OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <memory> | 11 #include <memory> |
12 #include <vector> | 12 #include <vector> |
13 | 13 |
14 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h" | 14 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h" |
| 15 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" |
15 #include "webrtc/test/gmock.h" | 16 #include "webrtc/test/gmock.h" |
16 #include "webrtc/test/gtest.h" | 17 #include "webrtc/test/gtest.h" |
17 #include "webrtc/typedefs.h" | 18 #include "webrtc/typedefs.h" |
18 | 19 |
19 namespace webrtc { | 20 namespace webrtc { |
20 namespace { | 21 namespace { |
21 void VerifyHeader(const RTPVideoHeaderVP9& expected, | 22 void VerifyHeader(const RTPVideoHeaderVP9& expected, |
22 const RTPVideoHeaderVP9& actual) { | 23 const RTPVideoHeaderVP9& actual) { |
23 EXPECT_EQ(expected.inter_layer_predicted, actual.inter_layer_predicted); | 24 EXPECT_EQ(expected.inter_layer_predicted, actual.inter_layer_predicted); |
24 EXPECT_EQ(expected.inter_pic_predicted, actual.inter_pic_predicted); | 25 EXPECT_EQ(expected.inter_pic_predicted, actual.inter_pic_predicted); |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
116 // L: | T |U| S |D| (CONDITIONALLY RECOMMENDED) | 117 // L: | T |U| S |D| (CONDITIONALLY RECOMMENDED) |
117 // +-+-+-+-+-+-+-+-+ | 118 // +-+-+-+-+-+-+-+-+ |
118 // | TL0PICIDX | (CONDITIONALLY REQUIRED) | 119 // | TL0PICIDX | (CONDITIONALLY REQUIRED) |
119 // +-+-+-+-+-+-+-+-+ | 120 // +-+-+-+-+-+-+-+-+ |
120 // V: | SS | | 121 // V: | SS | |
121 // | .. | | 122 // | .. | |
122 // +-+-+-+-+-+-+-+-+ | 123 // +-+-+-+-+-+-+-+-+ |
123 | 124 |
124 class RtpPacketizerVp9Test : public ::testing::Test { | 125 class RtpPacketizerVp9Test : public ::testing::Test { |
125 protected: | 126 protected: |
126 RtpPacketizerVp9Test() {} | 127 static constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr; |
| 128 static constexpr size_t kMaxPacketSize = 1200; |
| 129 |
| 130 RtpPacketizerVp9Test() : packet_(kNoExtensions, kMaxPacketSize) {} |
127 virtual void SetUp() { | 131 virtual void SetUp() { |
128 expected_.InitRTPVideoHeaderVP9(); | 132 expected_.InitRTPVideoHeaderVP9(); |
129 } | 133 } |
130 | 134 |
131 std::unique_ptr<uint8_t[]> packet_; | 135 RtpPacketToSend packet_; |
132 std::unique_ptr<uint8_t[]> payload_; | 136 std::unique_ptr<uint8_t[]> payload_; |
133 size_t payload_size_; | 137 size_t payload_size_; |
134 size_t payload_pos_; | 138 size_t payload_pos_; |
135 RTPVideoHeaderVP9 expected_; | 139 RTPVideoHeaderVP9 expected_; |
136 std::unique_ptr<RtpPacketizerVp9> packetizer_; | 140 std::unique_ptr<RtpPacketizerVp9> packetizer_; |
137 | 141 |
138 void Init(size_t payload_size, size_t packet_size) { | 142 void Init(size_t payload_size, size_t packet_size) { |
139 payload_.reset(new uint8_t[payload_size]); | 143 payload_.reset(new uint8_t[payload_size]); |
140 memset(payload_.get(), 7, payload_size); | 144 memset(payload_.get(), 7, payload_size); |
141 payload_size_ = payload_size; | 145 payload_size_ = payload_size; |
142 payload_pos_ = 0; | 146 payload_pos_ = 0; |
143 packetizer_.reset(new RtpPacketizerVp9(expected_, packet_size)); | 147 packetizer_.reset(new RtpPacketizerVp9(expected_, packet_size)); |
144 packetizer_->SetPayloadData(payload_.get(), payload_size_, NULL); | 148 packetizer_->SetPayloadData(payload_.get(), payload_size_, NULL); |
145 | |
146 const int kMaxPayloadDescriptorLength = 100; | |
147 packet_.reset(new uint8_t[payload_size_ + kMaxPayloadDescriptorLength]); | |
148 } | 149 } |
149 | 150 |
150 void CheckPayload(const uint8_t* packet, | 151 void CheckPayload(const uint8_t* packet, |
151 size_t start_pos, | 152 size_t start_pos, |
152 size_t end_pos, | 153 size_t end_pos, |
153 bool last) { | 154 bool last) { |
154 for (size_t i = start_pos; i < end_pos; ++i) { | 155 for (size_t i = start_pos; i < end_pos; ++i) { |
155 EXPECT_EQ(packet[i], payload_[payload_pos_++]); | 156 EXPECT_EQ(packet[i], payload_[payload_pos_++]); |
156 } | 157 } |
157 EXPECT_EQ(last, payload_pos_ == payload_size_); | 158 EXPECT_EQ(last, payload_pos_ == payload_size_); |
158 } | 159 } |
159 | 160 |
160 void CreateParseAndCheckPackets(const size_t* expected_hdr_sizes, | 161 void CreateParseAndCheckPackets(const size_t* expected_hdr_sizes, |
161 const size_t* expected_sizes, | 162 const size_t* expected_sizes, |
162 size_t expected_num_packets) { | 163 size_t expected_num_packets) { |
163 ASSERT_TRUE(packetizer_.get() != NULL); | 164 ASSERT_TRUE(packetizer_.get() != NULL); |
164 size_t length = 0; | |
165 bool last = false; | 165 bool last = false; |
166 if (expected_num_packets == 0) { | 166 if (expected_num_packets == 0) { |
167 EXPECT_FALSE(packetizer_->NextPacket(packet_.get(), &length, &last)); | 167 EXPECT_FALSE(packetizer_->NextPacket(&packet_, &last)); |
168 return; | 168 return; |
169 } | 169 } |
170 for (size_t i = 0; i < expected_num_packets; ++i) { | 170 for (size_t i = 0; i < expected_num_packets; ++i) { |
171 EXPECT_TRUE(packetizer_->NextPacket(packet_.get(), &length, &last)); | 171 EXPECT_TRUE(packetizer_->NextPacket(&packet_, &last)); |
172 EXPECT_EQ(expected_sizes[i], length); | 172 auto rtp_payload = packet_.payload(); |
| 173 EXPECT_EQ(expected_sizes[i], rtp_payload.size()); |
173 RTPVideoHeaderVP9 hdr = expected_; | 174 RTPVideoHeaderVP9 hdr = expected_; |
174 hdr.beginning_of_frame = (i == 0); | 175 hdr.beginning_of_frame = (i == 0); |
175 hdr.end_of_frame = last; | 176 hdr.end_of_frame = last; |
176 ParseAndCheckPacket(packet_.get(), hdr, expected_hdr_sizes[i], length); | 177 ParseAndCheckPacket(rtp_payload.data(), hdr, expected_hdr_sizes[i], |
177 CheckPayload(packet_.get(), expected_hdr_sizes[i], length, last); | 178 rtp_payload.size()); |
| 179 CheckPayload(rtp_payload.data(), expected_hdr_sizes[i], |
| 180 rtp_payload.size(), last); |
178 } | 181 } |
179 EXPECT_TRUE(last); | 182 EXPECT_TRUE(last); |
180 } | 183 } |
181 }; | 184 }; |
182 | 185 |
183 TEST_F(RtpPacketizerVp9Test, TestEqualSizedMode_OnePacket) { | 186 TEST_F(RtpPacketizerVp9Test, TestEqualSizedMode_OnePacket) { |
184 const size_t kFrameSize = 25; | 187 const size_t kFrameSize = 25; |
185 const size_t kPacketSize = 26; | 188 const size_t kPacketSize = 26; |
186 Init(kFrameSize, kPacketSize); | 189 Init(kFrameSize, kPacketSize); |
187 | 190 |
(...skipping 234 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
422 // N_G:3 | 425 // N_G:3 |
423 // T:0, U:1, R:0 | 426 // T:0, U:1, R:0 |
424 // T:1, U:1, R:3 | P_DIFF[1][0]:5 | P_DIFF[1][1]:6 | P_DIFF[1][2]:7 | 427 // T:1, U:1, R:3 | P_DIFF[1][0]:5 | P_DIFF[1][1]:6 | P_DIFF[1][2]:7 |
425 // T:2, U:0, R:2 | P_DIFF[2][0]:8 | P_DIFF[2][0]:9 | 428 // T:2, U:0, R:2 | P_DIFF[2][0]:8 | P_DIFF[2][0]:9 |
426 const size_t kExpectedHdrSizes[] = {19}; | 429 const size_t kExpectedHdrSizes[] = {19}; |
427 const size_t kExpectedSizes[] = {40}; | 430 const size_t kExpectedSizes[] = {40}; |
428 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 431 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
429 CreateParseAndCheckPackets(kExpectedHdrSizes, kExpectedSizes, kExpectedNum); | 432 CreateParseAndCheckPackets(kExpectedHdrSizes, kExpectedSizes, kExpectedNum); |
430 } | 433 } |
431 | 434 |
| 435 TEST_F(RtpPacketizerVp9Test, TestOnlyHighestSpatialLayerSetMarker) { |
| 436 const size_t kFrameSize = 10; |
| 437 const size_t kPacketSize = 9; // 2 packet per frame. |
| 438 const uint8_t kFrame[kFrameSize] = {7}; |
| 439 const RTPFragmentationHeader* kNoFragmentation = nullptr; |
| 440 |
| 441 RTPVideoHeaderVP9 vp9_header; |
| 442 vp9_header.InitRTPVideoHeaderVP9(); |
| 443 vp9_header.flexible_mode = true; |
| 444 vp9_header.num_spatial_layers = 3; |
| 445 |
| 446 RtpPacketToSend packet(kNoExtensions); |
| 447 bool last; |
| 448 |
| 449 vp9_header.spatial_idx = 0; |
| 450 RtpPacketizerVp9 packetizer0(vp9_header, kPacketSize); |
| 451 packetizer0.SetPayloadData(kFrame, sizeof(kFrame), kNoFragmentation); |
| 452 ASSERT_TRUE(packetizer0.NextPacket(&packet, &last)); |
| 453 EXPECT_FALSE(last); |
| 454 EXPECT_FALSE(packet.Marker()); |
| 455 ASSERT_TRUE(packetizer0.NextPacket(&packet, &last)); |
| 456 EXPECT_TRUE(last); |
| 457 EXPECT_FALSE(packet.Marker()); |
| 458 |
| 459 vp9_header.spatial_idx = 1; |
| 460 RtpPacketizerVp9 packetizer1(vp9_header, kPacketSize); |
| 461 packetizer1.SetPayloadData(kFrame, sizeof(kFrame), kNoFragmentation); |
| 462 ASSERT_TRUE(packetizer1.NextPacket(&packet, &last)); |
| 463 EXPECT_FALSE(last); |
| 464 EXPECT_FALSE(packet.Marker()); |
| 465 ASSERT_TRUE(packetizer1.NextPacket(&packet, &last)); |
| 466 EXPECT_TRUE(last); |
| 467 EXPECT_FALSE(packet.Marker()); |
| 468 |
| 469 vp9_header.spatial_idx = 2; |
| 470 RtpPacketizerVp9 packetizer2(vp9_header, kPacketSize); |
| 471 packetizer2.SetPayloadData(kFrame, sizeof(kFrame), kNoFragmentation); |
| 472 ASSERT_TRUE(packetizer2.NextPacket(&packet, &last)); |
| 473 EXPECT_FALSE(last); |
| 474 EXPECT_FALSE(packet.Marker()); |
| 475 ASSERT_TRUE(packetizer2.NextPacket(&packet, &last)); |
| 476 EXPECT_TRUE(last); |
| 477 EXPECT_TRUE(packet.Marker()); |
| 478 } |
| 479 |
432 TEST_F(RtpPacketizerVp9Test, TestBaseLayerProtectionAndStorageType) { | 480 TEST_F(RtpPacketizerVp9Test, TestBaseLayerProtectionAndStorageType) { |
433 const size_t kFrameSize = 10; | 481 const size_t kFrameSize = 10; |
434 const size_t kPacketSize = 12; | 482 const size_t kPacketSize = 12; |
435 | 483 |
436 // I:0, P:0, L:1, F:1, B:1, E:1, V:0 (2hdr + 10 payload) | 484 // I:0, P:0, L:1, F:1, B:1, E:1, V:0 (2hdr + 10 payload) |
437 // L: T:0, U:0, S:0, D:0 | 485 // L: T:0, U:0, S:0, D:0 |
438 expected_.flexible_mode = true; | 486 expected_.flexible_mode = true; |
439 expected_.temporal_idx = 0; | 487 expected_.temporal_idx = 0; |
440 Init(kFrameSize, kPacketSize); | 488 Init(kFrameSize, kPacketSize); |
441 EXPECT_EQ(kProtectedPacket, packetizer_->GetProtectionType()); | 489 EXPECT_EQ(kProtectedPacket, packetizer_->GetProtectionType()); |
(...skipping 240 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
682 } | 730 } |
683 | 731 |
684 TEST_F(RtpDepacketizerVp9Test, ParseFailsForTooShortBufferToFitPayload) { | 732 TEST_F(RtpDepacketizerVp9Test, ParseFailsForTooShortBufferToFitPayload) { |
685 const uint8_t kHeaderLength = 1; | 733 const uint8_t kHeaderLength = 1; |
686 uint8_t packet[kHeaderLength] = {0}; | 734 uint8_t packet[kHeaderLength] = {0}; |
687 RtpDepacketizer::ParsedPayload parsed; | 735 RtpDepacketizer::ParsedPayload parsed; |
688 EXPECT_FALSE(depacketizer_->Parse(&parsed, packet, sizeof(packet))); | 736 EXPECT_FALSE(depacketizer_->Parse(&parsed, packet, sizeof(packet))); |
689 } | 737 } |
690 | 738 |
691 } // namespace webrtc | 739 } // namespace webrtc |
OLD | NEW |