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

Delete video_coding_robustness_unittest.cc

Browse Source 
BUG=none

Review-Url: https://codereview.webrtc.org/2755803004
Cr-Commit-Position: refs/heads/master@{#17312}
This commit is contained in:
tommi
2017-03-20 10:43:23 -07:00
committed by Commit bot
parent aff5be35e0
commit a5c18d7312
6 changed files with 22 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/modules/video_coding/BUILD.gn
View File

@ -512,7 +512,6 @@ if (rtc_include_tests) {
"utility/quality_scaler_unittest.cc",
"utility/simulcast_rate_allocator_unittest.cc",
"video_codec_initializer_unittest.cc",
"video_coding_robustness_unittest.cc",
"video_packet_buffer_unittest.cc",
"video_receiver_unittest.cc",
"video_sender_unittest.cc",

25
webrtc/modules/video_coding/include/video_coding.h
View File

@ -71,23 +71,9 @@ class VideoCodingModule : public Module {
public:
enum SenderNackMode { kNackNone, kNackAll, kNackSelective };
enum ReceiverRobustness { kNone, kHardNack, kSoftNack, kReferenceSelection };
// DEPRECATED.
static VideoCodingModule* Create(Clock* clock, EventFactory* event_factory);
static VideoCodingModule* Create(
Clock* clock,
VCMQMSettingsCallback* qm_settings_callback,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender,
EncodedImageCallback* pre_decode_image_callback);
static VideoCodingModule* Create(
Clock* clock,
EventFactory* event_factory,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender);
// Get supported codec settings using codec type
//
// Input:
@ -396,11 +382,11 @@ class VideoCodingModule : public Module {
// Robustness APIs
// DEPRECATED.
// Set the receiver robustness mode. The mode decides how the receiver
// responds to losses in the stream. The type of counter-measure (soft or
// hard NACK, dual decoder, RPS, etc.) is selected through the
// robustnessMode parameter. The errorMode parameter decides if it is
// allowed to display frames corrupted by losses. Note that not all
// responds to losses in the stream. The type of counter-measure is selected
// through the robustnessMode parameter. The errorMode parameter decides if it
// is allowed to display frames corrupted by losses. Note that not all
// combinations of the two parameters are feasible. An error will be
// returned for invalid combinations.
// Input:
@ -409,6 +395,7 @@ class VideoCodingModule : public Module {
//
// Return value : VCM_OK, on success;
// < 0, on error.
enum ReceiverRobustness { kNone, kHardNack };
virtual int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
VCMDecodeErrorMode errorMode) = 0;

29
webrtc/modules/video_coding/video_coding_impl.cc
View File

@ -276,37 +276,14 @@ void VideoCodingModule::Codec(VideoCodecType codecType, VideoCodec* codec) {
VCMCodecDataBase::Codec(codecType, codec);
}
// Create method for the new jitter buffer.
VideoCodingModule* VideoCodingModule::Create(
Clock* clock,
VCMQMSettingsCallback* qm_settings_callback,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender,
EncodedImageCallback* pre_decode_image_callback) {
return new VideoCodingModuleImpl(clock, nullptr, nack_sender,
keyframe_request_sender,
pre_decode_image_callback);
}
// Create method for current interface, will be removed when the
// DEPRECATED. Create method for current interface, will be removed when the
// new jitter buffer is in place.
VideoCodingModule* VideoCodingModule::Create(Clock* clock,
EventFactory* event_factory) {
return VideoCodingModule::Create(clock, event_factory,
nullptr, // NackSender
nullptr); // KeyframeRequestSender
}
// Create method for the new jitter buffer.
VideoCodingModule* VideoCodingModule::Create(
Clock* clock,
EventFactory* event_factory,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender) {
RTC_DCHECK(clock);
RTC_DCHECK(event_factory);
return new VideoCodingModuleImpl(clock, event_factory, nack_sender,
keyframe_request_sender, nullptr);
return new VideoCodingModuleImpl(clock, event_factory, nullptr, nullptr,
nullptr);
}
} // namespace webrtc

7
webrtc/modules/video_coding/video_coding_impl.h
View File

@ -144,8 +144,6 @@ class VideoSender : public Module {
class VideoReceiver : public Module {
public:
typedef VideoCodingModule::ReceiverRobustness ReceiverRobustness;
VideoReceiver(Clock* clock,
EventFactory* event_factory,
EncodedImageCallback* pre_decode_image_callback,
@ -180,8 +178,11 @@ class VideoReceiver : public Module {
int32_t SetRenderDelay(uint32_t timeMS);
int32_t Delay() const;
int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
// DEPRECATED.
int SetReceiverRobustnessMode(
VideoCodingModule::ReceiverRobustness robustnessMode,
VCMDecodeErrorMode errorMode);
void SetNackSettings(size_t max_nack_list_size,
int max_packet_age_to_nack,
int max_incomplete_time_ms);

237
webrtc/modules/video_coding/video_coding_robustness_unittest.cc
View File

@ -1,237 +0,0 @@
/*
* Copyright (c) 2012 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 <memory>
#include "webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h"
#include "webrtc/modules/video_coding/include/mock/mock_video_codec_interface.h"
#include "webrtc/modules/video_coding/include/video_coding.h"
#include "webrtc/modules/video_coding/test/test_util.h"
#include "webrtc/system_wrappers/include/clock.h"
#include "webrtc/test/gmock.h"
#include "webrtc/test/gtest.h"
namespace webrtc {
using ::testing::_;
using ::testing::AllOf;
using ::testing::AnyNumber;
using ::testing::Args;
using ::testing::ElementsAre;
using ::testing::Field;
using ::testing::NiceMock;
using ::testing::Pointee;
using ::testing::Return;
using ::testing::Sequence;
class VCMRobustnessTest : public ::testing::Test {
protected:
static const size_t kPayloadLen = 10;
virtual void SetUp() {
clock_.reset(new SimulatedClock(0));
ASSERT_TRUE(clock_.get() != NULL);
vcm_.reset(VideoCodingModule::Create(clock_.get(), &event_factory_));
ASSERT_TRUE(vcm_ != NULL);
const size_t kMaxNackListSize = 250;
const int kMaxPacketAgeToNack = 450;
vcm_->SetNackSettings(kMaxNackListSize, kMaxPacketAgeToNack, 0);
ASSERT_EQ(0, vcm_->RegisterFrameTypeCallback(&frame_type_callback_));
ASSERT_EQ(0, vcm_->RegisterPacketRequestCallback(&request_callback_));
VideoCodingModule::Codec(kVideoCodecVP8, &video_codec_);
ASSERT_EQ(VCM_OK, vcm_->RegisterReceiveCodec(&video_codec_, 1));
vcm_->RegisterExternalDecoder(&decoder_, video_codec_.plType);
// Since we call Decode, we need to provide a valid receive callback.
// However, for the purposes of these tests, we ignore the callbacks.
EXPECT_CALL(receive_callback_, OnIncomingPayloadType(_)).Times(AnyNumber());
EXPECT_CALL(receive_callback_, OnDecoderImplementationName(_))
.Times(AnyNumber());
vcm_->RegisterReceiveCallback(&receive_callback_);
}
virtual void TearDown() { vcm_.reset(); }
void InsertPacket(uint32_t timestamp,
uint16_t seq_no,
bool first,
bool marker_bit,
FrameType frame_type) {
const uint8_t payload[kPayloadLen] = {0};
WebRtcRTPHeader rtp_info;
memset(&rtp_info, 0, sizeof(rtp_info));
rtp_info.frameType = frame_type;
rtp_info.header.timestamp = timestamp;
rtp_info.header.sequenceNumber = seq_no;
rtp_info.header.markerBit = marker_bit;
rtp_info.header.payloadType = video_codec_.plType;
rtp_info.type.Video.codec = kRtpVideoVp8;
rtp_info.type.Video.codecHeader.VP8.InitRTPVideoHeaderVP8();
rtp_info.type.Video.is_first_packet_in_frame = first;
ASSERT_EQ(VCM_OK, vcm_->IncomingPacket(payload, kPayloadLen, rtp_info));
}
std::unique_ptr<VideoCodingModule> vcm_;
MockVCMReceiveCallback receive_callback_;
VideoCodec video_codec_;
MockVCMFrameTypeCallback frame_type_callback_;
MockPacketRequestCallback request_callback_;
NiceMock<MockVideoDecoder> decoder_;
NiceMock<MockVideoDecoder> decoderCopy_;
std::unique_ptr<SimulatedClock> clock_;
NullEventFactory event_factory_;
};
TEST_F(VCMRobustnessTest, TestHardNack) {
Sequence s;
EXPECT_CALL(request_callback_, ResendPackets(_, 2))
.With(Args<0, 1>(ElementsAre(6, 7)))
.Times(1);
for (int ts = 0; ts <= 6000; ts += 3000) {
EXPECT_CALL(decoder_,
Decode(AllOf(Field(&EncodedImage::_timeStamp, ts),
Field(&EncodedImage::_length, kPayloadLen * 3),
Field(&EncodedImage::_completeFrame, true)),
false, _, _, _))
.Times(1)
.InSequence(s);
}
ASSERT_EQ(VCM_OK, vcm_->SetReceiverRobustnessMode(
VideoCodingModule::kHardNack, kNoErrors));
InsertPacket(0, 0, true, false, kVideoFrameKey);
InsertPacket(0, 1, false, false, kVideoFrameKey);
InsertPacket(0, 2, false, true, kVideoFrameKey);
clock_->AdvanceTimeMilliseconds(1000 / 30);
InsertPacket(3000, 3, true, false, kVideoFrameDelta);
InsertPacket(3000, 4, false, false, kVideoFrameDelta);
InsertPacket(3000, 5, false, true, kVideoFrameDelta);
clock_->AdvanceTimeMilliseconds(1000 / 30);
ASSERT_EQ(VCM_OK, vcm_->Decode(0));
ASSERT_EQ(VCM_OK, vcm_->Decode(0));
ASSERT_EQ(VCM_FRAME_NOT_READY, vcm_->Decode(0));
clock_->AdvanceTimeMilliseconds(10);
vcm_->Process();
ASSERT_EQ(VCM_FRAME_NOT_READY, vcm_->Decode(0));
InsertPacket(6000, 8, false, true, kVideoFrameDelta);
clock_->AdvanceTimeMilliseconds(10);
vcm_->Process();
ASSERT_EQ(VCM_FRAME_NOT_READY, vcm_->Decode(0));
InsertPacket(6000, 6, true, false, kVideoFrameDelta);
InsertPacket(6000, 7, false, false, kVideoFrameDelta);
clock_->AdvanceTimeMilliseconds(10);
vcm_->Process();
ASSERT_EQ(VCM_OK, vcm_->Decode(0));
}
TEST_F(VCMRobustnessTest, TestHardNackNoneDecoded) {
EXPECT_CALL(request_callback_, ResendPackets(_, _)).Times(0);
EXPECT_CALL(frame_type_callback_, RequestKeyFrame()).Times(1);
ASSERT_EQ(VCM_OK, vcm_->SetReceiverRobustnessMode(
VideoCodingModule::kHardNack, kNoErrors));
InsertPacket(3000, 3, true, false, kVideoFrameDelta);
InsertPacket(3000, 4, false, false, kVideoFrameDelta);
InsertPacket(3000, 5, false, true, kVideoFrameDelta);
EXPECT_EQ(VCM_FRAME_NOT_READY, vcm_->Decode(0));
vcm_->Process();
clock_->AdvanceTimeMilliseconds(10);
EXPECT_EQ(VCM_FRAME_NOT_READY, vcm_->Decode(0));
vcm_->Process();
}
TEST_F(VCMRobustnessTest, TestModeNoneWithErrors) {
EXPECT_CALL(decoder_, InitDecode(_, _)).Times(1);
EXPECT_CALL(decoder_, Release()).Times(1);
Sequence s1;
EXPECT_CALL(request_callback_, ResendPackets(_, 1))
.With(Args<0, 1>(ElementsAre(4)))
.Times(0);
EXPECT_CALL(decoder_, Copy()).Times(0);
EXPECT_CALL(decoderCopy_, Copy()).Times(0);
// Decode operations
EXPECT_CALL(decoder_,
Decode(AllOf(Field(&EncodedImage::_timeStamp, 0),
Field(&EncodedImage::_completeFrame, true)),
false, _, _, _))
.Times(1)
.InSequence(s1);
EXPECT_CALL(decoder_,
Decode(AllOf(Field(&EncodedImage::_timeStamp, 3000),
Field(&EncodedImage::_completeFrame, false)),
false, _, _, _))
.Times(1)
.InSequence(s1);
EXPECT_CALL(decoder_,
Decode(AllOf(Field(&EncodedImage::_timeStamp, 6000),
Field(&EncodedImage::_completeFrame, true)),
false, _, _, _))
.Times(1)
.InSequence(s1);
EXPECT_CALL(decoder_,
Decode(AllOf(Field(&EncodedImage::_timeStamp, 9000),
Field(&EncodedImage::_completeFrame, true)),
false, _, _, _))
.Times(1)
.InSequence(s1);
ASSERT_EQ(VCM_OK, vcm_->SetReceiverRobustnessMode(VideoCodingModule::kNone,
kWithErrors));
InsertPacket(0, 0, true, false, kVideoFrameKey);
InsertPacket(0, 1, false, false, kVideoFrameKey);
InsertPacket(0, 2, false, true, kVideoFrameKey);
EXPECT_EQ(VCM_OK, vcm_->Decode(33)); // Decode timestamp 0.
vcm_->Process();
clock_->AdvanceTimeMilliseconds(33);
InsertPacket(3000, 3, true, false, kVideoFrameDelta);
// Packet 4 missing
InsertPacket(3000, 5, false, true, kVideoFrameDelta);
EXPECT_EQ(VCM_FRAME_NOT_READY, vcm_->Decode(0));
vcm_->Process();
clock_->AdvanceTimeMilliseconds(33);
InsertPacket(6000, 6, true, false, kVideoFrameDelta);
InsertPacket(6000, 7, false, false, kVideoFrameDelta);
InsertPacket(6000, 8, false, true, kVideoFrameDelta);
EXPECT_EQ(VCM_OK, vcm_->Decode(0)); // Decode timestamp 3000 incomplete.
vcm_->Process();
clock_->AdvanceTimeMilliseconds(10);
EXPECT_EQ(VCM_OK, vcm_->Decode(23)); // Decode timestamp 6000 complete.
vcm_->Process();
clock_->AdvanceTimeMilliseconds(23);
InsertPacket(3000, 4, false, false, kVideoFrameDelta);
InsertPacket(9000, 9, true, false, kVideoFrameDelta);
InsertPacket(9000, 10, false, false, kVideoFrameDelta);
InsertPacket(9000, 11, false, true, kVideoFrameDelta);
EXPECT_EQ(VCM_OK, vcm_->Decode(33)); // Decode timestamp 9000 complete.
}
} // namespace webrtc

30
webrtc/modules/video_coding/video_receiver.cc
View File

@ -129,8 +129,7 @@ int32_t VideoReceiver::SetReceiveChannelParameters(int64_t rtt) {
// Enable or disable a video protection method.
// Note: This API should be deprecated, as it does not offer a distinction
// between the protection method and decoding with or without errors. If such a
// behavior is desired, use the following API: SetReceiverRobustnessMode.
// between the protection method and decoding with or without errors.
int32_t VideoReceiver::SetVideoProtection(VCMVideoProtection videoProtection,
bool enable) {
// By default, do not decode with errors.
@ -412,8 +411,11 @@ int32_t VideoReceiver::Delay() const {
}
int VideoReceiver::SetReceiverRobustnessMode(
ReceiverRobustness robustnessMode,
VideoCodingModule::ReceiverRobustness robustnessMode,
VCMDecodeErrorMode decode_error_mode) {
RTC_DCHECK(construction_thread_.CalledOnValidThread());
// TODO(tommi): This method must only be called when the decoder thread
// is not running and we don't need to hold this lock.
rtc::CritScope cs(&receive_crit_);
switch (robustnessMode) {
case VideoCodingModule::kNone:
@ -423,28 +425,10 @@ int VideoReceiver::SetReceiverRobustnessMode(
// Always wait for retransmissions (except when decoding with errors).
_receiver.SetNackMode(kNack, -1, -1);
break;
case VideoCodingModule::kSoftNack:
#if 1
assert(false); // TODO(hlundin): Not completed.
return VCM_NOT_IMPLEMENTED;
#else
// Enable hybrid NACK/FEC. Always wait for retransmissions and don't add
// extra delay when RTT is above kLowRttNackMs.
_receiver.SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
break;
#endif
case VideoCodingModule::kReferenceSelection:
#if 1
assert(false); // TODO(hlundin): Not completed.
return VCM_NOT_IMPLEMENTED;
#else
if (decode_error_mode == kNoErrors) {
default:
RTC_NOTREACHED();
return VCM_PARAMETER_ERROR;
}
_receiver.SetNackMode(kNoNack, -1, -1);
break;
#endif
}
_receiver.SetDecodeErrorMode(decode_error_mode);
return VCM_OK;
}