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

Add ProtectionBitrateCalculator as an abstract class. ProtectionBitrateCalculatorDefault implements ProtectionBitrateCalculator. Register VideoSendStream to packet feedback

Browse Source 
Bug: webrtc:8656
Change-Id: Iab4f6ab8997cb082762218afc8580e9985ac2522
Reviewed-on: https://webrtc-review.googlesource.com/33010
Commit-Queue: Ying Wang <yinwa@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21348}
This commit is contained in:
Ying Wang
2017-12-18 14:49:46 +01:00
committed by Commit Bot
parent d6c54cdc8e
commit e58e91b6d1
7 changed files with 181 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
modules/video_coding/BUILD.gn
View File

@ -57,8 +57,9 @@ rtc_static_library("video_coding") {
"packet.h",
"packet_buffer.cc",
"packet_buffer.h",
"protection_bitrate_calculator.cc",
"protection_bitrate_calculator.h",
"protection_bitrate_calculator_default.cc",
"protection_bitrate_calculator_default.h",
"qp_parser.cc",
"qp_parser.h",
"receiver.cc",

58
modules/video_coding/protection_bitrate_calculator.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
* Copyright (c) 2017 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
@ -13,6 +13,7 @@
#include <list>
#include <memory>
#include <vector>
#include "modules/include/module_common_types.h"
#include "modules/video_coding/include/video_coding.h"
@ -22,57 +23,38 @@
namespace webrtc {
// ProtectionBitrateCalculator calculates how much of the allocated network
// capacity that can be used by an encoder and how much that
// is needed for redundant packets such as FEC and NACK. It uses an
// implementation of |VCMProtectionCallback| to set new FEC parameters and get
// the bitrate currently used for FEC and NACK.
// Usage:
// Setup by calling SetProtectionMethod and SetEncodingData.
// For each encoded image, call UpdateWithEncodedData.
// Each time the bandwidth estimate change, call SetTargetRates. SetTargetRates
// will return the bitrate that can be used by an encoder.
// A lock is used to protect internal states, so methods can be called on an
// arbitrary thread.
class ProtectionBitrateCalculator {
public:
ProtectionBitrateCalculator(Clock* clock,
VCMProtectionCallback* protection_callback);
~ProtectionBitrateCalculator();
virtual ~ProtectionBitrateCalculator() {}
void SetProtectionMethod(bool enable_fec, bool enable_nack);
virtual void SetProtectionMethod(bool enable_fec, bool enable_nack) = 0;
// Informs media optimization of initial encoding state.
void SetEncodingData(size_t width,
size_t height,
size_t num_temporal_layers,
size_t max_payload_size);
virtual void SetEncodingData(size_t width,
size_t height,
size_t num_temporal_layers,
size_t max_payload_size) = 0;
// Returns target rate for the encoder given the channel parameters.
// Inputs: estimated_bitrate_bps - the estimated network bitrate in bits/s.
// actual_framerate - encoder frame rate.
// fraction_lost - packet loss rate in % in the network.
// round_trip_time_ms - round trip time in milliseconds.
uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
int actual_framerate,
uint8_t fraction_lost,
int64_t round_trip_time_ms);
virtual uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
int actual_framerate,
uint8_t fraction_lost,
int64_t round_trip_time_ms) = 0;
virtual uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
std::vector<uint8_t> loss_mask_vector,
int64_t round_trip_time_ms) = 0;
// Informs of encoded output.
void UpdateWithEncodedData(const EncodedImage& encoded_image);
virtual void UpdateWithEncodedData(const EncodedImage& encoded_image) = 0;
private:
enum { kBitrateAverageWinMs = 1000 };
Clock* const clock_;
VCMProtectionCallback* const protection_callback_;
rtc::CriticalSection crit_sect_;
std::unique_ptr<media_optimization::VCMLossProtectionLogic> loss_prot_logic_
RTC_GUARDED_BY(crit_sect_);
size_t max_payload_size_ RTC_GUARDED_BY(crit_sect_);
RTC_DISALLOW_COPY_AND_ASSIGN(ProtectionBitrateCalculator);
virtual void OnLossMaskVector(const std::vector<bool> loss_mask_vector) = 0;
};
} // namespace webrtc
#endif // MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_H_

23
modules/video_coding/protection_bitrate_calculator.cc → modules/video_coding/protection_bitrate_calculator_default.cc
View File

