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/modules/audio_coding/neteq/include/neteq.h"
12 #include "webrtc/modules/audio_coding/neteq/neteq_impl.h"
13
14 #include "testing/gmock/include/gmock/gmock.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16 #include "webrtc/base/safe_conversions.h"
17 #include "webrtc/modules/audio_coding/neteq/accelerate.h"
18 #include "webrtc/modules/audio_coding/neteq/expand.h"
19 #include "webrtc/modules/audio_coding/neteq/mock/mock_audio_decoder.h"
20 #include "webrtc/modules/audio_coding/neteq/mock/mock_buffer_level_filter.h"
21 #include "webrtc/modules/audio_coding/neteq/mock/mock_decoder_database.h"
22 #include "webrtc/modules/audio_coding/neteq/mock/mock_delay_manager.h"
23 #include "webrtc/modules/audio_coding/neteq/mock/mock_delay_peak_detector.h"
24 #include "webrtc/modules/audio_coding/neteq/mock/mock_dtmf_buffer.h"
25 #include "webrtc/modules/audio_coding/neteq/mock/mock_dtmf_tone_generator.h"
26 #include "webrtc/modules/audio_coding/neteq/mock/mock_packet_buffer.h"
27 #include "webrtc/modules/audio_coding/neteq/mock/mock_payload_splitter.h"
28 #include "webrtc/modules/audio_coding/neteq/preemptive_expand.h"
29 #include "webrtc/modules/audio_coding/neteq/sync_buffer.h"
30 #include "webrtc/modules/audio_coding/neteq/timestamp_scaler.h"
31
32 using ::testing::AtLeast;
33 using ::testing::Return;
34 using ::testing::ReturnNull;
35 using ::testing::_;
36 using ::testing::SetArgPointee;
37 using ::testing::SetArrayArgument;
38 using ::testing::InSequence;
39 using ::testing::Invoke;
40 using ::testing::WithArg;
41 using ::testing::Pointee;
42 using ::testing::IsNull;
43
44 namespace webrtc {
45
46 // This function is called when inserting a packet list into the mock packet
47 // buffer. The purpose is to delete all inserted packets properly, to avoid
48 // memory leaks in the test.
DeletePacketsAndReturnOk(PacketList * packet_list)49 int DeletePacketsAndReturnOk(PacketList* packet_list) {
50 PacketBuffer::DeleteAllPackets(packet_list);
51 return PacketBuffer::kOK;
52 }
53
54 class NetEqImplTest : public ::testing::Test {
55 protected:
NetEqImplTest()56 NetEqImplTest()
57 : neteq_(NULL),
58 config_(),
59 mock_buffer_level_filter_(NULL),
60 buffer_level_filter_(NULL),
61 use_mock_buffer_level_filter_(true),
62 mock_decoder_database_(NULL),
63 decoder_database_(NULL),
64 use_mock_decoder_database_(true),
65 mock_delay_peak_detector_(NULL),
66 delay_peak_detector_(NULL),
67 use_mock_delay_peak_detector_(true),
68 mock_delay_manager_(NULL),
69 delay_manager_(NULL),
70 use_mock_delay_manager_(true),
71 mock_dtmf_buffer_(NULL),
72 dtmf_buffer_(NULL),
73 use_mock_dtmf_buffer_(true),
74 mock_dtmf_tone_generator_(NULL),
75 dtmf_tone_generator_(NULL),
76 use_mock_dtmf_tone_generator_(true),
77 mock_packet_buffer_(NULL),
78 packet_buffer_(NULL),
79 use_mock_packet_buffer_(true),
80 mock_payload_splitter_(NULL),
81 payload_splitter_(NULL),
82 use_mock_payload_splitter_(true),
83 timestamp_scaler_(NULL) {
84 config_.sample_rate_hz = 8000;
85 }
86
CreateInstance()87 void CreateInstance() {
88 if (use_mock_buffer_level_filter_) {
89 mock_buffer_level_filter_ = new MockBufferLevelFilter;
90 buffer_level_filter_ = mock_buffer_level_filter_;
91 } else {
92 buffer_level_filter_ = new BufferLevelFilter;
93 }
94 if (use_mock_decoder_database_) {
95 mock_decoder_database_ = new MockDecoderDatabase;
96 EXPECT_CALL(*mock_decoder_database_, GetActiveCngDecoder())
97 .WillOnce(ReturnNull());
98 decoder_database_ = mock_decoder_database_;
99 } else {
100 decoder_database_ = new DecoderDatabase;
101 }
102 if (use_mock_delay_peak_detector_) {
103 mock_delay_peak_detector_ = new MockDelayPeakDetector;
104 EXPECT_CALL(*mock_delay_peak_detector_, Reset()).Times(1);
105 delay_peak_detector_ = mock_delay_peak_detector_;
106 } else {
107 delay_peak_detector_ = new DelayPeakDetector;
108 }
109 if (use_mock_delay_manager_) {
110 mock_delay_manager_ = new MockDelayManager(config_.max_packets_in_buffer,
111 delay_peak_detector_);
112 EXPECT_CALL(*mock_delay_manager_, set_streaming_mode(false)).Times(1);
113 delay_manager_ = mock_delay_manager_;
114 } else {
115 delay_manager_ =
116 new DelayManager(config_.max_packets_in_buffer, delay_peak_detector_);
117 }
118 if (use_mock_dtmf_buffer_) {
119 mock_dtmf_buffer_ = new MockDtmfBuffer(config_.sample_rate_hz);
120 dtmf_buffer_ = mock_dtmf_buffer_;
121 } else {
122 dtmf_buffer_ = new DtmfBuffer(config_.sample_rate_hz);
123 }
124 if (use_mock_dtmf_tone_generator_) {
125 mock_dtmf_tone_generator_ = new MockDtmfToneGenerator;
126 dtmf_tone_generator_ = mock_dtmf_tone_generator_;
127 } else {
128 dtmf_tone_generator_ = new DtmfToneGenerator;
129 }
130 if (use_mock_packet_buffer_) {
131 mock_packet_buffer_ = new MockPacketBuffer(config_.max_packets_in_buffer);
132 packet_buffer_ = mock_packet_buffer_;
133 } else {
134 packet_buffer_ = new PacketBuffer(config_.max_packets_in_buffer);
135 }
136 if (use_mock_payload_splitter_) {
137 mock_payload_splitter_ = new MockPayloadSplitter;
138 payload_splitter_ = mock_payload_splitter_;
139 } else {
140 payload_splitter_ = new PayloadSplitter;
141 }
142 timestamp_scaler_ = new TimestampScaler(*decoder_database_);
143 AccelerateFactory* accelerate_factory = new AccelerateFactory;
144 ExpandFactory* expand_factory = new ExpandFactory;
145 PreemptiveExpandFactory* preemptive_expand_factory =
146 new PreemptiveExpandFactory;
147
148 neteq_ = new NetEqImpl(config_,
149 buffer_level_filter_,
150 decoder_database_,
151 delay_manager_,
152 delay_peak_detector_,
153 dtmf_buffer_,
154 dtmf_tone_generator_,
155 packet_buffer_,
156 payload_splitter_,
157 timestamp_scaler_,
158 accelerate_factory,
159 expand_factory,
160 preemptive_expand_factory);
161 ASSERT_TRUE(neteq_ != NULL);
162 }
163
UseNoMocks()164 void UseNoMocks() {
165 ASSERT_TRUE(neteq_ == NULL) << "Must call UseNoMocks before CreateInstance";
166 use_mock_buffer_level_filter_ = false;
167 use_mock_decoder_database_ = false;
168 use_mock_delay_peak_detector_ = false;
169 use_mock_delay_manager_ = false;
170 use_mock_dtmf_buffer_ = false;
171 use_mock_dtmf_tone_generator_ = false;
172 use_mock_packet_buffer_ = false;
173 use_mock_payload_splitter_ = false;
174 }
175
~NetEqImplTest()176 virtual ~NetEqImplTest() {
177 if (use_mock_buffer_level_filter_) {
178 EXPECT_CALL(*mock_buffer_level_filter_, Die()).Times(1);
179 }
180 if (use_mock_decoder_database_) {
181 EXPECT_CALL(*mock_decoder_database_, Die()).Times(1);
182 }
183 if (use_mock_delay_manager_) {
184 EXPECT_CALL(*mock_delay_manager_, Die()).Times(1);
185 }
186 if (use_mock_delay_peak_detector_) {
187 EXPECT_CALL(*mock_delay_peak_detector_, Die()).Times(1);
188 }
189 if (use_mock_dtmf_buffer_) {
190 EXPECT_CALL(*mock_dtmf_buffer_, Die()).Times(1);
191 }
192 if (use_mock_dtmf_tone_generator_) {
193 EXPECT_CALL(*mock_dtmf_tone_generator_, Die()).Times(1);
194 }
195 if (use_mock_packet_buffer_) {
196 EXPECT_CALL(*mock_packet_buffer_, Die()).Times(1);
197 }
198 delete neteq_;
199 }
200
201 NetEqImpl* neteq_;
202 NetEq::Config config_;
203 MockBufferLevelFilter* mock_buffer_level_filter_;
204 BufferLevelFilter* buffer_level_filter_;
205 bool use_mock_buffer_level_filter_;
206 MockDecoderDatabase* mock_decoder_database_;
207 DecoderDatabase* decoder_database_;
208 bool use_mock_decoder_database_;
209 MockDelayPeakDetector* mock_delay_peak_detector_;
210 DelayPeakDetector* delay_peak_detector_;
211 bool use_mock_delay_peak_detector_;
212 MockDelayManager* mock_delay_manager_;
213 DelayManager* delay_manager_;
214 bool use_mock_delay_manager_;
215 MockDtmfBuffer* mock_dtmf_buffer_;
216 DtmfBuffer* dtmf_buffer_;
217 bool use_mock_dtmf_buffer_;
218 MockDtmfToneGenerator* mock_dtmf_tone_generator_;
219 DtmfToneGenerator* dtmf_tone_generator_;
220 bool use_mock_dtmf_tone_generator_;
221 MockPacketBuffer* mock_packet_buffer_;
222 PacketBuffer* packet_buffer_;
223 bool use_mock_packet_buffer_;
224 MockPayloadSplitter* mock_payload_splitter_;
225 PayloadSplitter* payload_splitter_;
226 bool use_mock_payload_splitter_;
227 TimestampScaler* timestamp_scaler_;
228 };
229
230
231 // This tests the interface class NetEq.
232 // TODO(hlundin): Move to separate file?
TEST(NetEq,CreateAndDestroy)233 TEST(NetEq, CreateAndDestroy) {
234 NetEq::Config config;
235 NetEq* neteq = NetEq::Create(config);
236 delete neteq;
237 }
238
TEST_F(NetEqImplTest,RegisterPayloadType)239 TEST_F(NetEqImplTest, RegisterPayloadType) {
240 CreateInstance();
241 uint8_t rtp_payload_type = 0;
242 NetEqDecoder codec_type = NetEqDecoder::kDecoderPCMu;
243 const std::string kCodecName = "Robert\'); DROP TABLE Students;";
244 EXPECT_CALL(*mock_decoder_database_,
245 RegisterPayload(rtp_payload_type, codec_type, kCodecName));
246 neteq_->RegisterPayloadType(codec_type, kCodecName, rtp_payload_type);
247 }
248
TEST_F(NetEqImplTest,RemovePayloadType)249 TEST_F(NetEqImplTest, RemovePayloadType) {
250 CreateInstance();
251 uint8_t rtp_payload_type = 0;
252 EXPECT_CALL(*mock_decoder_database_, Remove(rtp_payload_type))
253 .WillOnce(Return(DecoderDatabase::kDecoderNotFound));
254 // Check that kFail is returned when database returns kDecoderNotFound.
255 EXPECT_EQ(NetEq::kFail, neteq_->RemovePayloadType(rtp_payload_type));
256 }
257
TEST_F(NetEqImplTest,InsertPacket)258 TEST_F(NetEqImplTest, InsertPacket) {
259 CreateInstance();
260 const size_t kPayloadLength = 100;
261 const uint8_t kPayloadType = 0;
262 const uint16_t kFirstSequenceNumber = 0x1234;
263 const uint32_t kFirstTimestamp = 0x12345678;
264 const uint32_t kSsrc = 0x87654321;
265 const uint32_t kFirstReceiveTime = 17;
266 uint8_t payload[kPayloadLength] = {0};
267 WebRtcRTPHeader rtp_header;
268 rtp_header.header.payloadType = kPayloadType;
269 rtp_header.header.sequenceNumber = kFirstSequenceNumber;
270 rtp_header.header.timestamp = kFirstTimestamp;
271 rtp_header.header.ssrc = kSsrc;
272
273 // Create a mock decoder object.
274 MockAudioDecoder mock_decoder;
275 EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
276 // BWE update function called with first packet.
277 EXPECT_CALL(mock_decoder, IncomingPacket(_,
278 kPayloadLength,
279 kFirstSequenceNumber,
280 kFirstTimestamp,
281 kFirstReceiveTime));
282 // BWE update function called with second packet.
283 EXPECT_CALL(mock_decoder, IncomingPacket(_,
284 kPayloadLength,
285 kFirstSequenceNumber + 1,
286 kFirstTimestamp + 160,
287 kFirstReceiveTime + 155));
288 EXPECT_CALL(mock_decoder, Die()).Times(1); // Called when deleted.
289
290 // Expectations for decoder database.
291 EXPECT_CALL(*mock_decoder_database_, IsRed(kPayloadType))
292 .WillRepeatedly(Return(false)); // This is not RED.
293 EXPECT_CALL(*mock_decoder_database_, CheckPayloadTypes(_))
294 .Times(2)
295 .WillRepeatedly(Return(DecoderDatabase::kOK)); // Payload type is valid.
296 EXPECT_CALL(*mock_decoder_database_, IsDtmf(kPayloadType))
297 .WillRepeatedly(Return(false)); // This is not DTMF.
298 EXPECT_CALL(*mock_decoder_database_, GetDecoder(kPayloadType))
299 .Times(3)
300 .WillRepeatedly(Return(&mock_decoder));
301 EXPECT_CALL(*mock_decoder_database_, IsComfortNoise(kPayloadType))
302 .WillRepeatedly(Return(false)); // This is not CNG.
303 DecoderDatabase::DecoderInfo info;
304 info.codec_type = NetEqDecoder::kDecoderPCMu;
305 EXPECT_CALL(*mock_decoder_database_, GetDecoderInfo(kPayloadType))
306 .WillRepeatedly(Return(&info));
307
308 // Expectations for packet buffer.
309 EXPECT_CALL(*mock_packet_buffer_, NumPacketsInBuffer())
310 .WillOnce(Return(0)) // First packet.
311 .WillOnce(Return(1)) // Second packet.
312 .WillOnce(Return(2)); // Second packet, checking after it was inserted.
313 EXPECT_CALL(*mock_packet_buffer_, Empty())
314 .WillOnce(Return(false)); // Called once after first packet is inserted.
315 EXPECT_CALL(*mock_packet_buffer_, Flush())
316 .Times(1);
317 EXPECT_CALL(*mock_packet_buffer_, InsertPacketList(_, _, _, _))
318 .Times(2)
319 .WillRepeatedly(DoAll(SetArgPointee<2>(kPayloadType),
320 WithArg<0>(Invoke(DeletePacketsAndReturnOk))));
321 // SetArgPointee<2>(kPayloadType) means that the third argument (zero-based
322 // index) is a pointer, and the variable pointed to is set to kPayloadType.
323 // Also invoke the function DeletePacketsAndReturnOk to properly delete all
324 // packets in the list (to avoid memory leaks in the test).
325 EXPECT_CALL(*mock_packet_buffer_, NextRtpHeader())
326 .Times(1)
327 .WillOnce(Return(&rtp_header.header));
328
329 // Expectations for DTMF buffer.
330 EXPECT_CALL(*mock_dtmf_buffer_, Flush())
331 .Times(1);
332
333 // Expectations for delay manager.
334 {
335 // All expectations within this block must be called in this specific order.
336 InSequence sequence; // Dummy variable.
337 // Expectations when the first packet is inserted.
338 EXPECT_CALL(*mock_delay_manager_,
339 LastDecoderType(NetEqDecoder::kDecoderPCMu))
340 .Times(1);
341 EXPECT_CALL(*mock_delay_manager_, last_pack_cng_or_dtmf())
342 .Times(2)
343 .WillRepeatedly(Return(-1));
344 EXPECT_CALL(*mock_delay_manager_, set_last_pack_cng_or_dtmf(0))
345 .Times(1);
346 EXPECT_CALL(*mock_delay_manager_, ResetPacketIatCount()).Times(1);
347 // Expectations when the second packet is inserted. Slightly different.
348 EXPECT_CALL(*mock_delay_manager_,
349 LastDecoderType(NetEqDecoder::kDecoderPCMu))
350 .Times(1);
351 EXPECT_CALL(*mock_delay_manager_, last_pack_cng_or_dtmf())
352 .WillOnce(Return(0));
353 EXPECT_CALL(*mock_delay_manager_, SetPacketAudioLength(30))
354 .WillOnce(Return(0));
355 }
356
357 // Expectations for payload splitter.
358 EXPECT_CALL(*mock_payload_splitter_, SplitAudio(_, _))
359 .Times(2)
360 .WillRepeatedly(Return(PayloadSplitter::kOK));
361
362 // Insert first packet.
363 neteq_->InsertPacket(rtp_header, payload, kFirstReceiveTime);
364
365 // Insert second packet.
366 rtp_header.header.timestamp += 160;
367 rtp_header.header.sequenceNumber += 1;
368 neteq_->InsertPacket(rtp_header, payload, kFirstReceiveTime + 155);
369 }
370
TEST_F(NetEqImplTest,InsertPacketsUntilBufferIsFull)371 TEST_F(NetEqImplTest, InsertPacketsUntilBufferIsFull) {
372 UseNoMocks();
373 CreateInstance();
374
375 const int kPayloadLengthSamples = 80;
376 const size_t kPayloadLengthBytes = 2 * kPayloadLengthSamples; // PCM 16-bit.
377 const uint8_t kPayloadType = 17; // Just an arbitrary number.
378 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
379 uint8_t payload[kPayloadLengthBytes] = {0};
380 WebRtcRTPHeader rtp_header;
381 rtp_header.header.payloadType = kPayloadType;
382 rtp_header.header.sequenceNumber = 0x1234;
383 rtp_header.header.timestamp = 0x12345678;
384 rtp_header.header.ssrc = 0x87654321;
385
386 EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
387 NetEqDecoder::kDecoderPCM16B, "", kPayloadType));
388
389 // Insert packets. The buffer should not flush.
390 for (size_t i = 1; i <= config_.max_packets_in_buffer; ++i) {
391 EXPECT_EQ(NetEq::kOK,
392 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
393 rtp_header.header.timestamp += kPayloadLengthSamples;
394 rtp_header.header.sequenceNumber += 1;
395 EXPECT_EQ(i, packet_buffer_->NumPacketsInBuffer());
396 }
397
398 // Insert one more packet and make sure the buffer got flushed. That is, it
399 // should only hold one single packet.
400 EXPECT_EQ(NetEq::kOK,
401 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
402 EXPECT_EQ(1u, packet_buffer_->NumPacketsInBuffer());
403 const RTPHeader* test_header = packet_buffer_->NextRtpHeader();
404 EXPECT_EQ(rtp_header.header.timestamp, test_header->timestamp);
405 EXPECT_EQ(rtp_header.header.sequenceNumber, test_header->sequenceNumber);
406 }
407
408 // This test verifies that timestamps propagate from the incoming packets
409 // through to the sync buffer and to the playout timestamp.
TEST_F(NetEqImplTest,VerifyTimestampPropagation)410 TEST_F(NetEqImplTest, VerifyTimestampPropagation) {
411 UseNoMocks();
412 CreateInstance();
413
414 const uint8_t kPayloadType = 17; // Just an arbitrary number.
415 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
416 const int kSampleRateHz = 8000;
417 const size_t kPayloadLengthSamples =
418 static_cast<size_t>(10 * kSampleRateHz / 1000); // 10 ms.
419 const size_t kPayloadLengthBytes = kPayloadLengthSamples;
420 uint8_t payload[kPayloadLengthBytes] = {0};
421 WebRtcRTPHeader rtp_header;
422 rtp_header.header.payloadType = kPayloadType;
423 rtp_header.header.sequenceNumber = 0x1234;
424 rtp_header.header.timestamp = 0x12345678;
425 rtp_header.header.ssrc = 0x87654321;
426
427 // This is a dummy decoder that produces as many output samples as the input
428 // has bytes. The output is an increasing series, starting at 1 for the first
429 // sample, and then increasing by 1 for each sample.
430 class CountingSamplesDecoder : public AudioDecoder {
431 public:
432 CountingSamplesDecoder() : next_value_(1) {}
433
434 // Produce as many samples as input bytes (|encoded_len|).
435 int DecodeInternal(const uint8_t* encoded,
436 size_t encoded_len,
437 int /* sample_rate_hz */,
438 int16_t* decoded,
439 SpeechType* speech_type) override {
440 for (size_t i = 0; i < encoded_len; ++i) {
441 decoded[i] = next_value_++;
442 }
443 *speech_type = kSpeech;
444 return encoded_len;
445 }
446
447 void Reset() override { next_value_ = 1; }
448
449 size_t Channels() const override { return 1; }
450
451 uint16_t next_value() const { return next_value_; }
452
453 private:
454 int16_t next_value_;
455 } decoder_;
456
457 EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
458 &decoder_, NetEqDecoder::kDecoderPCM16B,
459 "dummy name", kPayloadType, kSampleRateHz));
460
461 // Insert one packet.
462 EXPECT_EQ(NetEq::kOK,
463 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
464
465 // Pull audio once.
466 const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
467 int16_t output[kMaxOutputSize];
468 size_t samples_per_channel;
469 size_t num_channels;
470 NetEqOutputType type;
471 EXPECT_EQ(
472 NetEq::kOK,
473 neteq_->GetAudio(
474 kMaxOutputSize, output, &samples_per_channel, &num_channels, &type));
475 ASSERT_EQ(kMaxOutputSize, samples_per_channel);
476 EXPECT_EQ(1u, num_channels);
477 EXPECT_EQ(kOutputNormal, type);
478
479 // Start with a simple check that the fake decoder is behaving as expected.
480 EXPECT_EQ(kPayloadLengthSamples,
481 static_cast<size_t>(decoder_.next_value() - 1));
482
483 // The value of the last of the output samples is the same as the number of
484 // samples played from the decoded packet. Thus, this number + the RTP
485 // timestamp should match the playout timestamp.
486 uint32_t timestamp = 0;
487 EXPECT_TRUE(neteq_->GetPlayoutTimestamp(×tamp));
488 EXPECT_EQ(rtp_header.header.timestamp + output[samples_per_channel - 1],
489 timestamp);
490
491 // Check the timestamp for the last value in the sync buffer. This should
492 // be one full frame length ahead of the RTP timestamp.
493 const SyncBuffer* sync_buffer = neteq_->sync_buffer_for_test();
494 ASSERT_TRUE(sync_buffer != NULL);
495 EXPECT_EQ(rtp_header.header.timestamp + kPayloadLengthSamples,
496 sync_buffer->end_timestamp());
497
498 // Check that the number of samples still to play from the sync buffer add
499 // up with what was already played out.
500 EXPECT_EQ(kPayloadLengthSamples - output[samples_per_channel - 1],
501 sync_buffer->FutureLength());
502 }
503
TEST_F(NetEqImplTest,ReorderedPacket)504 TEST_F(NetEqImplTest, ReorderedPacket) {
505 UseNoMocks();
506 CreateInstance();
507
508 const uint8_t kPayloadType = 17; // Just an arbitrary number.
509 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
510 const int kSampleRateHz = 8000;
511 const size_t kPayloadLengthSamples =
512 static_cast<size_t>(10 * kSampleRateHz / 1000); // 10 ms.
513 const size_t kPayloadLengthBytes = kPayloadLengthSamples;
514 uint8_t payload[kPayloadLengthBytes] = {0};
515 WebRtcRTPHeader rtp_header;
516 rtp_header.header.payloadType = kPayloadType;
517 rtp_header.header.sequenceNumber = 0x1234;
518 rtp_header.header.timestamp = 0x12345678;
519 rtp_header.header.ssrc = 0x87654321;
520
521 // Create a mock decoder object.
522 MockAudioDecoder mock_decoder;
523 EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
524 EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
525 EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
526 .WillRepeatedly(Return(0));
527 int16_t dummy_output[kPayloadLengthSamples] = {0};
528 // The below expectation will make the mock decoder write
529 // |kPayloadLengthSamples| zeros to the output array, and mark it as speech.
530 EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(0), kPayloadLengthBytes,
531 kSampleRateHz, _, _))
532 .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
533 dummy_output + kPayloadLengthSamples),
534 SetArgPointee<4>(AudioDecoder::kSpeech),
535 Return(kPayloadLengthSamples)));
536 EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
537 &mock_decoder, NetEqDecoder::kDecoderPCM16B,
538 "dummy name", kPayloadType, kSampleRateHz));
539
540 // Insert one packet.
541 EXPECT_EQ(NetEq::kOK,
542 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
543
544 // Pull audio once.
545 const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
546 int16_t output[kMaxOutputSize];
547 size_t samples_per_channel;
548 size_t num_channels;
549 NetEqOutputType type;
550 EXPECT_EQ(
551 NetEq::kOK,
552 neteq_->GetAudio(
553 kMaxOutputSize, output, &samples_per_channel, &num_channels, &type));
554 ASSERT_EQ(kMaxOutputSize, samples_per_channel);
555 EXPECT_EQ(1u, num_channels);
556 EXPECT_EQ(kOutputNormal, type);
557
558 // Insert two more packets. The first one is out of order, and is already too
559 // old, the second one is the expected next packet.
560 rtp_header.header.sequenceNumber -= 1;
561 rtp_header.header.timestamp -= kPayloadLengthSamples;
562 payload[0] = 1;
563 EXPECT_EQ(NetEq::kOK,
564 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
565 rtp_header.header.sequenceNumber += 2;
566 rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
567 payload[0] = 2;
568 EXPECT_EQ(NetEq::kOK,
569 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
570
571 // Expect only the second packet to be decoded (the one with "2" as the first
572 // payload byte).
573 EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(2), kPayloadLengthBytes,
574 kSampleRateHz, _, _))
575 .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
576 dummy_output + kPayloadLengthSamples),
577 SetArgPointee<4>(AudioDecoder::kSpeech),
578 Return(kPayloadLengthSamples)));
579
580 // Pull audio once.
581 EXPECT_EQ(
582 NetEq::kOK,
583 neteq_->GetAudio(
584 kMaxOutputSize, output, &samples_per_channel, &num_channels, &type));
585 ASSERT_EQ(kMaxOutputSize, samples_per_channel);
586 EXPECT_EQ(1u, num_channels);
587 EXPECT_EQ(kOutputNormal, type);
588
589 // Now check the packet buffer, and make sure it is empty, since the
590 // out-of-order packet should have been discarded.
591 EXPECT_TRUE(packet_buffer_->Empty());
592
593 EXPECT_CALL(mock_decoder, Die());
594 }
595
596 // This test verifies that NetEq can handle the situation where the first
597 // incoming packet is rejected.
TEST_F(NetEqImplTest,FirstPacketUnknown)598 TEST_F(NetEqImplTest, FirstPacketUnknown) {
599 UseNoMocks();
600 CreateInstance();
601
602 const uint8_t kPayloadType = 17; // Just an arbitrary number.
603 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
604 const int kSampleRateHz = 8000;
605 const size_t kPayloadLengthSamples =
606 static_cast<size_t>(10 * kSampleRateHz / 1000); // 10 ms.
607 const size_t kPayloadLengthBytes = kPayloadLengthSamples;
608 uint8_t payload[kPayloadLengthBytes] = {0};
609 WebRtcRTPHeader rtp_header;
610 rtp_header.header.payloadType = kPayloadType;
611 rtp_header.header.sequenceNumber = 0x1234;
612 rtp_header.header.timestamp = 0x12345678;
613 rtp_header.header.ssrc = 0x87654321;
614
615 // Insert one packet. Note that we have not registered any payload type, so
616 // this packet will be rejected.
617 EXPECT_EQ(NetEq::kFail,
618 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
619 EXPECT_EQ(NetEq::kUnknownRtpPayloadType, neteq_->LastError());
620
621 // Pull audio once.
622 const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
623 int16_t output[kMaxOutputSize];
624 size_t samples_per_channel;
625 size_t num_channels;
626 NetEqOutputType type;
627 EXPECT_EQ(NetEq::kOK,
628 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
629 &num_channels, &type));
630 ASSERT_LE(samples_per_channel, kMaxOutputSize);
631 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
632 EXPECT_EQ(1u, num_channels);
633 EXPECT_EQ(kOutputPLC, type);
634
635 // Register the payload type.
636 EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
637 NetEqDecoder::kDecoderPCM16B, "", kPayloadType));
638
639 // Insert 10 packets.
640 for (size_t i = 0; i < 10; ++i) {
641 rtp_header.header.sequenceNumber++;
642 rtp_header.header.timestamp += kPayloadLengthSamples;
643 EXPECT_EQ(NetEq::kOK,
644 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
645 EXPECT_EQ(i + 1, packet_buffer_->NumPacketsInBuffer());
646 }
647
648 // Pull audio repeatedly and make sure we get normal output, that is not PLC.
649 for (size_t i = 0; i < 3; ++i) {
650 EXPECT_EQ(NetEq::kOK,
651 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
652 &num_channels, &type));
653 ASSERT_LE(samples_per_channel, kMaxOutputSize);
654 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
655 EXPECT_EQ(1u, num_channels);
656 EXPECT_EQ(kOutputNormal, type)
657 << "NetEq did not decode the packets as expected.";
658 }
659 }
660
661 // This test verifies that NetEq can handle comfort noise and enters/quits codec
662 // internal CNG mode properly.
TEST_F(NetEqImplTest,CodecInternalCng)663 TEST_F(NetEqImplTest, CodecInternalCng) {
664 UseNoMocks();
665 CreateInstance();
666
667 const uint8_t kPayloadType = 17; // Just an arbitrary number.
668 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
669 const int kSampleRateKhz = 48;
670 const size_t kPayloadLengthSamples =
671 static_cast<size_t>(20 * kSampleRateKhz); // 20 ms.
672 const size_t kPayloadLengthBytes = 10;
673 uint8_t payload[kPayloadLengthBytes] = {0};
674 int16_t dummy_output[kPayloadLengthSamples] = {0};
675
676 WebRtcRTPHeader rtp_header;
677 rtp_header.header.payloadType = kPayloadType;
678 rtp_header.header.sequenceNumber = 0x1234;
679 rtp_header.header.timestamp = 0x12345678;
680 rtp_header.header.ssrc = 0x87654321;
681
682 // Create a mock decoder object.
683 MockAudioDecoder mock_decoder;
684 EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
685 EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
686 EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
687 .WillRepeatedly(Return(0));
688
689 // Pointee(x) verifies that first byte of the payload equals x, this makes it
690 // possible to verify that the correct payload is fed to Decode().
691 EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(0), kPayloadLengthBytes,
692 kSampleRateKhz * 1000, _, _))
693 .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
694 dummy_output + kPayloadLengthSamples),
695 SetArgPointee<4>(AudioDecoder::kSpeech),
696 Return(kPayloadLengthSamples)));
697
698 EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(1), kPayloadLengthBytes,
699 kSampleRateKhz * 1000, _, _))
700 .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
701 dummy_output + kPayloadLengthSamples),
702 SetArgPointee<4>(AudioDecoder::kComfortNoise),
703 Return(kPayloadLengthSamples)));
704
705 EXPECT_CALL(mock_decoder,
706 DecodeInternal(IsNull(), 0, kSampleRateKhz * 1000, _, _))
707 .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
708 dummy_output + kPayloadLengthSamples),
709 SetArgPointee<4>(AudioDecoder::kComfortNoise),
710 Return(kPayloadLengthSamples)));
711
712 EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(2), kPayloadLengthBytes,
713 kSampleRateKhz * 1000, _, _))
714 .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
715 dummy_output + kPayloadLengthSamples),
716 SetArgPointee<4>(AudioDecoder::kSpeech),
717 Return(kPayloadLengthSamples)));
718
719 EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
720 &mock_decoder, NetEqDecoder::kDecoderOpus,
721 "dummy name", kPayloadType, kSampleRateKhz * 1000));
722
723 // Insert one packet (decoder will return speech).
724 EXPECT_EQ(NetEq::kOK,
725 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
726
727 // Insert second packet (decoder will return CNG).
728 payload[0] = 1;
729 rtp_header.header.sequenceNumber++;
730 rtp_header.header.timestamp += kPayloadLengthSamples;
731 EXPECT_EQ(NetEq::kOK,
732 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
733
734 const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateKhz);
735 int16_t output[kMaxOutputSize];
736 size_t samples_per_channel;
737 size_t num_channels;
738 uint32_t timestamp;
739 uint32_t last_timestamp;
740 NetEqOutputType type;
741 NetEqOutputType expected_type[8] = {
742 kOutputNormal, kOutputNormal,
743 kOutputCNG, kOutputCNG,
744 kOutputCNG, kOutputCNG,
745 kOutputNormal, kOutputNormal
746 };
747 int expected_timestamp_increment[8] = {
748 -1, // will not be used.
749 10 * kSampleRateKhz,
750 0, 0, // timestamp does not increase during CNG mode.
751 0, 0,
752 50 * kSampleRateKhz, 10 * kSampleRateKhz
753 };
754
755 EXPECT_EQ(NetEq::kOK,
756 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
757 &num_channels, &type));
758 EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&last_timestamp));
759
760 for (size_t i = 1; i < 6; ++i) {
761 ASSERT_EQ(kMaxOutputSize, samples_per_channel);
762 EXPECT_EQ(1u, num_channels);
763 EXPECT_EQ(expected_type[i - 1], type);
764 EXPECT_TRUE(neteq_->GetPlayoutTimestamp(×tamp));
765 EXPECT_EQ(NetEq::kOK,
766 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
767 &num_channels, &type));
768 EXPECT_TRUE(neteq_->GetPlayoutTimestamp(×tamp));
769 EXPECT_EQ(timestamp, last_timestamp + expected_timestamp_increment[i]);
770 last_timestamp = timestamp;
771 }
772
773 // Insert third packet, which leaves a gap from last packet.
774 payload[0] = 2;
775 rtp_header.header.sequenceNumber += 2;
776 rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
777 EXPECT_EQ(NetEq::kOK,
778 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
779
780 for (size_t i = 6; i < 8; ++i) {
781 ASSERT_EQ(kMaxOutputSize, samples_per_channel);
782 EXPECT_EQ(1u, num_channels);
783 EXPECT_EQ(expected_type[i - 1], type);
784 EXPECT_EQ(NetEq::kOK,
785 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
786 &num_channels, &type));
787 EXPECT_TRUE(neteq_->GetPlayoutTimestamp(×tamp));
788 EXPECT_EQ(timestamp, last_timestamp + expected_timestamp_increment[i]);
789 last_timestamp = timestamp;
790 }
791
792 // Now check the packet buffer, and make sure it is empty.
793 EXPECT_TRUE(packet_buffer_->Empty());
794
795 EXPECT_CALL(mock_decoder, Die());
796 }
797
TEST_F(NetEqImplTest,UnsupportedDecoder)798 TEST_F(NetEqImplTest, UnsupportedDecoder) {
799 UseNoMocks();
800 CreateInstance();
801 static const size_t kNetEqMaxFrameSize = 2880; // 60 ms @ 48 kHz.
802 static const size_t kChannels = 2;
803
804 const uint8_t kPayloadType = 17; // Just an arbitrary number.
805 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
806 const int kSampleRateHz = 8000;
807
808 const size_t kPayloadLengthSamples =
809 static_cast<size_t>(10 * kSampleRateHz / 1000); // 10 ms.
810 const size_t kPayloadLengthBytes = 1;
811 uint8_t payload[kPayloadLengthBytes]= {0};
812 int16_t dummy_output[kPayloadLengthSamples * kChannels] = {0};
813 WebRtcRTPHeader rtp_header;
814 rtp_header.header.payloadType = kPayloadType;
815 rtp_header.header.sequenceNumber = 0x1234;
816 rtp_header.header.timestamp = 0x12345678;
817 rtp_header.header.ssrc = 0x87654321;
818
819 class MockAudioDecoder : public AudioDecoder {
820 public:
821 void Reset() override {}
822 MOCK_CONST_METHOD2(PacketDuration, int(const uint8_t*, size_t));
823 MOCK_METHOD5(DecodeInternal, int(const uint8_t*, size_t, int, int16_t*,
824 SpeechType*));
825 size_t Channels() const override { return kChannels; }
826 } decoder_;
827
828 const uint8_t kFirstPayloadValue = 1;
829 const uint8_t kSecondPayloadValue = 2;
830
831 EXPECT_CALL(decoder_, PacketDuration(Pointee(kFirstPayloadValue),
832 kPayloadLengthBytes))
833 .Times(AtLeast(1))
834 .WillRepeatedly(Return(kNetEqMaxFrameSize + 1));
835
836 EXPECT_CALL(decoder_,
837 DecodeInternal(Pointee(kFirstPayloadValue), _, _, _, _))
838 .Times(0);
839
840 EXPECT_CALL(decoder_, DecodeInternal(Pointee(kSecondPayloadValue),
841 kPayloadLengthBytes,
842 kSampleRateHz, _, _))
843 .Times(1)
844 .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
845 dummy_output +
846 kPayloadLengthSamples * kChannels),
847 SetArgPointee<4>(AudioDecoder::kSpeech),
848 Return(static_cast<int>(
849 kPayloadLengthSamples * kChannels))));
850
851 EXPECT_CALL(decoder_, PacketDuration(Pointee(kSecondPayloadValue),
852 kPayloadLengthBytes))
853 .Times(AtLeast(1))
854 .WillRepeatedly(Return(kNetEqMaxFrameSize));
855
856 EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
857 &decoder_, NetEqDecoder::kDecoderPCM16B,
858 "dummy name", kPayloadType, kSampleRateHz));
859
860 // Insert one packet.
861 payload[0] = kFirstPayloadValue; // This will make Decode() fail.
862 EXPECT_EQ(NetEq::kOK,
863 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
864
865 // Insert another packet.
866 payload[0] = kSecondPayloadValue; // This will make Decode() successful.
867 rtp_header.header.sequenceNumber++;
868 // The second timestamp needs to be at least 30 ms after the first to make
869 // the second packet get decoded.
870 rtp_header.header.timestamp += 3 * kPayloadLengthSamples;
871 EXPECT_EQ(NetEq::kOK,
872 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
873
874 const size_t kMaxOutputSize = 10 * kSampleRateHz / 1000 * kChannels;
875 int16_t output[kMaxOutputSize];
876 size_t samples_per_channel;
877 size_t num_channels;
878 NetEqOutputType type;
879
880 EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(kMaxOutputSize, output,
881 &samples_per_channel, &num_channels,
882 &type));
883 EXPECT_EQ(NetEq::kOtherDecoderError, neteq_->LastError());
884 EXPECT_EQ(kMaxOutputSize, samples_per_channel * kChannels);
885 EXPECT_EQ(kChannels, num_channels);
886
887 EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(kMaxOutputSize, output,
888 &samples_per_channel, &num_channels,
889 &type));
890 EXPECT_EQ(kMaxOutputSize, samples_per_channel * kChannels);
891 EXPECT_EQ(kChannels, num_channels);
892 }
893
894 // This test inserts packets until the buffer is flushed. After that, it asks
895 // NetEq for the network statistics. The purpose of the test is to make sure
896 // that even though the buffer size increment is negative (which it becomes when
897 // the packet causing a flush is inserted), the packet length stored in the
898 // decision logic remains valid.
TEST_F(NetEqImplTest,FloodBufferAndGetNetworkStats)899 TEST_F(NetEqImplTest, FloodBufferAndGetNetworkStats) {
900 UseNoMocks();
901 CreateInstance();
902
903 const size_t kPayloadLengthSamples = 80;
904 const size_t kPayloadLengthBytes = 2 * kPayloadLengthSamples; // PCM 16-bit.
905 const uint8_t kPayloadType = 17; // Just an arbitrary number.
906 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
907 uint8_t payload[kPayloadLengthBytes] = {0};
908 WebRtcRTPHeader rtp_header;
909 rtp_header.header.payloadType = kPayloadType;
910 rtp_header.header.sequenceNumber = 0x1234;
911 rtp_header.header.timestamp = 0x12345678;
912 rtp_header.header.ssrc = 0x87654321;
913
914 EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
915 NetEqDecoder::kDecoderPCM16B, "", kPayloadType));
916
917 // Insert packets until the buffer flushes.
918 for (size_t i = 0; i <= config_.max_packets_in_buffer; ++i) {
919 EXPECT_EQ(i, packet_buffer_->NumPacketsInBuffer());
920 EXPECT_EQ(NetEq::kOK,
921 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
922 rtp_header.header.timestamp +=
923 rtc::checked_cast<uint32_t>(kPayloadLengthSamples);
924 ++rtp_header.header.sequenceNumber;
925 }
926 EXPECT_EQ(1u, packet_buffer_->NumPacketsInBuffer());
927
928 // Ask for network statistics. This should not crash.
929 NetEqNetworkStatistics stats;
930 EXPECT_EQ(NetEq::kOK, neteq_->NetworkStatistics(&stats));
931 }
932
TEST_F(NetEqImplTest,DecodedPayloadTooShort)933 TEST_F(NetEqImplTest, DecodedPayloadTooShort) {
934 UseNoMocks();
935 CreateInstance();
936
937 const uint8_t kPayloadType = 17; // Just an arbitrary number.
938 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
939 const int kSampleRateHz = 8000;
940 const size_t kPayloadLengthSamples =
941 static_cast<size_t>(10 * kSampleRateHz / 1000); // 10 ms.
942 const size_t kPayloadLengthBytes = 2 * kPayloadLengthSamples;
943 uint8_t payload[kPayloadLengthBytes] = {0};
944 WebRtcRTPHeader rtp_header;
945 rtp_header.header.payloadType = kPayloadType;
946 rtp_header.header.sequenceNumber = 0x1234;
947 rtp_header.header.timestamp = 0x12345678;
948 rtp_header.header.ssrc = 0x87654321;
949
950 // Create a mock decoder object.
951 MockAudioDecoder mock_decoder;
952 EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
953 EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
954 EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
955 .WillRepeatedly(Return(0));
956 EXPECT_CALL(mock_decoder, PacketDuration(_, _))
957 .WillRepeatedly(Return(kPayloadLengthSamples));
958 int16_t dummy_output[kPayloadLengthSamples] = {0};
959 // The below expectation will make the mock decoder write
960 // |kPayloadLengthSamples| - 5 zeros to the output array, and mark it as
961 // speech. That is, the decoded length is 5 samples shorter than the expected.
962 EXPECT_CALL(mock_decoder,
963 DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
964 .WillOnce(
965 DoAll(SetArrayArgument<3>(dummy_output,
966 dummy_output + kPayloadLengthSamples - 5),
967 SetArgPointee<4>(AudioDecoder::kSpeech),
968 Return(kPayloadLengthSamples - 5)));
969 EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
970 &mock_decoder, NetEqDecoder::kDecoderPCM16B,
971 "dummy name", kPayloadType, kSampleRateHz));
972
973 // Insert one packet.
974 EXPECT_EQ(NetEq::kOK,
975 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
976
977 EXPECT_EQ(5u, neteq_->sync_buffer_for_test()->FutureLength());
978
979 // Pull audio once.
980 const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
981 int16_t output[kMaxOutputSize];
982 size_t samples_per_channel;
983 size_t num_channels;
984 NetEqOutputType type;
985 EXPECT_EQ(NetEq::kOK,
986 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
987 &num_channels, &type));
988 ASSERT_EQ(kMaxOutputSize, samples_per_channel);
989 EXPECT_EQ(1u, num_channels);
990 EXPECT_EQ(kOutputNormal, type);
991
992 EXPECT_CALL(mock_decoder, Die());
993 }
994
995 // This test checks the behavior of NetEq when audio decoder fails.
TEST_F(NetEqImplTest,DecodingError)996 TEST_F(NetEqImplTest, DecodingError) {
997 UseNoMocks();
998 CreateInstance();
999
1000 const uint8_t kPayloadType = 17; // Just an arbitrary number.
1001 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
1002 const int kSampleRateHz = 8000;
1003 const int kDecoderErrorCode = -97; // Any negative number.
1004
1005 // We let decoder return 5 ms each time, and therefore, 2 packets make 10 ms.
1006 const size_t kFrameLengthSamples =
1007 static_cast<size_t>(5 * kSampleRateHz / 1000);
1008
1009 const size_t kPayloadLengthBytes = 1; // This can be arbitrary.
1010
1011 uint8_t payload[kPayloadLengthBytes] = {0};
1012
1013 WebRtcRTPHeader rtp_header;
1014 rtp_header.header.payloadType = kPayloadType;
1015 rtp_header.header.sequenceNumber = 0x1234;
1016 rtp_header.header.timestamp = 0x12345678;
1017 rtp_header.header.ssrc = 0x87654321;
1018
1019 // Create a mock decoder object.
1020 MockAudioDecoder mock_decoder;
1021 EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
1022 EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
1023 EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
1024 .WillRepeatedly(Return(0));
1025 EXPECT_CALL(mock_decoder, PacketDuration(_, _))
1026 .WillRepeatedly(Return(kFrameLengthSamples));
1027 EXPECT_CALL(mock_decoder, ErrorCode())
1028 .WillOnce(Return(kDecoderErrorCode));
1029 EXPECT_CALL(mock_decoder, HasDecodePlc())
1030 .WillOnce(Return(false));
1031 int16_t dummy_output[kFrameLengthSamples] = {0};
1032
1033 {
1034 InSequence sequence; // Dummy variable.
1035 // Mock decoder works normally the first time.
1036 EXPECT_CALL(mock_decoder,
1037 DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
1038 .Times(3)
1039 .WillRepeatedly(
1040 DoAll(SetArrayArgument<3>(dummy_output,
1041 dummy_output + kFrameLengthSamples),
1042 SetArgPointee<4>(AudioDecoder::kSpeech),
1043 Return(kFrameLengthSamples)))
1044 .RetiresOnSaturation();
1045
1046 // Then mock decoder fails. A common reason for failure can be buffer being
1047 // too short
1048 EXPECT_CALL(mock_decoder,
1049 DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
1050 .WillOnce(Return(-1))
1051 .RetiresOnSaturation();
1052
1053 // Mock decoder finally returns to normal.
1054 EXPECT_CALL(mock_decoder,
1055 DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
1056 .Times(2)
1057 .WillRepeatedly(
1058 DoAll(SetArrayArgument<3>(dummy_output,
1059 dummy_output + kFrameLengthSamples),
1060 SetArgPointee<4>(AudioDecoder::kSpeech),
1061 Return(kFrameLengthSamples)));
1062 }
1063
1064 EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
1065 &mock_decoder, NetEqDecoder::kDecoderPCM16B,
1066 "dummy name", kPayloadType, kSampleRateHz));
1067
1068 // Insert packets.
1069 for (int i = 0; i < 6; ++i) {
1070 rtp_header.header.sequenceNumber += 1;
1071 rtp_header.header.timestamp += kFrameLengthSamples;
1072 EXPECT_EQ(NetEq::kOK,
1073 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
1074 }
1075
1076 // Pull audio.
1077 const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
1078 int16_t output[kMaxOutputSize];
1079 size_t samples_per_channel;
1080 size_t num_channels;
1081 NetEqOutputType type;
1082 EXPECT_EQ(NetEq::kOK,
1083 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
1084 &num_channels, &type));
1085 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
1086 EXPECT_EQ(1u, num_channels);
1087 EXPECT_EQ(kOutputNormal, type);
1088
1089 // Pull audio again. Decoder fails.
1090 EXPECT_EQ(NetEq::kFail,
1091 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
1092 &num_channels, &type));
1093 EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
1094 EXPECT_EQ(kDecoderErrorCode, neteq_->LastDecoderError());
1095 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
1096 EXPECT_EQ(1u, num_channels);
1097 // TODO(minyue): should NetEq better give kOutputPLC, since it is actually an
1098 // expansion.
1099 EXPECT_EQ(kOutputNormal, type);
1100
1101 // Pull audio again, should continue an expansion.
1102 EXPECT_EQ(NetEq::kOK,
1103 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
1104 &num_channels, &type));
1105 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
1106 EXPECT_EQ(1u, num_channels);
1107 EXPECT_EQ(kOutputPLC, type);
1108
1109 // Pull audio again, should behave normal.
1110 EXPECT_EQ(NetEq::kOK,
1111 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
1112 &num_channels, &type));
1113 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
1114 EXPECT_EQ(1u, num_channels);
1115 EXPECT_EQ(kOutputNormal, type);
1116
1117 EXPECT_CALL(mock_decoder, Die());
1118 }
1119
1120 // This test checks the behavior of NetEq when audio decoder fails during CNG.
TEST_F(NetEqImplTest,DecodingErrorDuringInternalCng)1121 TEST_F(NetEqImplTest, DecodingErrorDuringInternalCng) {
1122 UseNoMocks();
1123 CreateInstance();
1124
1125 const uint8_t kPayloadType = 17; // Just an arbitrary number.
1126 const uint32_t kReceiveTime = 17; // Value doesn't matter for this test.
1127 const int kSampleRateHz = 8000;
1128 const int kDecoderErrorCode = -97; // Any negative number.
1129
1130 // We let decoder return 5 ms each time, and therefore, 2 packets make 10 ms.
1131 const size_t kFrameLengthSamples =
1132 static_cast<size_t>(5 * kSampleRateHz / 1000);
1133
1134 const size_t kPayloadLengthBytes = 1; // This can be arbitrary.
1135
1136 uint8_t payload[kPayloadLengthBytes] = {0};
1137
1138 WebRtcRTPHeader rtp_header;
1139 rtp_header.header.payloadType = kPayloadType;
1140 rtp_header.header.sequenceNumber = 0x1234;
1141 rtp_header.header.timestamp = 0x12345678;
1142 rtp_header.header.ssrc = 0x87654321;
1143
1144 // Create a mock decoder object.
1145 MockAudioDecoder mock_decoder;
1146 EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
1147 EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
1148 EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
1149 .WillRepeatedly(Return(0));
1150 EXPECT_CALL(mock_decoder, PacketDuration(_, _))
1151 .WillRepeatedly(Return(kFrameLengthSamples));
1152 EXPECT_CALL(mock_decoder, ErrorCode())
1153 .WillOnce(Return(kDecoderErrorCode));
1154 int16_t dummy_output[kFrameLengthSamples] = {0};
1155
1156 {
1157 InSequence sequence; // Dummy variable.
1158 // Mock decoder works normally the first 2 times.
1159 EXPECT_CALL(mock_decoder,
1160 DecodeInternal(_, kPayloadLengthBytes, kSampleRateHz, _, _))
1161 .Times(2)
1162 .WillRepeatedly(
1163 DoAll(SetArrayArgument<3>(dummy_output,
1164 dummy_output + kFrameLengthSamples),
1165 SetArgPointee<4>(AudioDecoder::kComfortNoise),
1166 Return(kFrameLengthSamples)))
1167 .RetiresOnSaturation();
1168
1169 // Then mock decoder fails. A common reason for failure can be buffer being
1170 // too short
1171 EXPECT_CALL(mock_decoder, DecodeInternal(nullptr, 0, kSampleRateHz, _, _))
1172 .WillOnce(Return(-1))
1173 .RetiresOnSaturation();
1174
1175 // Mock decoder finally returns to normal.
1176 EXPECT_CALL(mock_decoder, DecodeInternal(nullptr, 0, kSampleRateHz, _, _))
1177 .Times(2)
1178 .WillRepeatedly(
1179 DoAll(SetArrayArgument<3>(dummy_output,
1180 dummy_output + kFrameLengthSamples),
1181 SetArgPointee<4>(AudioDecoder::kComfortNoise),
1182 Return(kFrameLengthSamples)));
1183 }
1184
1185 EXPECT_EQ(NetEq::kOK, neteq_->RegisterExternalDecoder(
1186 &mock_decoder, NetEqDecoder::kDecoderPCM16B,
1187 "dummy name", kPayloadType, kSampleRateHz));
1188
1189 // Insert 2 packets. This will make netEq into codec internal CNG mode.
1190 for (int i = 0; i < 2; ++i) {
1191 rtp_header.header.sequenceNumber += 1;
1192 rtp_header.header.timestamp += kFrameLengthSamples;
1193 EXPECT_EQ(NetEq::kOK,
1194 neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
1195 }
1196
1197 // Pull audio.
1198 const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
1199 int16_t output[kMaxOutputSize];
1200 size_t samples_per_channel;
1201 size_t num_channels;
1202 NetEqOutputType type;
1203 EXPECT_EQ(NetEq::kOK,
1204 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
1205 &num_channels, &type));
1206 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
1207 EXPECT_EQ(1u, num_channels);
1208 EXPECT_EQ(kOutputCNG, type);
1209
1210 // Pull audio again. Decoder fails.
1211 EXPECT_EQ(NetEq::kFail,
1212 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
1213 &num_channels, &type));
1214 EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
1215 EXPECT_EQ(kDecoderErrorCode, neteq_->LastDecoderError());
1216 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
1217 EXPECT_EQ(1u, num_channels);
1218 // TODO(minyue): should NetEq better give kOutputPLC, since it is actually an
1219 // expansion.
1220 EXPECT_EQ(kOutputCNG, type);
1221
1222 // Pull audio again, should resume codec CNG.
1223 EXPECT_EQ(NetEq::kOK,
1224 neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
1225 &num_channels, &type));
1226 EXPECT_EQ(kMaxOutputSize, samples_per_channel);
1227 EXPECT_EQ(1u, num_channels);
1228 EXPECT_EQ(kOutputCNG, type);
1229
1230 EXPECT_CALL(mock_decoder, Die());
1231 }
1232
1233 // Tests that the return value from last_output_sample_rate_hz() is equal to the
1234 // configured inital sample rate.
TEST_F(NetEqImplTest,InitialLastOutputSampleRate)1235 TEST_F(NetEqImplTest, InitialLastOutputSampleRate) {
1236 UseNoMocks();
1237 config_.sample_rate_hz = 48000;
1238 CreateInstance();
1239 EXPECT_EQ(48000, neteq_->last_output_sample_rate_hz());
1240 }
1241
1242 }// namespace webrtc
1243