| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 */ | |
| 10 | |
| 11 #include <stdlib.h> // NULL | |
| 12 | |
| 13 #include "webrtc/modules/rtp_rtcp/source/vp8_partition_aggregator.h" | |
| 14 #include "webrtc/test/gtest.h" | |
| 15 | |
| 16 namespace webrtc { | |
| 17 | |
| 18 TEST(PartitionTreeNode, CreateAndDelete) { | |
| 19 const size_t kVector[] = {1, 2, 3}; | |
| 20 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector); | |
| 21 PartitionTreeNode* node1 = | |
| 22 PartitionTreeNode::CreateRootNode(kVector, kNumPartitions); | |
| 23 PartitionTreeNode* node2 = | |
| 24 new PartitionTreeNode(node1, kVector, kNumPartitions, 17); | |
| 25 delete node1; | |
| 26 delete node2; | |
| 27 } | |
| 28 | |
| 29 TEST(PartitionTreeNode, CreateChildrenAndDelete) { | |
| 30 const size_t kVector[] = {1, 2, 3}; | |
| 31 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector); | |
| 32 const size_t kMaxSize = 10; | |
| 33 const size_t kPenalty = 5; | |
| 34 PartitionTreeNode* root = | |
| 35 PartitionTreeNode::CreateRootNode(kVector, kNumPartitions); | |
| 36 EXPECT_TRUE(root->CreateChildren(kMaxSize)); | |
| 37 ASSERT_TRUE(NULL != root->left_child()); | |
| 38 ASSERT_TRUE(NULL != root->right_child()); | |
| 39 EXPECT_EQ(3u, root->left_child()->this_size()); | |
| 40 EXPECT_EQ(2u, root->right_child()->this_size()); | |
| 41 EXPECT_EQ(11, root->right_child()->Cost(kPenalty)); | |
| 42 EXPECT_FALSE(root->left_child()->packet_start()); | |
| 43 EXPECT_TRUE(root->right_child()->packet_start()); | |
| 44 delete root; | |
| 45 } | |
| 46 | |
| 47 TEST(PartitionTreeNode, FindOptimalConfig) { | |
| 48 const size_t kVector[] = {197, 194, 213, 215, 184, 199, 197, 207}; | |
| 49 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector); | |
| 50 const size_t kMaxSize = 1500; | |
| 51 const size_t kPenalty = 1; | |
| 52 PartitionTreeNode* root = | |
| 53 PartitionTreeNode::CreateRootNode(kVector, kNumPartitions); | |
| 54 root->set_max_parent_size(500); | |
| 55 root->set_min_parent_size(300); | |
| 56 PartitionTreeNode* opt = root->GetOptimalNode(kMaxSize, kPenalty); | |
| 57 ASSERT_TRUE(opt != NULL); | |
| 58 EXPECT_EQ(4u, opt->NumPackets()); | |
| 59 // Expect optimal sequence to be {1, 0, 1, 0, 1, 0, 1, 0}, which corresponds | |
| 60 // to (right)-left-right-left-right-left-right-left, where the root node is | |
| 61 // implicitly a "right" node by definition. | |
| 62 EXPECT_TRUE(opt->parent()->parent()->parent()->parent()->parent()-> | |
| 63 parent()->parent()->packet_start()); | |
| 64 EXPECT_FALSE(opt->parent()->parent()->parent()->parent()->parent()-> | |
| 65 parent()->packet_start()); | |
| 66 EXPECT_TRUE(opt->parent()->parent()->parent()->parent()->parent()-> | |
| 67 packet_start()); | |
| 68 EXPECT_FALSE(opt->parent()->parent()->parent()->parent()->packet_start()); | |
| 69 EXPECT_TRUE(opt->parent()->parent()->parent()->packet_start()); | |
| 70 EXPECT_FALSE(opt->parent()->parent()->packet_start()); | |
| 71 EXPECT_TRUE(opt->parent()->packet_start()); | |
| 72 EXPECT_FALSE(opt->packet_start()); | |
| 73 EXPECT_TRUE(opt == root->left_child()->right_child()->left_child()-> | |
| 74 right_child()->left_child()->right_child()->left_child()); | |
| 75 delete root; | |
| 76 } | |
| 77 | |
| 78 TEST(PartitionTreeNode, FindOptimalConfigSinglePartition) { | |
| 79 const size_t kVector[] = {17}; | |
| 80 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kVector); | |
| 81 const size_t kMaxSize = 1500; | |
| 82 const size_t kPenalty = 1; | |
| 83 PartitionTreeNode* root = | |
| 84 PartitionTreeNode::CreateRootNode(kVector, kNumPartitions); | |
| 85 PartitionTreeNode* opt = root->GetOptimalNode(kMaxSize, kPenalty); | |
| 86 ASSERT_TRUE(opt != NULL); | |
| 87 EXPECT_EQ(1u, opt->NumPackets()); | |
| 88 EXPECT_TRUE(opt == root); | |
| 89 delete root; | |
| 90 } | |
| 91 | |
| 92 static void VerifyConfiguration( | |
| 93 const size_t* expected_config, | |
| 94 size_t expected_config_len, | |
| 95 const Vp8PartitionAggregator::ConfigVec& opt_config, | |
| 96 const RTPFragmentationHeader& fragmentation) { | |
| 97 ASSERT_EQ(expected_config_len, fragmentation.fragmentationVectorSize); | |
| 98 EXPECT_EQ(expected_config_len, opt_config.size()); | |
| 99 for (size_t i = 0; i < expected_config_len; ++i) { | |
| 100 EXPECT_EQ(expected_config[i], opt_config[i]); | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 static void VerifyMinMax(const Vp8PartitionAggregator& aggregator, | |
| 105 const Vp8PartitionAggregator::ConfigVec& opt_config, | |
| 106 int expected_min, | |
| 107 int expected_max) { | |
| 108 int min_size = -1; | |
| 109 int max_size = -1; | |
| 110 aggregator.CalcMinMax(opt_config, &min_size, &max_size); | |
| 111 EXPECT_EQ(expected_min, min_size); | |
| 112 EXPECT_EQ(expected_max, max_size); | |
| 113 } | |
| 114 | |
| 115 TEST(Vp8PartitionAggregator, CreateAndDelete) { | |
| 116 RTPFragmentationHeader fragmentation; | |
| 117 fragmentation.VerifyAndAllocateFragmentationHeader(3); | |
| 118 Vp8PartitionAggregator* aggregator = | |
| 119 new Vp8PartitionAggregator(fragmentation, 0, 2); | |
| 120 delete aggregator; | |
| 121 } | |
| 122 | |
| 123 TEST(Vp8PartitionAggregator, FindOptimalConfig) { | |
| 124 RTPFragmentationHeader fragmentation; | |
| 125 fragmentation.VerifyAndAllocateFragmentationHeader(8); | |
| 126 fragmentation.fragmentationLength[0] = 197; | |
| 127 fragmentation.fragmentationLength[1] = 194; | |
| 128 fragmentation.fragmentationLength[2] = 213; | |
| 129 fragmentation.fragmentationLength[3] = 215; | |
| 130 fragmentation.fragmentationLength[4] = 184; | |
| 131 fragmentation.fragmentationLength[5] = 199; | |
| 132 fragmentation.fragmentationLength[6] = 197; | |
| 133 fragmentation.fragmentationLength[7] = 207; | |
| 134 Vp8PartitionAggregator* aggregator = | |
| 135 new Vp8PartitionAggregator(fragmentation, 0, 7); | |
| 136 aggregator->SetPriorMinMax(300, 500); | |
| 137 size_t kMaxSize = 1500; | |
| 138 size_t kPenalty = 1; | |
| 139 Vp8PartitionAggregator::ConfigVec opt_config = | |
| 140 aggregator->FindOptimalConfiguration(kMaxSize, kPenalty); | |
| 141 const size_t kExpectedConfig[] = {0, 0, 1, 1, 2, 2, 3, 3}; | |
| 142 const size_t kExpectedConfigSize = GTEST_ARRAY_SIZE_(kExpectedConfig); | |
| 143 VerifyConfiguration(kExpectedConfig, kExpectedConfigSize, opt_config, | |
| 144 fragmentation); | |
| 145 VerifyMinMax(*aggregator, opt_config, 383, 428); | |
| 146 // Change min and max and run method again. This time, we expect it to leave | |
| 147 // the values unchanged. | |
| 148 int min_size = 382; | |
| 149 int max_size = 429; | |
| 150 aggregator->CalcMinMax(opt_config, &min_size, &max_size); | |
| 151 EXPECT_EQ(382, min_size); | |
| 152 EXPECT_EQ(429, max_size); | |
| 153 delete aggregator; | |
| 154 } | |
| 155 | |
| 156 TEST(Vp8PartitionAggregator, FindOptimalConfigEqualFragments) { | |
| 157 RTPFragmentationHeader fragmentation; | |
| 158 fragmentation.VerifyAndAllocateFragmentationHeader(8); | |
| 159 fragmentation.fragmentationLength[0] = 200; | |
| 160 fragmentation.fragmentationLength[1] = 200; | |
| 161 fragmentation.fragmentationLength[2] = 200; | |
| 162 fragmentation.fragmentationLength[3] = 200; | |
| 163 fragmentation.fragmentationLength[4] = 200; | |
| 164 fragmentation.fragmentationLength[5] = 200; | |
| 165 fragmentation.fragmentationLength[6] = 200; | |
| 166 fragmentation.fragmentationLength[7] = 200; | |
| 167 Vp8PartitionAggregator* aggregator = | |
| 168 new Vp8PartitionAggregator(fragmentation, 0, 7); | |
| 169 size_t kMaxSize = 1500; | |
| 170 size_t kPenalty = 1; | |
| 171 Vp8PartitionAggregator::ConfigVec opt_config = | |
| 172 aggregator->FindOptimalConfiguration(kMaxSize, kPenalty); | |
| 173 const size_t kExpectedConfig[] = {0, 0, 0, 0, 1, 1, 1, 1}; | |
| 174 const size_t kExpectedConfigSize = GTEST_ARRAY_SIZE_(kExpectedConfig); | |
| 175 VerifyConfiguration(kExpectedConfig, kExpectedConfigSize, opt_config, | |
| 176 fragmentation); | |
| 177 VerifyMinMax(*aggregator, opt_config, 800, 800); | |
| 178 delete aggregator; | |
| 179 } | |
| 180 | |
| 181 TEST(Vp8PartitionAggregator, FindOptimalConfigSinglePartition) { | |
| 182 RTPFragmentationHeader fragmentation; | |
| 183 fragmentation.VerifyAndAllocateFragmentationHeader(1); | |
| 184 fragmentation.fragmentationLength[0] = 17; | |
| 185 Vp8PartitionAggregator* aggregator = | |
| 186 new Vp8PartitionAggregator(fragmentation, 0, 0); | |
| 187 size_t kMaxSize = 1500; | |
| 188 size_t kPenalty = 1; | |
| 189 Vp8PartitionAggregator::ConfigVec opt_config = | |
| 190 aggregator->FindOptimalConfiguration(kMaxSize, kPenalty); | |
| 191 const size_t kExpectedConfig[] = {0}; | |
| 192 const size_t kExpectedConfigSize = GTEST_ARRAY_SIZE_(kExpectedConfig); | |
| 193 VerifyConfiguration(kExpectedConfig, kExpectedConfigSize, opt_config, | |
| 194 fragmentation); | |
| 195 VerifyMinMax(*aggregator, opt_config, 17, 17); | |
| 196 delete aggregator; | |
| 197 } | |
| 198 | |
| 199 TEST(Vp8PartitionAggregator, TestCalcNumberOfFragments) { | |
| 200 const int kMTU = 1500; | |
| 201 EXPECT_EQ(2u, | |
| 202 Vp8PartitionAggregator::CalcNumberOfFragments( | |
| 203 1600, kMTU, 1, 300, 900)); | |
| 204 EXPECT_EQ(3u, | |
| 205 Vp8PartitionAggregator::CalcNumberOfFragments( | |
| 206 1600, kMTU, 1, 300, 798)); | |
| 207 EXPECT_EQ(2u, | |
| 208 Vp8PartitionAggregator::CalcNumberOfFragments( | |
| 209 1600, kMTU, 1, 900, 1000)); | |
| 210 } | |
| 211 | |
| 212 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2871173008:
Fix packetization logic to leave space for extensions in the last packet (Closed)