@ -8,13 +8,13 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/video_coding/protection_bitrate_calculator.h"
#include "modules/video_coding/protection_bitrate_calculator_default.h"
namespace webrtc {
using rtc::CritScope;
ProtectionBitrateCalculator::ProtectionBitrateCalculator(
ProtectionBitrateCalculatorDefault::ProtectionBitrateCalculatorDefault(
Clock* clock,
VCMProtectionCallback* protection_callback)
: clock_(clock),
@ -23,21 +23,22 @@ ProtectionBitrateCalculator::ProtectionBitrateCalculator(
clock_->TimeInMilliseconds())),
max_payload_size_(1460) {}
ProtectionBitrateCalculator::~ProtectionBitrateCalculator(void) {
ProtectionBitrateCalculatorDefault::~ProtectionBitrateCalculatorDefault(void) {
loss_prot_logic_->Release();
}
void ProtectionBitrateCalculator::SetEncodingData(size_t width,
size_t height,
size_t num_temporal_layers,
size_t max_payload_size) {
void ProtectionBitrateCalculatorDefault::SetEncodingData(
size_t width,
size_t height,
size_t num_temporal_layers,
size_t max_payload_size) {
CritScope lock(&crit_sect_);
loss_prot_logic_->UpdateFrameSize(width, height);
loss_prot_logic_->UpdateNumLayers(num_temporal_layers);
max_payload_size_ = max_payload_size;
}
uint32_t ProtectionBitrateCalculator::SetTargetRates(
uint32_t ProtectionBitrateCalculatorDefault::SetTargetRates(
uint32_t estimated_bitrate_bps,
int actual_framerate_fps,
uint8_t fraction_lost,
@ -138,8 +139,8 @@ uint32_t ProtectionBitrateCalculator::SetTargetRates(
return estimated_bitrate_bps * (1.0 - protection_overhead_rate);
}
void ProtectionBitrateCalculator::SetProtectionMethod(bool enable_fec,
bool enable_nack) {
void ProtectionBitrateCalculatorDefault::SetProtectionMethod(bool enable_fec,
bool enable_nack) {
media_optimization::VCMProtectionMethodEnum method(media_optimization::kNone);
if (enable_fec && enable_nack) {
method = media_optimization::kNackFec;
@ -152,7 +153,7 @@ void ProtectionBitrateCalculator::SetProtectionMethod(bool enable_fec,
loss_prot_logic_->SetMethod(method);
}
void ProtectionBitrateCalculator::UpdateWithEncodedData(
void ProtectionBitrateCalculatorDefault::UpdateWithEncodedData(
const EncodedImage& encoded_image) {
const size_t encoded_length = encoded_image._length;
CritScope lock(&crit_sect_);

87
modules/video_coding/protection_bitrate_calculator_default.h Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright (c) 2016 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 MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_DEFAULT_H_
#define MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_DEFAULT_H_
#include <list>
#include <memory>
#include <vector>
#include "modules/include/module_common_types.h"
#include "modules/video_coding/include/video_coding.h"
#include "modules/video_coding/media_opt_util.h"
#include "modules/video_coding/protection_bitrate_calculator.h"
#include "rtc_base/criticalsection.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
// ProtectionBitrateCalculator calculates how much of the allocated network
// capacity that can be used by an encoder and how much that
// is needed for redundant packets such as FEC and NACK. It uses an
// implementation of |VCMProtectionCallback| to set new FEC parameters and get
// the bitrate currently used for FEC and NACK.
// Usage:
// Setup by calling SetProtectionMethod and SetEncodingData.
// For each encoded image, call UpdateWithEncodedData.
// Each time the bandwidth estimate change, call SetTargetRates. SetTargetRates
// will return the bitrate that can be used by an encoder.
// A lock is used to protect internal states, so methods can be called on an
// arbitrary thread.
class ProtectionBitrateCalculatorDefault : public ProtectionBitrateCalculator {
public:
ProtectionBitrateCalculatorDefault(
Clock* clock,
VCMProtectionCallback* protection_callback);
~ProtectionBitrateCalculatorDefault();
void SetProtectionMethod(bool enable_fec, bool enable_nack) override;
// Informs media optimization of initial encoding state.
void SetEncodingData(size_t width,
size_t height,
size_t num_temporal_layers,
size_t max_payload_size) override;
uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
std::vector<uint8_t> loss_mask_vector,
int64_t round_trip_time_ms) override {
return 0;
}
void OnLossMaskVector(const std::vector<bool> loss_mask_vector) override {}
// Returns target rate for the encoder given the channel parameters.
// Inputs: estimated_bitrate_bps - the estimated network bitrate in bits/s.
// actual_framerate - encoder frame rate.
// fraction_lost - packet loss rate in % in the network.
// round_trip_time_ms - round trip time in milliseconds.
uint32_t SetTargetRates(uint32_t estimated_bitrate_bps,
int actual_framerate,
uint8_t fraction_lost,
int64_t round_trip_time_ms) override;
// Informs of encoded output.
void UpdateWithEncodedData(const EncodedImage& encoded_image) override;
private:
enum { kBitrateAverageWinMs = 1000 };
Clock* const clock_;
VCMProtectionCallback* const protection_callback_;
rtc::CriticalSection crit_sect_;
std::unique_ptr<media_optimization::VCMLossProtectionLogic> loss_prot_logic_
RTC_GUARDED_BY(crit_sect_);
size_t max_payload_size_ RTC_GUARDED_BY(crit_sect_);
RTC_DISALLOW_COPY_AND_ASSIGN(ProtectionBitrateCalculatorDefault);
};
} // namespace webrtc
#endif // MODULES_VIDEO_CODING_PROTECTION_BITRATE_CALCULATOR_DEFAULT_H_

4
modules/video_coding/protection_bitrate_calculator_unittest.cc
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/video_coding/protection_bitrate_calculator.h"
#include "modules/video_coding/protection_bitrate_calculator_default.h"
#include "system_wrappers/include/clock.h"
#include "test/gtest.h"
@ -46,7 +46,7 @@ class ProtectionBitrateCalculatorTest : public ::testing::Test {
SimulatedClock clock_;
ProtectionCallback protection_callback_;
ProtectionBitrateCalculator media_opt_;
ProtectionBitrateCalculatorDefault media_opt_;
};
TEST_F(ProtectionBitrateCalculatorTest, ProtectsUsingFecBitrate) {