zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ACM: Removed the code for InitialDelayManager

Browse Source 
It looks to have been unused since the landing of
https://codereview.webrtc.org/1419573013

BUG=webrtc:3520

Review-Url: https://codereview.webrtc.org/2363993002
Cr-Commit-Position: refs/heads/master@{#14397}
This commit is contained in:
ossu
2016-09-27 05:43:33 -07:00
committed by Commit bot
parent 29a44e351e
commit 46a8d18efa
7 changed files with 0 additions and 745 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/modules/BUILD.gn
View File

@ -270,7 +270,6 @@ if (rtc_include_tests) {
"audio_coding/acm2/audio_coding_module_unittest_oldapi.cc", "audio_coding/acm2/audio_coding_module_unittest_oldapi.cc",
"audio_coding/acm2/call_statistics_unittest.cc", "audio_coding/acm2/call_statistics_unittest.cc",
"audio_coding/acm2/codec_manager_unittest.cc", "audio_coding/acm2/codec_manager_unittest.cc",
"audio_coding/acm2/initial_delay_manager_unittest.cc",
"audio_coding/acm2/rent_a_codec_unittest.cc", "audio_coding/acm2/rent_a_codec_unittest.cc",
"audio_coding/codecs/audio_decoder_factory_unittest.cc", "audio_coding/codecs/audio_decoder_factory_unittest.cc",
"audio_coding/codecs/cng/audio_encoder_cng_unittest.cc", "audio_coding/codecs/cng/audio_encoder_cng_unittest.cc",

2
webrtc/modules/audio_coding/BUILD.gn
View File

@ -92,8 +92,6 @@ rtc_static_library("audio_coding") {
"acm2/call_statistics.h", "acm2/call_statistics.h",
"acm2/codec_manager.cc", "acm2/codec_manager.cc",
"acm2/codec_manager.h", "acm2/codec_manager.h",
"acm2/initial_delay_manager.cc",
"acm2/initial_delay_manager.h",
"include/audio_coding_module.h", "include/audio_coding_module.h",
"include/audio_coding_module_typedefs.h", "include/audio_coding_module_typedefs.h",
] ]

1
webrtc/modules/audio_coding/acm2/acm_receiver.h
View File

@ -24,7 +24,6 @@
#include "webrtc/engine_configurations.h" #include "webrtc/engine_configurations.h"
#include "webrtc/modules/audio_coding/acm2/acm_resampler.h" #include "webrtc/modules/audio_coding/acm2/acm_resampler.h"
#include "webrtc/modules/audio_coding/acm2/call_statistics.h" #include "webrtc/modules/audio_coding/acm2/call_statistics.h"
#include "webrtc/modules/audio_coding/acm2/initial_delay_manager.h"
#include "webrtc/modules/audio_coding/include/audio_coding_module.h" #include "webrtc/modules/audio_coding/include/audio_coding_module.h"
#include "webrtc/modules/audio_coding/neteq/include/neteq.h" #include "webrtc/modules/audio_coding/neteq/include/neteq.h"
#include "webrtc/modules/include/module_common_types.h" #include "webrtc/modules/include/module_common_types.h"

242
webrtc/modules/audio_coding/acm2/initial_delay_manager.cc
View File

@ -1,242 +0,0 @@
/*
* Copyright (c) 2013 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/acm2/initial_delay_manager.h"
namespace webrtc {
namespace acm2 {
InitialDelayManager::InitialDelayManager(int initial_delay_ms,
int late_packet_threshold)
: last_packet_type_(kUndefinedPacket),
last_receive_timestamp_(0),
timestamp_step_(0),
audio_payload_type_(kInvalidPayloadType),
initial_delay_ms_(initial_delay_ms),
buffered_audio_ms_(0),
buffering_(true),
playout_timestamp_(0),
late_packet_threshold_(late_packet_threshold) {
last_packet_rtp_info_.header.payloadType = kInvalidPayloadType;
last_packet_rtp_info_.header.ssrc = 0;
last_packet_rtp_info_.header.sequenceNumber = 0;
last_packet_rtp_info_.header.timestamp = 0;
}
void InitialDelayManager::UpdateLastReceivedPacket(
const WebRtcRTPHeader& rtp_info,
uint32_t receive_timestamp,
PacketType type,
bool new_codec,
int sample_rate_hz,
SyncStream* sync_stream) {
assert(sync_stream);
// If payload of audio packets is changing |new_codec| has to be true.
assert(!(!new_codec && type == kAudioPacket &&
rtp_info.header.payloadType != audio_payload_type_));
// Just shorthands.
const RTPHeader* current_header = &rtp_info.header;
RTPHeader* last_header = &last_packet_rtp_info_.header;
// Don't do anything if getting DTMF. The chance of DTMF in applications where
// initial delay is required is very low (we don't know of any). This avoids a
// lot of corner cases. The effect of ignoring DTMF packet is minimal. Note
// that DTMFs are inserted into NetEq just not accounted here.
if (type == kAvtPacket ||
(last_packet_type_ != kUndefinedPacket &&
!IsNewerSequenceNumber(current_header->sequenceNumber,
last_header->sequenceNumber))) {
sync_stream->num_sync_packets = 0;
return;
}
// Either if it is a new packet or the first packet record and set variables.
if (new_codec ||
last_packet_rtp_info_.header.payloadType == kInvalidPayloadType) {
timestamp_step_ = 0;
if (type == kAudioPacket)
audio_payload_type_ = rtp_info.header.payloadType;
else
audio_payload_type_ = kInvalidPayloadType; // Invalid.
RecordLastPacket(rtp_info, receive_timestamp, type);
sync_stream->num_sync_packets = 0;
buffered_audio_ms_ = 0;
buffering_ = true;
// If |buffering_| is set then |playout_timestamp_| should have correct
// value.
UpdatePlayoutTimestamp(*current_header, sample_rate_hz);
return;
}
uint32_t timestamp_increase = current_header->timestamp -
last_header->timestamp;
// |timestamp_increase| is invalid if this is the first packet. The effect is
// that |buffered_audio_ms_| is not increased.
if (last_packet_type_ == kUndefinedPacket) {
timestamp_increase = 0;
}
if (buffering_) {
buffered_audio_ms_ += timestamp_increase * 1000 / sample_rate_hz;
// A timestamp that reflects the initial delay, while buffering.
UpdatePlayoutTimestamp(*current_header, sample_rate_hz);
if (buffered_audio_ms_ >= initial_delay_ms_)
buffering_ = false;
}
if (current_header->sequenceNumber == last_header->sequenceNumber + 1) {
// Two consecutive audio packets, the previous packet-type is audio, so we
// can update |timestamp_step_|.
if (last_packet_type_ == kAudioPacket)
timestamp_step_ = timestamp_increase;
RecordLastPacket(rtp_info, receive_timestamp, type);
sync_stream->num_sync_packets = 0;
return;
}
uint16_t packet_gap = current_header->sequenceNumber -
last_header->sequenceNumber - 1;
// For smooth transitions leave a gap between audio and sync packets.
sync_stream->num_sync_packets = last_packet_type_ == kSyncPacket ?
packet_gap - 1 : packet_gap - 2;
// Do nothing if we haven't received any audio packet.
if (sync_stream->num_sync_packets > 0 &&
audio_payload_type_ != kInvalidPayloadType) {
if (timestamp_step_ == 0) {
// Make an estimate for |timestamp_step_| if it is not updated, yet.
assert(packet_gap > 0);
timestamp_step_ = timestamp_increase / (packet_gap + 1);
}
sync_stream->timestamp_step = timestamp_step_;
// Build the first sync-packet based on the current received packet.
memcpy(&sync_stream->rtp_info, &rtp_info, sizeof(rtp_info));
sync_stream->rtp_info.header.payloadType = audio_payload_type_;
uint16_t sequence_number_update = sync_stream->num_sync_packets + 1;
uint32_t timestamp_update = timestamp_step_ * sequence_number_update;
// Rewind sequence number and timestamps. This will give a more accurate
// description of the missing packets.
//
// Note that we leave a gap between the last packet in sync-stream and the
// current received packet, so it should be compensated for in the following
// computation of timestamps and sequence number.
sync_stream->rtp_info.header.sequenceNumber -= sequence_number_update;
sync_stream->receive_timestamp = receive_timestamp - timestamp_update;
sync_stream->rtp_info.header.timestamp -= timestamp_update;
sync_stream->rtp_info.header.payloadType = audio_payload_type_;
} else {
sync_stream->num_sync_packets = 0;
}
RecordLastPacket(rtp_info, receive_timestamp, type);
return;
}
void InitialDelayManager::RecordLastPacket(const WebRtcRTPHeader& rtp_info,
uint32_t receive_timestamp,
PacketType type) {
last_packet_type_ = type;
last_receive_timestamp_ = receive_timestamp;
memcpy(&last_packet_rtp_info_, &rtp_info, sizeof(rtp_info));
}
void InitialDelayManager::LatePackets(
uint32_t timestamp_now, SyncStream* sync_stream) {
assert(sync_stream);
sync_stream->num_sync_packets = 0;
// If there is no estimate of timestamp increment, |timestamp_step_|, then
// we cannot estimate the number of late packets.
// If the last packet has been CNG, estimating late packets is not meaningful,
// as a CNG packet is on unknown length.
// We can set a higher threshold if the last packet is CNG and continue
// execution, but this is how ACM1 code was written.
if (timestamp_step_ <= 0 ||
last_packet_type_ == kCngPacket ||
last_packet_type_ == kUndefinedPacket ||
audio_payload_type_ == kInvalidPayloadType) // No audio packet received.
return;
int num_late_packets = (timestamp_now - last_receive_timestamp_) /
timestamp_step_;
if (num_late_packets < late_packet_threshold_)
return;
int sync_offset = 1; // One gap at the end of the sync-stream.
if (last_packet_type_ != kSyncPacket) {
++sync_offset; // One more gap at the beginning of the sync-stream.
--num_late_packets;
}
uint32_t timestamp_update = sync_offset * timestamp_step_;
sync_stream->num_sync_packets = num_late_packets;
if (num_late_packets == 0)
return;
// Build the first sync-packet in the sync-stream.
memcpy(&sync_stream->rtp_info, &last_packet_rtp_info_,
sizeof(last_packet_rtp_info_));
// Increase sequence number and timestamps.
sync_stream->rtp_info.header.sequenceNumber += sync_offset;
sync_stream->rtp_info.header.timestamp += timestamp_update;
sync_stream->receive_timestamp = last_receive_timestamp_ + timestamp_update;
sync_stream->timestamp_step = timestamp_step_;
// Sync-packets have audio payload-type.
sync_stream->rtp_info.header.payloadType = audio_payload_type_;
uint16_t sequence_number_update = num_late_packets + sync_offset - 1;
timestamp_update = sequence_number_update * timestamp_step_;
// Fake the last RTP, assuming the caller will inject the whole sync-stream.
last_packet_rtp_info_.header.timestamp += timestamp_update;
last_packet_rtp_info_.header.sequenceNumber += sequence_number_update;
last_packet_rtp_info_.header.payloadType = audio_payload_type_;
last_receive_timestamp_ += timestamp_update;
last_packet_type_ = kSyncPacket;
return;
}
bool InitialDelayManager::GetPlayoutTimestamp(uint32_t* playout_timestamp) {
if (!buffering_) {
return false;
}
*playout_timestamp = playout_timestamp_;
return true;
}
void InitialDelayManager::DisableBuffering() {
buffering_ = false;
}
void InitialDelayManager::UpdatePlayoutTimestamp(
const RTPHeader& current_header, int sample_rate_hz) {
playout_timestamp_ = current_header.timestamp - static_cast<uint32_t>(
initial_delay_ms_ * sample_rate_hz / 1000);
}
} // namespace acm2
} // namespace webrtc

119
webrtc/modules/audio_coding/acm2/initial_delay_manager.h
View File

@ -1,119 +0,0 @@
/*
* Copyright (c) 2013 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.
*/
#ifndef WEBRTC_MODULES_AUDIO_CODING_ACM2_INITIAL_DELAY_MANAGER_H_
#define WEBRTC_MODULES_AUDIO_CODING_ACM2_INITIAL_DELAY_MANAGER_H_
#include "webrtc/modules/include/module_common_types.h"
namespace webrtc {
namespace acm2 {
class InitialDelayManager {
public:
enum PacketType {
kUndefinedPacket, kCngPacket, kAvtPacket, kAudioPacket, kSyncPacket };
// Specifies a stream of sync-packets.
struct SyncStream {
SyncStream()
: num_sync_packets(0),
receive_timestamp(0),
timestamp_step(0) {
memset(&rtp_info, 0, sizeof(rtp_info));
}
int num_sync_packets;
// RTP header of the first sync-packet in the sequence.
WebRtcRTPHeader rtp_info;
// Received timestamp of the first sync-packet in the sequence.
uint32_t receive_timestamp;
// Samples per packet.
uint32_t timestamp_step;
};
InitialDelayManager(int initial_delay_ms, int late_packet_threshold);
// Update with the last received RTP header, |header|, and received timestamp,
// |received_timestamp|. |type| indicates the packet type. If codec is changed
// since the last time |new_codec| should be true. |sample_rate_hz| is the
// decoder's sampling rate in Hz. |header| has a field to store sampling rate
// but we are not sure if that is properly set at the send side, and |header|
// is declared constant in the caller of this function
// (AcmReceiver::InsertPacket()). |sync_stream| contains information required
// to generate a stream of sync packets.
void UpdateLastReceivedPacket(const WebRtcRTPHeader& header,
uint32_t receive_timestamp,
PacketType type,
bool new_codec,
int sample_rate_hz,
SyncStream* sync_stream);
// Based on the last received timestamp and given the current timestamp,
// sequence of late (or perhaps missing) packets is computed.
void LatePackets(uint32_t timestamp_now, SyncStream* sync_stream);
// Get playout timestamp.
// Returns true if the timestamp is valid (when buffering), otherwise false.
bool GetPlayoutTimestamp(uint32_t* playout_timestamp);
// True if buffered audio is less than the given initial delay (specified at
// the constructor). Buffering might be disabled by the client of this class.
bool buffering() { return buffering_; }
// Disable buffering in the class.
void DisableBuffering();
// True if any packet received for buffering.
bool PacketBuffered() { return last_packet_type_ != kUndefinedPacket; }
private:
static const uint8_t kInvalidPayloadType = 0xFF;
// Update playout timestamps. While buffering, this is about
// |initial_delay_ms| millisecond behind the latest received timestamp.
void UpdatePlayoutTimestamp(const RTPHeader& current_header,
int sample_rate_hz);
// Record an RTP headr and related parameter
void RecordLastPacket(const WebRtcRTPHeader& rtp_info,
uint32_t receive_timestamp,
PacketType type);
PacketType last_packet_type_;
WebRtcRTPHeader last_packet_rtp_info_;
uint32_t last_receive_timestamp_;
uint32_t timestamp_step_;
uint8_t audio_payload_type_;
const int initial_delay_ms_;
int buffered_audio_ms_;
bool buffering_;
// During the initial phase where packets are being accumulated and silence
// is played out, |playout_ts| is a timestamp which is equal to
// |initial_delay_ms_| milliseconds earlier than the most recently received
// RTP timestamp.
uint32_t playout_timestamp_;
// If the number of late packets exceed this value (computed based on current
// timestamp and last received timestamp), sequence of sync-packets is
// specified.
const int late_packet_threshold_;
};
} // namespace acm2
} // namespace webrtc
#endif // WEBRTC_MODULES_AUDIO_CODING_ACM2_INITIAL_DELAY_MANAGER_H_

378
webrtc/modules/audio_coding/acm2/initial_delay_manager_unittest.cc
View File

@ -1,378 +0,0 @@
/*
* Copyright (c) 2013 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 <string.h>
#include <memory>
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/modules/audio_coding/acm2/initial_delay_manager.h"
namespace webrtc {
namespace acm2 {
namespace {
const uint8_t kAudioPayloadType = 0;
const uint8_t kCngPayloadType = 1;
const uint8_t kAvtPayloadType = 2;
const int kSamplingRateHz = 16000;
const int kInitDelayMs = 200;
const int kFrameSizeMs = 20;
const uint32_t kTimestampStep = kFrameSizeMs * kSamplingRateHz / 1000;
const int kLatePacketThreshold = 5;
void InitRtpInfo(WebRtcRTPHeader* rtp_info) {
memset(rtp_info, 0, sizeof(*rtp_info));
rtp_info->header.markerBit = false;
rtp_info->header.payloadType = kAudioPayloadType;
rtp_info->header.sequenceNumber = 1234;
rtp_info->header.timestamp = 0xFFFFFFFD; // Close to wrap around.
rtp_info->header.ssrc = 0x87654321; // Arbitrary.
rtp_info->header.numCSRCs = 0; // Arbitrary.
rtp_info->header.paddingLength = 0;
rtp_info->header.headerLength = sizeof(RTPHeader);
rtp_info->header.payload_type_frequency = kSamplingRateHz;
rtp_info->header.extension.absoluteSendTime = 0;
rtp_info->header.extension.transmissionTimeOffset = 0;
rtp_info->frameType = kAudioFrameSpeech;
}
void ForwardRtpHeader(int n,
WebRtcRTPHeader* rtp_info,
uint32_t* rtp_receive_timestamp) {
rtp_info->header.sequenceNumber += n;
rtp_info->header.timestamp += n * kTimestampStep;
*rtp_receive_timestamp += n * kTimestampStep;
}
void NextRtpHeader(WebRtcRTPHeader* rtp_info,
uint32_t* rtp_receive_timestamp) {
ForwardRtpHeader(1, rtp_info, rtp_receive_timestamp);
}
} // namespace
class InitialDelayManagerTest : public ::testing::Test {
protected:
InitialDelayManagerTest()
: manager_(new InitialDelayManager(kInitDelayMs, kLatePacketThreshold)),
rtp_receive_timestamp_(1111) { } // Arbitrary starting point.
virtual void SetUp() {
ASSERT_TRUE(manager_.get() != NULL);
InitRtpInfo(&rtp_info_);
}
void GetNextRtpHeader(WebRtcRTPHeader* rtp_info,
uint32_t* rtp_receive_timestamp) const {
memcpy(rtp_info, &rtp_info_, sizeof(*rtp_info));
*rtp_receive_timestamp = rtp_receive_timestamp_;
NextRtpHeader(rtp_info, rtp_receive_timestamp);
}
std::unique_ptr<InitialDelayManager> manager_;
WebRtcRTPHeader rtp_info_;
uint32_t rtp_receive_timestamp_;
};
TEST_F(InitialDelayManagerTest, Init) {
EXPECT_TRUE(manager_->buffering());
EXPECT_FALSE(manager_->PacketBuffered());
manager_->DisableBuffering();
EXPECT_FALSE(manager_->buffering());
InitialDelayManager::SyncStream sync_stream;
// Call before any packet inserted.
manager_->LatePackets(0x6789ABCD, &sync_stream); // Arbitrary but large
// receive timestamp.
EXPECT_EQ(0, sync_stream.num_sync_packets);
// Insert non-audio packets, a CNG and DTMF.
rtp_info_.header.payloadType = kCngPayloadType;
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kCngPacket, false,
kSamplingRateHz, &sync_stream);
EXPECT_EQ(0, sync_stream.num_sync_packets);
ForwardRtpHeader(5, &rtp_info_, &rtp_receive_timestamp_);
rtp_info_.header.payloadType = kAvtPayloadType;
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAvtPacket, false,
kSamplingRateHz, &sync_stream);
// Gap in sequence numbers but no audio received, sync-stream should be empty.
EXPECT_EQ(0, sync_stream.num_sync_packets);
manager_->LatePackets(0x45678987, &sync_stream); // Large arbitrary receive
// timestamp.
// |manager_| has no estimate of timestamp-step and has not received any
// audio packet.
EXPECT_EQ(0, sync_stream.num_sync_packets);
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
rtp_info_.header.payloadType = kAudioPayloadType;
// First packet.
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, true,
kSamplingRateHz, &sync_stream);
EXPECT_EQ(0, sync_stream.num_sync_packets);
// Call LatePAcket() after only one packet inserted.
manager_->LatePackets(0x6789ABCD, &sync_stream); // Arbitrary but large
// receive timestamp.
EXPECT_EQ(0, sync_stream.num_sync_packets);
// Gap in timestamp, but this packet is also flagged as "new," therefore,
// expecting empty sync-stream.
ForwardRtpHeader(5, &rtp_info_, &rtp_receive_timestamp_);
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, true,
kSamplingRateHz, &sync_stream);
}
TEST_F(InitialDelayManagerTest, MissingPacket) {
InitialDelayManager::SyncStream sync_stream;
// First packet.
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, true,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Second packet.
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, false,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Third packet, missing packets start from here.
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
// First sync-packet in sync-stream is one after the above packet.
WebRtcRTPHeader expected_rtp_info;
uint32_t expected_receive_timestamp;
GetNextRtpHeader(&expected_rtp_info, &expected_receive_timestamp);
const int kNumMissingPackets = 10;
ForwardRtpHeader(kNumMissingPackets, &rtp_info_, &rtp_receive_timestamp_);
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, false,
kSamplingRateHz, &sync_stream);
EXPECT_EQ(kNumMissingPackets - 2, sync_stream.num_sync_packets);
EXPECT_EQ(0, memcmp(&expected_rtp_info, &sync_stream.rtp_info,
sizeof(expected_rtp_info)));
EXPECT_EQ(kTimestampStep, sync_stream.timestamp_step);
EXPECT_EQ(expected_receive_timestamp, sync_stream.receive_timestamp);
}
// There hasn't been any consecutive packets to estimate timestamp-step.
TEST_F(InitialDelayManagerTest, MissingPacketEstimateTimestamp) {
InitialDelayManager::SyncStream sync_stream;
// First packet.
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, true,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Second packet, missing packets start here.
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
// First sync-packet in sync-stream is one after the above.
WebRtcRTPHeader expected_rtp_info;
uint32_t expected_receive_timestamp;
GetNextRtpHeader(&expected_rtp_info, &expected_receive_timestamp);
const int kNumMissingPackets = 10;
ForwardRtpHeader(kNumMissingPackets, &rtp_info_, &rtp_receive_timestamp_);
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, false,
kSamplingRateHz, &sync_stream);
EXPECT_EQ(kNumMissingPackets - 2, sync_stream.num_sync_packets);
EXPECT_EQ(0, memcmp(&expected_rtp_info, &sync_stream.rtp_info,
sizeof(expected_rtp_info)));
}
TEST_F(InitialDelayManagerTest, MissingPacketWithCng) {
InitialDelayManager::SyncStream sync_stream;
// First packet.
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, true,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Second packet as CNG.
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
rtp_info_.header.payloadType = kCngPayloadType;
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kCngPacket, false,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Audio packet after CNG. Missing packets start from this packet.
rtp_info_.header.payloadType = kAudioPayloadType;
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
// Timestamps are increased higher than regular packet.
const uint32_t kCngTimestampStep = 5 * kTimestampStep;
rtp_info_.header.timestamp += kCngTimestampStep;
rtp_receive_timestamp_ += kCngTimestampStep;
// First sync-packet in sync-stream is the one after the above packet.
WebRtcRTPHeader expected_rtp_info;
uint32_t expected_receive_timestamp;
GetNextRtpHeader(&expected_rtp_info, &expected_receive_timestamp);
const int kNumMissingPackets = 10;
ForwardRtpHeader(kNumMissingPackets, &rtp_info_, &rtp_receive_timestamp_);
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, false,
kSamplingRateHz, &sync_stream);
EXPECT_EQ(kNumMissingPackets - 2, sync_stream.num_sync_packets);
EXPECT_EQ(0, memcmp(&expected_rtp_info, &sync_stream.rtp_info,
sizeof(expected_rtp_info)));
EXPECT_EQ(kTimestampStep, sync_stream.timestamp_step);
EXPECT_EQ(expected_receive_timestamp, sync_stream.receive_timestamp);
}
TEST_F(InitialDelayManagerTest, LatePacket) {
InitialDelayManager::SyncStream sync_stream;
// First packet.
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, true,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Second packet.
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, false,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Timestamp increment for 10ms;
const uint32_t kTimestampStep10Ms = kSamplingRateHz / 100;
// 10 ms after the second packet is inserted.
uint32_t timestamp_now = rtp_receive_timestamp_ + kTimestampStep10Ms;
// Third packet, late packets start from this packet.
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
// First sync-packet in sync-stream, which is one after the above packet.
WebRtcRTPHeader expected_rtp_info;
uint32_t expected_receive_timestamp;
GetNextRtpHeader(&expected_rtp_info, &expected_receive_timestamp);
const int kLatePacketThreshold = 5;
int expected_num_late_packets = kLatePacketThreshold - 1;
for (int k = 0; k < 2; ++k) {
for (int n = 1; n < kLatePacketThreshold * kFrameSizeMs / 10; ++n) {
manager_->LatePackets(timestamp_now, &sync_stream);
EXPECT_EQ(0, sync_stream.num_sync_packets) <<
"try " << k << " loop number " << n;
timestamp_now += kTimestampStep10Ms;
}
manager_->LatePackets(timestamp_now, &sync_stream);
EXPECT_EQ(expected_num_late_packets, sync_stream.num_sync_packets) <<
"try " << k;
EXPECT_EQ(kTimestampStep, sync_stream.timestamp_step) <<
"try " << k;
EXPECT_EQ(expected_receive_timestamp, sync_stream.receive_timestamp) <<
"try " << k;
EXPECT_EQ(0, memcmp(&expected_rtp_info, &sync_stream.rtp_info,
sizeof(expected_rtp_info)));
timestamp_now += kTimestampStep10Ms;
// |manger_| assumes the |sync_stream| obtained by LatePacket() is fully
// injected. The last injected packet is sync-packet, therefore, there will
// not be any gap between sync stream of this and the next iteration.
ForwardRtpHeader(sync_stream.num_sync_packets, &expected_rtp_info,
&expected_receive_timestamp);
expected_num_late_packets = kLatePacketThreshold;
}
// Test "no-gap" for missing packet after late packet.
// |expected_rtp_info| is the expected sync-packet if any packet is missing.
memcpy(&rtp_info_, &expected_rtp_info, sizeof(rtp_info_));
rtp_receive_timestamp_ = expected_receive_timestamp;
int kNumMissingPackets = 3; // Arbitrary.
ForwardRtpHeader(kNumMissingPackets, &rtp_info_, &rtp_receive_timestamp_);
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, false,
kSamplingRateHz, &sync_stream);
// Note that there is one packet gap between the last sync-packet and the
// latest inserted packet.
EXPECT_EQ(kNumMissingPackets - 1, sync_stream.num_sync_packets);
EXPECT_EQ(kTimestampStep, sync_stream.timestamp_step);
EXPECT_EQ(expected_receive_timestamp, sync_stream.receive_timestamp);
EXPECT_EQ(0, memcmp(&expected_rtp_info, &sync_stream.rtp_info,
sizeof(expected_rtp_info)));
}
TEST_F(InitialDelayManagerTest, NoLatePacketAfterCng) {
InitialDelayManager::SyncStream sync_stream;
// First packet.
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket, true,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Second packet as CNG.
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
rtp_info_.header.payloadType = kCngPayloadType;
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kCngPacket, false,
kSamplingRateHz, &sync_stream);
ASSERT_EQ(0, sync_stream.num_sync_packets);
// Forward the time more then |kLatePacketThreshold| packets.
uint32_t timestamp_now = rtp_receive_timestamp_ + kTimestampStep * (3 +
kLatePacketThreshold);
manager_->LatePackets(timestamp_now, &sync_stream);
EXPECT_EQ(0, sync_stream.num_sync_packets);
}
TEST_F(InitialDelayManagerTest, BufferingAudio) {
InitialDelayManager::SyncStream sync_stream;
// Very first packet is not counted in calculation of buffered audio.
for (int n = 0; n < kInitDelayMs / kFrameSizeMs; ++n) {
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket,
n == 0, kSamplingRateHz, &sync_stream);
EXPECT_EQ(0, sync_stream.num_sync_packets);
EXPECT_TRUE(manager_->buffering());
const uint32_t expected_playout_timestamp = rtp_info_.header.timestamp -
kInitDelayMs * kSamplingRateHz / 1000;
uint32_t actual_playout_timestamp = 0;
EXPECT_TRUE(manager_->GetPlayoutTimestamp(&actual_playout_timestamp));
EXPECT_EQ(expected_playout_timestamp, actual_playout_timestamp);
NextRtpHeader(&rtp_info_, &rtp_receive_timestamp_);
}
manager_->UpdateLastReceivedPacket(rtp_info_, rtp_receive_timestamp_,
InitialDelayManager::kAudioPacket,
false, kSamplingRateHz, &sync_stream);
EXPECT_EQ(0, sync_stream.num_sync_packets);
EXPECT_FALSE(manager_->buffering());
}
} // namespace acm2
} // namespace webrtc

2
webrtc/modules/audio_coding/audio_coding.gypi
View File

@ -180,8 +180,6 @@
'acm2/call_statistics.h', 'acm2/call_statistics.h',
'acm2/codec_manager.cc', 'acm2/codec_manager.cc',
'acm2/codec_manager.h', 'acm2/codec_manager.h',
'acm2/initial_delay_manager.cc',
'acm2/initial_delay_manager.h',
'include/audio_coding_module.h', 'include/audio_coding_module.h',
'include/audio_coding_module_typedefs.h', 'include/audio_coding_module_typedefs.h',
], ],