Revert 4911 "Adding temporal layer strategy that keeps base laye..."
> Adding temporal layer strategy that keeps base layer framerate at an acceptable value.
>
> R=stefan@webrtc.org
>
> Review URL: https://webrtc-codereview.appspot.com/2272005
TBR=andresp@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/2349004
git-svn-id: http://webrtc.googlecode.com/svn/trunk/webrtc@4913 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/modules/video_coding/codecs/vp8/include/vp8_common_types.h b/modules/video_coding/codecs/vp8/include/vp8_common_types.h
index c2cefdd..8b97b3b 100644
--- a/modules/video_coding/codecs/vp8/include/vp8_common_types.h
+++ b/modules/video_coding/codecs/vp8/include/vp8_common_types.h
@@ -18,11 +18,11 @@
// Ratio allocation between temporal streams:
// Values as required for the VP8 codec (accumulating).
static const float
- kVp8LayerRateAlloction[kMaxTemporalStreams][kMaxTemporalStreams] = {
- {1.0f, 1.0f, 1.0f, 1.0f}, // 1 layer
- {0.6f, 1.0f, 1.0f, 1.0f}, // 2 layers {60%, 40%}
- {0.4f, 0.6f, 1.0f, 1.0f}, // 3 layers {40%, 20%, 40%}
- {0.25f, 0.4f, 0.6f, 1.0f} // 4 layers {25%, 15%, 20%, 40%}
+ kVp8LayerRateAlloction[kMaxTemporalStreams][kMaxTemporalStreams] = {
+ {1.0f, 0, 0, 0}, // 1 layer
+ {0.6f, 1.0f , 0 , 0}, // 2 layers {60%, 40%}
+ {0.4f, 0.6f , 1.0f, 0}, // 3 layers {40%, 20%, 40%}
+ {0.25f, 0.4f, 0.6f, 1.0f} // 4 layers {25%, 15%, 20%, 40%}
};
} // namespace webrtc
diff --git a/modules/video_coding/codecs/vp8/realtime_temporal_layers.cc b/modules/video_coding/codecs/vp8/realtime_temporal_layers.cc
deleted file mode 100644
index ba7412b..0000000
--- a/modules/video_coding/codecs/vp8/realtime_temporal_layers.cc
+++ /dev/null
@@ -1,268 +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 <stdlib.h>
-#include <algorithm>
-
-#include "vpx/vpx_encoder.h"
-#include "vpx/vp8cx.h"
-#include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
-#include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
-#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
-
-// This file implements logic to adapt the number of temporal layers based on
-// input frame rate in order to avoid having the base layer being relaying at
-// a below acceptable framerate.
-namespace webrtc {
-namespace {
-enum {
- kTemporalUpdateLast = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
- VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF,
-
- kTemporalUpdateGolden =
- VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST,
-
- kTemporalUpdateGoldenWithoutDependency =
- kTemporalUpdateGolden | VP8_EFLAG_NO_REF_GF,
-
- kTemporalUpdateAltref = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_LAST,
-
- kTemporalUpdateAltrefWithoutDependency =
- kTemporalUpdateAltref | VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF,
-
- kTemporalUpdateNone = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
- VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY,
-
- kTemporalUpdateNoneNoRefAltref = kTemporalUpdateNone | VP8_EFLAG_NO_REF_ARF,
-
- kTemporalUpdateNoneNoRefGoldenRefAltRef =
- VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
- VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ENTROPY,
-
- kTemporalUpdateGoldenWithoutDependencyRefAltRef =
- VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST,
-
- kTemporalUpdateLastRefAltRef =
- VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF,
-
- kTemporalUpdateGoldenRefAltRef = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST,
-
- kTemporalUpdateLastAndGoldenRefAltRef =
- VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_REF_GF,
-
- kTemporalUpdateLastRefAll = VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF,
-};
-
-int CalculateNumberOfTemporalLayers(int current_temporal_layers,
- int input_fps) {
- if (input_fps >= 24) {
- return 3;
- }
- if (input_fps >= 20 && current_temporal_layers >= 3) {
- // Keep doing 3 temporal layers until we go below 20fps.
- return 3;
- }
- if (input_fps >= 10) {
- return 2;
- }
- if (input_fps > 8 && current_temporal_layers >= 2) {
- // keep doing 2 temporal layers until we go below 8fps
- return 2;
- }
- return 1;
-}
-
-class RealTimeTemporalLayers : public TemporalLayers {
- public:
- RealTimeTemporalLayers(int max_num_temporal_layers,
- uint8_t initial_tl0_pic_idx)
- : temporal_layers_(1),
- max_temporal_layers_(max_num_temporal_layers),
- tl0_pic_idx_(initial_tl0_pic_idx),
- frame_counter_(static_cast<unsigned int>(-1)),
- timestamp_(0),
- last_base_layer_sync_(0),
- layer_ids_length_(0),
- layer_ids_(NULL),
- encode_flags_length_(0),
- encode_flags_(NULL) {
- assert(max_temporal_layers_ >= 1);
- assert(max_temporal_layers_ <= 3);
- }
-
- virtual ~RealTimeTemporalLayers() {}
-
- virtual bool ConfigureBitrates(int bitrate_kbit,
- int max_bitrate_kbit,
- int framerate,
- vpx_codec_enc_cfg_t* cfg) {
- temporal_layers_ =
- CalculateNumberOfTemporalLayers(temporal_layers_, framerate);
- temporal_layers_ = std::min(temporal_layers_, max_temporal_layers_);
- assert(temporal_layers_ >= 1 && temporal_layers_ <= 3);
-
- cfg->ts_number_layers = temporal_layers_;
- for (int tl = 0; tl < temporal_layers_; ++tl) {
- cfg->ts_target_bitrate[tl] =
- bitrate_kbit * kVp8LayerRateAlloction[temporal_layers_ - 1][tl];
- }
-
- switch (temporal_layers_) {
- case 1: {
- static const unsigned int layer_ids[] = {0u};
- layer_ids_ = layer_ids;
- layer_ids_length_ = sizeof(layer_ids) / sizeof(*layer_ids);
-
- static const int encode_flags[] = {kTemporalUpdateLastRefAll};
- encode_flags_length_ = sizeof(encode_flags) / sizeof(*layer_ids);
- encode_flags_ = encode_flags;
-
- cfg->ts_rate_decimator[0] = 1;
- cfg->ts_periodicity = layer_ids_length_;
- } break;
-
- case 2: {
- static const unsigned int layer_ids[] = {0u, 1u};
- layer_ids_ = layer_ids;
- layer_ids_length_ = sizeof(layer_ids) / sizeof(*layer_ids);
-
- static const int encode_flags[] = {
- kTemporalUpdateLastAndGoldenRefAltRef,
- kTemporalUpdateGoldenWithoutDependencyRefAltRef,
- kTemporalUpdateLastRefAltRef, kTemporalUpdateGoldenRefAltRef,
- kTemporalUpdateLastRefAltRef, kTemporalUpdateGoldenRefAltRef,
- kTemporalUpdateLastRefAltRef, kTemporalUpdateNone
- };
- encode_flags_length_ = sizeof(encode_flags) / sizeof(*layer_ids);
- encode_flags_ = encode_flags;
-
- cfg->ts_rate_decimator[0] = 2;
- cfg->ts_rate_decimator[1] = 1;
- cfg->ts_periodicity = layer_ids_length_;
- } break;
-
- case 3: {
- static const unsigned int layer_ids[] = {0u, 2u, 1u, 2u};
- layer_ids_ = layer_ids;
- layer_ids_length_ = sizeof(layer_ids) / sizeof(*layer_ids);
-
- static const int encode_flags[] = {
- kTemporalUpdateLastAndGoldenRefAltRef,
- kTemporalUpdateNoneNoRefGoldenRefAltRef,
- kTemporalUpdateGoldenWithoutDependencyRefAltRef, kTemporalUpdateNone,
- kTemporalUpdateLastRefAltRef, kTemporalUpdateNone,
- kTemporalUpdateGoldenRefAltRef, kTemporalUpdateNone
- };
- encode_flags_length_ = sizeof(encode_flags) / sizeof(*layer_ids);
- encode_flags_ = encode_flags;
-
- cfg->ts_rate_decimator[0] = 4;
- cfg->ts_rate_decimator[1] = 2;
- cfg->ts_rate_decimator[2] = 1;
- cfg->ts_periodicity = layer_ids_length_;
- } break;
-
- default:
- assert(false);
- return false;
- }
- memcpy(
- cfg->ts_layer_id, layer_ids_, sizeof(unsigned int) * layer_ids_length_);
- return true;
- }
-
- virtual int EncodeFlags(uint32_t timestamp) {
- frame_counter_++;
- return CurrentEncodeFlags();
- }
-
- int CurrentEncodeFlags() const {
- assert(encode_flags_length_ > 0 && encode_flags_ != NULL);
- int index = frame_counter_ % encode_flags_length_;
- assert(index >= 0 && index < encode_flags_length_);
- return encode_flags_[index];
- }
-
- unsigned int CurrentLayerId() const {
- assert(layer_ids_length_ > 0 && layer_ids_ != NULL);
- int index = frame_counter_ % layer_ids_length_;
- assert(index >= 0 && index < layer_ids_length_);
- return layer_ids_[index];
- }
-
- virtual void PopulateCodecSpecific(bool base_layer_sync,
- CodecSpecificInfoVP8* vp8_info,
- uint32_t timestamp) {
- assert(temporal_layers_ > 0);
-
- if (temporal_layers_ == 1) {
- vp8_info->temporalIdx = kNoTemporalIdx;
- vp8_info->layerSync = false;
- vp8_info->tl0PicIdx = kNoTl0PicIdx;
- } else {
- if (base_layer_sync) {
- vp8_info->temporalIdx = 0;
- vp8_info->layerSync = true;
- } else {
- vp8_info->temporalIdx = CurrentLayerId();
- int temporal_reference = CurrentEncodeFlags();
-
- if (temporal_reference == kTemporalUpdateAltrefWithoutDependency ||
- temporal_reference == kTemporalUpdateGoldenWithoutDependency ||
- temporal_reference ==
- kTemporalUpdateGoldenWithoutDependencyRefAltRef ||
- temporal_reference == kTemporalUpdateNoneNoRefGoldenRefAltRef ||
- (temporal_reference == kTemporalUpdateNone &&
- temporal_layers_ == 4)) {
- vp8_info->layerSync = true;
- } else {
- vp8_info->layerSync = false;
- }
- }
- if (last_base_layer_sync_ && vp8_info->temporalIdx != 0) {
- // Regardless of pattern the frame after a base layer sync will always
- // be a layer sync.
- vp8_info->layerSync = true;
- }
- if (vp8_info->temporalIdx == 0 && timestamp != timestamp_) {
- timestamp_ = timestamp;
- tl0_pic_idx_++;
- }
- last_base_layer_sync_ = base_layer_sync;
- vp8_info->tl0PicIdx = tl0_pic_idx_;
- }
- }
-
- void FrameEncoded(unsigned int size, uint32_t timestamp) {}
-
- private:
- int temporal_layers_;
- int max_temporal_layers_;
-
- int tl0_pic_idx_;
- unsigned int frame_counter_;
- uint32_t timestamp_;
- bool last_base_layer_sync_;
-
- // Pattern of temporal layer ids.
- int layer_ids_length_;
- const unsigned int* layer_ids_;
-
- // Pattern of encode flags.
- int encode_flags_length_;
- const int* encode_flags_;
-};
-} // namespace
-
-TemporalLayers* RealTimeTemporalLayersFactory::Create(
- int max_temporal_layers,
- uint8_t initial_tl0_pic_idx) const {
- return new RealTimeTemporalLayers(max_temporal_layers, initial_tl0_pic_idx);
-}
-} // namespace webrtc
diff --git a/modules/video_coding/codecs/vp8/temporal_layers.h b/modules/video_coding/codecs/vp8/temporal_layers.h
index 4549e28..9df88b9 100644
--- a/modules/video_coding/codecs/vp8/temporal_layers.h
+++ b/modules/video_coding/codecs/vp8/temporal_layers.h
@@ -24,8 +24,6 @@
class TemporalLayers {
public:
- // Factory for TemporalLayer strategy. Default behaviour is a fixed pattern
- // of temporal layers. See default_temporal_layers.cc
struct Factory {
Factory() {}
virtual ~Factory() {}
@@ -51,14 +49,5 @@
virtual void FrameEncoded(unsigned int size, uint32_t timestamp) = 0;
};
-// Factory for a temporal layers strategy that adaptively changes the number of
-// layers based on input framerate so that the base layer has an acceptable
-// framerate. See realtime_temporal_layers.cc
-struct RealTimeTemporalLayersFactory : TemporalLayers::Factory {
- virtual ~RealTimeTemporalLayersFactory() {}
- virtual TemporalLayers* Create(int num_temporal_layers,
- uint8_t initial_tl0_pic_idx) const;
-};
-
} // namespace webrtc
#endif // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_TEMPORAL_LAYERS_H_
diff --git a/modules/video_coding/codecs/vp8/vp8.gyp b/modules/video_coding/codecs/vp8/vp8.gyp
index b3859a5..2fd3150 100644
--- a/modules/video_coding/codecs/vp8/vp8.gyp
+++ b/modules/video_coding/codecs/vp8/vp8.gyp
@@ -34,7 +34,6 @@
'vp8_impl.cc',
'default_temporal_layers.cc',
'default_temporal_layers.h',
- 'realtime_temporal_layers.cc',
'temporal_layers.h',
],
# Disable warnings to enable Win64 build, issue 1323.
diff --git a/modules/video_coding/main/source/video_sender_unittest.cc b/modules/video_coding/main/source/video_sender_unittest.cc
index bdf2947..9f341b1 100644
--- a/modules/video_coding/main/source/video_sender_unittest.cc
+++ b/modules/video_coding/main/source/video_sender_unittest.cc
@@ -11,11 +11,9 @@
#include <vector>
#include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/common.h"
#include "webrtc/common_video/test/frame_generator.h"
#include "webrtc/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h"
#include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
-#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
#include "webrtc/modules/video_coding/main/interface/mock/mock_vcm_callbacks.h"
#include "webrtc/modules/video_coding/main/interface/video_coding.h"
#include "webrtc/modules/video_coding/main/source/video_coding_impl.h"
@@ -33,40 +31,12 @@
using ::testing::NiceMock;
using ::testing::Pointee;
using ::testing::Return;
-using ::testing::FloatEq;
using std::vector;
using webrtc::test::FrameGenerator;
namespace webrtc {
namespace vcm {
namespace {
-enum {
- kMaxNumberOfTemporalLayers = 3
-};
-
-struct Vp8StreamInfo {
- float framerate_fps[kMaxNumberOfTemporalLayers];
- int bitrate_kbps[kMaxNumberOfTemporalLayers];
-};
-
-MATCHER_P(MatchesVp8StreamInfo, expected, "") {
- bool res = true;
- for (int tl = 0; tl < kMaxNumberOfTemporalLayers; ++tl) {
- if (abs(expected.framerate_fps[tl] - arg.framerate_fps[tl]) > 0.5) {
- *result_listener << " framerate_fps[" << tl
- << "] = " << arg.framerate_fps[tl] << " (expected "
- << expected.framerate_fps[tl] << ") ";
- res = false;
- }
- if (abs(expected.bitrate_kbps[tl] - arg.bitrate_kbps[tl]) > 10) {
- *result_listener << " bitrate_kbps[" << tl
- << "] = " << arg.bitrate_kbps[tl] << " (expected "
- << expected.bitrate_kbps[tl] << ") ";
- res = false;
- }
- }
- return res;
-}
class EmptyFrameGenerator : public FrameGenerator {
public:
@@ -111,15 +81,6 @@
interval_ms();
}
- Vp8StreamInfo CalculateVp8StreamInfo() {
- Vp8StreamInfo info;
- for (int tl = 0; tl < 3; ++tl) {
- info.framerate_fps[tl] = FramerateFpsWithinTemporalLayer(tl);
- info.bitrate_kbps[tl] = BitrateKbpsWithinTemporalLayer(tl);
- }
- return info;
- }
-
private:
struct FrameData {
FrameData() {}
@@ -358,18 +319,6 @@
}
}
- Vp8StreamInfo SimulateWithFramerate(float framerate) {
- const float short_simulation_interval = 5.0;
- const float long_simulation_interval = 10.0;
- // It appears that this 5 seconds simulation is needed to allow
- // bitrate and framerate to stabilize.
- InsertFrames(framerate, short_simulation_interval);
- packetization_callback_.Reset();
-
- InsertFrames(framerate, long_simulation_interval);
- return packetization_callback_.CalculateVp8StreamInfo();
- }
-
protected:
VideoCodec codec_;
int codec_bitrate_kbps_;
@@ -378,56 +327,51 @@
TEST_F(TestVideoSenderWithVp8,
DISABLED_ON_ANDROID(FixedTemporalLayersStrategy)) {
- const int low_b = codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][0];
- const int mid_b = codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][1];
- const int high_b = codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][2];
- {
- Vp8StreamInfo expected = {{7.5, 15.0, 30.0}, {low_b, mid_b, high_b}};
- EXPECT_THAT(SimulateWithFramerate(30.0), MatchesVp8StreamInfo(expected));
- }
- {
- Vp8StreamInfo expected = {{3.75, 7.5, 15.0}, {low_b, mid_b, high_b}};
- EXPECT_THAT(SimulateWithFramerate(15.0), MatchesVp8StreamInfo(expected));
- }
-}
+ // It appears that this 5 seconds simulation are need to allow
+ // bitrate and framerate to stabilize.
+ // TODO(andresp): the framerate calculation should be improved.
+ double framerate = 30.0;
+ InsertFrames(framerate, 5.0);
+ packetization_callback_.Reset();
-TEST_F(TestVideoSenderWithVp8,
- DISABLED_ON_ANDROID(RealTimeTemporalLayersStrategy)) {
- Config extra_options;
- extra_options.Set<TemporalLayers::Factory>(
- new RealTimeTemporalLayersFactory());
- VideoCodec codec = MakeVp8VideoCodec(352, 288, 3);
- codec.extra_options = &extra_options;
- codec.minBitrate = 10;
- codec.startBitrate = codec_bitrate_kbps_;
- codec.maxBitrate = codec_bitrate_kbps_;
- EXPECT_EQ(0, sender_->RegisterSendCodec(&codec, 1, 1200));
+ // Need to simulate for 10 seconds due to VP8 bitrate controller.
+ InsertFrames(framerate, 10.0);
+ EXPECT_NEAR(
+ packetization_callback_.FramerateFpsWithinTemporalLayer(2), 30.0, 0.5);
+ EXPECT_NEAR(
+ packetization_callback_.FramerateFpsWithinTemporalLayer(1), 15.0, 0.5);
+ EXPECT_NEAR(
+ packetization_callback_.FramerateFpsWithinTemporalLayer(0), 7.5, 0.5);
+ EXPECT_NEAR(packetization_callback_.BitrateKbpsWithinTemporalLayer(2),
+ codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][2],
+ 10);
+ EXPECT_NEAR(packetization_callback_.BitrateKbpsWithinTemporalLayer(1),
+ codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][1],
+ 10);
+ EXPECT_NEAR(packetization_callback_.BitrateKbpsWithinTemporalLayer(0),
+ codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][0],
+ 10);
- const int low_b = codec_bitrate_kbps_ * 0.4;
- const int mid_b = codec_bitrate_kbps_ * 0.6;
- const int high_b = codec_bitrate_kbps_;
+ framerate = 15.0;
+ InsertFrames(framerate, 5.0);
+ packetization_callback_.Reset();
- {
- Vp8StreamInfo expected = {{7.5, 15.0, 30.0}, {low_b, mid_b, high_b}};
- EXPECT_THAT(SimulateWithFramerate(30.0), MatchesVp8StreamInfo(expected));
- }
- {
- Vp8StreamInfo expected = {{5.0, 10.0, 20.0}, {low_b, mid_b, high_b}};
- EXPECT_THAT(SimulateWithFramerate(20.0), MatchesVp8StreamInfo(expected));
- }
- {
- Vp8StreamInfo expected = {{7.5, 15.0, 15.0}, {mid_b, high_b, high_b}};
- EXPECT_THAT(SimulateWithFramerate(15.0), MatchesVp8StreamInfo(expected));
- }
- {
- Vp8StreamInfo expected = {{5.0, 10.0, 10.0}, {mid_b, high_b, high_b}};
- EXPECT_THAT(SimulateWithFramerate(10.0), MatchesVp8StreamInfo(expected));
- }
- {
- // TODO(andresp): Find out why this fails with framerate = 7.5
- Vp8StreamInfo expected = {{7.0, 7.0, 7.0}, {high_b, high_b, high_b}};
- EXPECT_THAT(SimulateWithFramerate(7.0), MatchesVp8StreamInfo(expected));
- }
+ InsertFrames(15.0, 10.0);
+ EXPECT_NEAR(
+ packetization_callback_.FramerateFpsWithinTemporalLayer(2), 15.0, 0.5);
+ EXPECT_NEAR(
+ packetization_callback_.FramerateFpsWithinTemporalLayer(1), 7.5, 0.5);
+ EXPECT_NEAR(
+ packetization_callback_.FramerateFpsWithinTemporalLayer(0), 3.75, 0.5);
+ EXPECT_NEAR(packetization_callback_.BitrateKbpsWithinTemporalLayer(2),
+ codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][2],
+ 10);
+ EXPECT_NEAR(packetization_callback_.BitrateKbpsWithinTemporalLayer(1),
+ codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][1],
+ 10);
+ EXPECT_NEAR(packetization_callback_.BitrateKbpsWithinTemporalLayer(0),
+ codec_bitrate_kbps_ * kVp8LayerRateAlloction[2][0],
+ 10);
}
} // namespace
} // namespace vcm
