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

Support layer skipping in key svc structures

Browse Source 
Add KSvc structure for 3 spatial and 3 temporal layers to allow to cover
more scenarious

Bug: webrtc:11999
Change-Id: Id16d1acfb4ca5f98d1b17d8f66d54b31d22d0745
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/188122
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#32434}
This commit is contained in:
Danil Chapovalov
2020-10-16 16:14:58 +02:00
committed by Commit Bot
parent 609b047b07
commit 4b18e24967
12 changed files with 641 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
modules/video_coding/svc/scalability_structure_test_helpers.cc
View File

@ -14,6 +14,7 @@
#include <utility>
#include <vector>
#include "api/array_view.h"
#include "api/transport/rtp/dependency_descriptor.h"
#include "api/video/video_bitrate_allocation.h"
#include "api/video/video_frame_type.h"
@ -38,58 +39,66 @@ VideoBitrateAllocation EnableTemporalLayers(int s0, int s1, int s2) {
return bitrate;
}
std::vector<GenericFrameInfo> ScalabilityStructureWrapper::GenerateFrames(
void ScalabilityStructureWrapper::GenerateFrames(
int num_temporal_units,
bool restart) {
std::vector<GenericFrameInfo> frames;
std::vector<GenericFrameInfo>& frames) {
for (int i = 0; i < num_temporal_units; ++i) {
for (auto& layer_frame : structure_controller_.NextFrameConfig(restart)) {
for (auto& layer_frame :
structure_controller_.NextFrameConfig(/*restart=*/false)) {
int64_t frame_id = ++frame_id_;
bool is_keyframe = layer_frame.IsKeyframe();
absl::optional<GenericFrameInfo> frame_info =
structure_controller_.OnEncodeDone(std::move(layer_frame));
EXPECT_TRUE(frame_info.has_value());
GenericFrameInfo frame_info =
structure_controller_.OnEncodeDone(layer_frame);
if (is_keyframe) {
chain_diff_calculator_.Reset(frame_info->part_of_chain);
chain_diff_calculator_.Reset(frame_info.part_of_chain);
}
frame_info->chain_diffs =
chain_diff_calculator_.From(frame_id, frame_info->part_of_chain);
frame_info.chain_diffs =
chain_diff_calculator_.From(frame_id, frame_info.part_of_chain);
for (int64_t base_frame_id : frame_deps_calculator_.FromBuffersUsage(
is_keyframe ? VideoFrameType::kVideoFrameKey
: VideoFrameType::kVideoFrameDelta,
frame_id, frame_info->encoder_buffers)) {
EXPECT_LT(base_frame_id, frame_id);
EXPECT_GE(base_frame_id, 0);
frame_info->frame_diffs.push_back(frame_id - base_frame_id);
frame_id, frame_info.encoder_buffers)) {
frame_info.frame_diffs.push_back(frame_id - base_frame_id);
}
frames.push_back(*std::move(frame_info));
frames.push_back(std::move(frame_info));
}
restart = false;
}
}
if (restart) {
buffer_contains_frame_.reset();
}
for (const GenericFrameInfo& frame : frames) {
bool ScalabilityStructureWrapper::FrameReferencesAreValid(
rtc::ArrayView<const GenericFrameInfo> frames) const {
bool valid = true;
// VP9 and AV1 supports up to 8 buffers. Expect no more buffers are not used.
std::bitset<8> buffer_contains_frame;
for (size_t i = 0; i < frames.size(); ++i) {
const GenericFrameInfo& frame = frames[i];
for (const CodecBufferUsage& buffer_usage : frame.encoder_buffers) {
if (buffer_usage.id < 0 || buffer_usage.id >= 8) {
ADD_FAILURE() << "Invalid buffer id " << buffer_usage.id
<< " for frame#" << i
<< ". Up to 8 buffers are supported.";
valid = false;
continue;
}
if (buffer_usage.referenced && !buffer_contains_frame_[buffer_usage.id]) {
ADD_FAILURE() << "buffer " << buffer_usage.id
if (buffer_usage.referenced && !buffer_contains_frame[buffer_usage.id]) {
ADD_FAILURE() << "buffer " << buffer_usage.id << " for frame#" << i
<< " was reference before updated.";
valid = false;
}
if (buffer_usage.updated) {
buffer_contains_frame_.set(buffer_usage.id);
buffer_contains_frame.set(buffer_usage.id);
}
}
for (int fdiff : frame.frame_diffs) {
if (fdiff <= 0 || static_cast<size_t>(fdiff) > i) {
ADD_FAILURE() << "Invalid frame diff " << fdiff << " for frame#" << i;
valid = false;
}
}
}
return frames;
return valid;
}
} // namespace webrtc