OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2013 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 #include <algorithm> // max | 10 #include <algorithm> // max |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
51 const VideoFrame& frame2); | 51 const VideoFrame& frame2); |
52 void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1, | 52 void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1, |
53 const std::vector<VideoFrame>& frames2); | 53 const std::vector<VideoFrame>& frames2); |
54 VideoFrame CreateVideoFrame(int width, int height, uint8_t data); | 54 VideoFrame CreateVideoFrame(int width, int height, uint8_t data); |
55 | 55 |
56 class VideoSendStreamTest : public test::CallTest { | 56 class VideoSendStreamTest : public test::CallTest { |
57 protected: | 57 protected: |
58 void TestNackRetransmission(uint32_t retransmit_ssrc, | 58 void TestNackRetransmission(uint32_t retransmit_ssrc, |
59 uint8_t retransmit_payload_type); | 59 uint8_t retransmit_payload_type); |
60 void TestPacketFragmentationSize(VideoFormat format, bool with_fec); | 60 void TestPacketFragmentationSize(VideoFormat format, bool with_fec); |
| 61 |
| 62 void TestVp9NonFlexMode(uint8_t num_temporal_layers, |
| 63 uint8_t num_spatial_layers); |
61 }; | 64 }; |
62 | 65 |
63 TEST_F(VideoSendStreamTest, CanStartStartedStream) { | 66 TEST_F(VideoSendStreamTest, CanStartStartedStream) { |
64 Call::Config call_config; | 67 Call::Config call_config; |
65 CreateSenderCall(call_config); | 68 CreateSenderCall(call_config); |
66 | 69 |
67 test::NullTransport transport; | 70 test::NullTransport transport; |
68 CreateSendConfig(1, &transport); | 71 CreateSendConfig(1, &transport); |
69 CreateStreams(); | 72 CreateStreams(); |
70 send_stream_->Start(); | 73 send_stream_->Start(); |
(...skipping 1713 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1784 const std::vector<VideoReceiveStream*>& receive_streams) override { | 1787 const std::vector<VideoReceiveStream*>& receive_streams) override { |
1785 send_stream_ = send_stream; | 1788 send_stream_ = send_stream; |
1786 } | 1789 } |
1787 | 1790 |
1788 VideoSendStream* send_stream_; | 1791 VideoSendStream* send_stream_; |
1789 } test; | 1792 } test; |
1790 | 1793 |
1791 RunBaseTest(&test, FakeNetworkPipe::Config()); | 1794 RunBaseTest(&test, FakeNetworkPipe::Config()); |
1792 } | 1795 } |
1793 | 1796 |
1794 class VP9HeaderObeserver : public test::SendTest { | 1797 class Vp9HeaderObserver : public test::SendTest { |
1795 public: | 1798 public: |
1796 VP9HeaderObeserver() | 1799 Vp9HeaderObserver() |
1797 : SendTest(VideoSendStreamTest::kDefaultTimeoutMs), | 1800 : SendTest(VideoSendStreamTest::kDefaultTimeoutMs), |
1798 vp9_encoder_(VP9Encoder::Create()), | 1801 vp9_encoder_(VP9Encoder::Create()), |
1799 vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) { | 1802 vp9_settings_(VideoEncoder::GetDefaultVp9Settings()), |
1800 vp9_settings_.numberOfTemporalLayers = 1; | 1803 packets_sent_(0), |
1801 vp9_settings_.numberOfSpatialLayers = 2; | 1804 frames_sent_(0) {} |
1802 } | |
1803 | 1805 |
1804 virtual void ModifyConfigsHook( | 1806 virtual void ModifyConfigsHook( |
1805 VideoSendStream::Config* send_config, | 1807 VideoSendStream::Config* send_config, |
1806 std::vector<VideoReceiveStream::Config>* receive_configs, | 1808 std::vector<VideoReceiveStream::Config>* receive_configs, |
1807 VideoEncoderConfig* encoder_config) {} | 1809 VideoEncoderConfig* encoder_config) {} |
1808 | 1810 |
1809 virtual void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) = 0; | 1811 virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0; |
1810 | 1812 |
1811 private: | 1813 private: |
1812 const int kVp9PayloadType = 105; | 1814 const int kVp9PayloadType = 105; |
1813 | 1815 |
1814 void ModifyConfigs(VideoSendStream::Config* send_config, | 1816 void ModifyConfigs(VideoSendStream::Config* send_config, |
1815 std::vector<VideoReceiveStream::Config>* receive_configs, | 1817 std::vector<VideoReceiveStream::Config>* receive_configs, |
1816 VideoEncoderConfig* encoder_config) override { | 1818 VideoEncoderConfig* encoder_config) override { |
1817 encoder_config->encoder_specific_settings = &vp9_settings_; | 1819 encoder_config->encoder_specific_settings = &vp9_settings_; |
1818 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; | |
1819 send_config->encoder_settings.encoder = vp9_encoder_.get(); | 1820 send_config->encoder_settings.encoder = vp9_encoder_.get(); |
1820 send_config->encoder_settings.payload_name = "VP9"; | 1821 send_config->encoder_settings.payload_name = "VP9"; |
1821 send_config->encoder_settings.payload_type = kVp9PayloadType; | 1822 send_config->encoder_settings.payload_type = kVp9PayloadType; |
1822 ModifyConfigsHook(send_config, receive_configs, encoder_config); | 1823 ModifyConfigsHook(send_config, receive_configs, encoder_config); |
| 1824 EXPECT_EQ(1u, encoder_config->streams.size()); |
| 1825 encoder_config->streams[0].temporal_layer_thresholds_bps.resize( |
| 1826 vp9_settings_.numberOfTemporalLayers - 1); |
| 1827 encoder_config_ = *encoder_config; |
1823 } | 1828 } |
1824 | 1829 |
1825 void PerformTest() override { | 1830 void PerformTest() override { |
1826 EXPECT_EQ(kEventSignaled, Wait()) | 1831 EXPECT_EQ(kEventSignaled, Wait()) |
1827 << "Test timed out waiting for VP9 packet"; | 1832 << "Test timed out waiting for VP9 packet"; |
1828 } | 1833 } |
1829 | 1834 |
1830 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 1835 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
1831 RTPHeader header; | 1836 RTPHeader header; |
1832 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | 1837 EXPECT_TRUE(parser_->Parse(packet, length, &header)); |
1833 | 1838 |
1834 if (header.payloadType == kVp9PayloadType) { | 1839 EXPECT_EQ(kVp9PayloadType, header.payloadType); |
1835 RtpDepacketizerVp9 vp9depacketizer; | 1840 const uint8_t* payload = packet + header.headerLength; |
1836 RtpDepacketizer::ParsedPayload vp9payload; | 1841 size_t payload_length = length - header.headerLength - header.paddingLength; |
1837 const uint8_t* vp9_packet = packet + header.headerLength; | 1842 |
1838 size_t payload_length = | 1843 bool new_packet = packets_sent_ == 0 || |
1839 length - header.headerLength - header.paddingLength; | 1844 IsNewerSequenceNumber(header.sequenceNumber, |
1840 | 1845 last_header_.sequenceNumber); |
1841 if (payload_length > 0) { | 1846 if (payload_length > 0 && new_packet) { |
1842 bool parse_vp9header_successful = | 1847 RtpDepacketizer::ParsedPayload parsed; |
1843 vp9depacketizer.Parse(&vp9payload, vp9_packet, payload_length); | 1848 RtpDepacketizerVp9 depacketizer; |
1844 bool is_vp9_codec_type = | 1849 EXPECT_TRUE(depacketizer.Parse(&parsed, payload, payload_length)); |
1845 vp9payload.type.Video.codec == RtpVideoCodecTypes::kRtpVideoVp9; | 1850 EXPECT_EQ(RtpVideoCodecTypes::kRtpVideoVp9, parsed.type.Video.codec); |
1846 EXPECT_TRUE(parse_vp9header_successful); | 1851 // Verify common fields for all configurations. |
1847 EXPECT_TRUE(is_vp9_codec_type); | 1852 VerifyCommonHeader(parsed.type.Video.codecHeader.VP9); |
1848 | 1853 CompareConsecutiveFrames(header, parsed.type.Video); |
1849 RTPVideoHeaderVP9* vp9videoHeader = | 1854 // Verify configuration specific settings. |
1850 &vp9payload.type.Video.codecHeader.VP9; | 1855 InspectHeader(parsed.type.Video.codecHeader.VP9); |
1851 if (parse_vp9header_successful && is_vp9_codec_type) { | 1856 |
1852 InspectHeader(vp9videoHeader); | 1857 ++packets_sent_; |
1853 } else { | 1858 if (header.markerBit) { |
1854 observation_complete_->Set(); | 1859 ++frames_sent_; |
1855 } | |
1856 } | 1860 } |
1857 } | 1861 last_header_ = header; |
1858 | 1862 last_vp9_ = parsed.type.Video.codecHeader.VP9; |
| 1863 } |
1859 return SEND_PACKET; | 1864 return SEND_PACKET; |
1860 } | 1865 } |
1861 | 1866 |
1862 protected: | 1867 protected: |
| 1868 bool ContinuousPictureId(const RTPVideoHeaderVP9& vp9) const { |
| 1869 if (last_vp9_.picture_id > vp9.picture_id) { |
| 1870 return vp9.picture_id == 0; // Wrap. |
| 1871 } else { |
| 1872 return vp9.picture_id == last_vp9_.picture_id + 1; |
| 1873 } |
| 1874 } |
| 1875 |
| 1876 void VerifySpatialIdxWithinFrame(const RTPVideoHeaderVP9& vp9) const { |
| 1877 if (frames_sent_ == 0) |
| 1878 return; |
| 1879 |
| 1880 bool new_layer = vp9.spatial_idx != last_vp9_.spatial_idx; |
| 1881 EXPECT_EQ(new_layer, vp9.beginning_of_frame); |
| 1882 EXPECT_EQ(new_layer, last_vp9_.end_of_frame); |
| 1883 EXPECT_EQ(new_layer ? last_vp9_.spatial_idx + 1 : last_vp9_.spatial_idx, |
| 1884 vp9.spatial_idx); |
| 1885 } |
| 1886 |
| 1887 void VerifyFixedTemporalLayerStructure(const RTPVideoHeaderVP9& vp9, |
| 1888 uint8_t num_layers) const { |
| 1889 switch (num_layers) { |
| 1890 case 0: |
| 1891 VerifyTemporalLayerStructure0(vp9); |
| 1892 break; |
| 1893 case 1: |
| 1894 VerifyTemporalLayerStructure1(vp9); |
| 1895 break; |
| 1896 case 2: |
| 1897 VerifyTemporalLayerStructure2(vp9); |
| 1898 break; |
| 1899 case 3: |
| 1900 VerifyTemporalLayerStructure3(vp9); |
| 1901 break; |
| 1902 default: |
| 1903 RTC_NOTREACHED(); |
| 1904 } |
| 1905 } |
| 1906 |
| 1907 void VerifyTemporalLayerStructure0(const RTPVideoHeaderVP9& vp9) const { |
| 1908 EXPECT_EQ(kNoTl0PicIdx, vp9.tl0_pic_idx); |
| 1909 EXPECT_EQ(kNoTemporalIdx, vp9.temporal_idx); // no tid |
| 1910 EXPECT_FALSE(vp9.temporal_up_switch); |
| 1911 } |
| 1912 |
| 1913 void VerifyTemporalLayerStructure1(const RTPVideoHeaderVP9& vp9) const { |
| 1914 EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx); |
| 1915 EXPECT_EQ(0, vp9.temporal_idx); // 0,0,0,... |
| 1916 EXPECT_FALSE(vp9.temporal_up_switch); |
| 1917 } |
| 1918 |
| 1919 void VerifyTemporalLayerStructure2(const RTPVideoHeaderVP9& vp9) const { |
| 1920 EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx); |
| 1921 EXPECT_GE(vp9.temporal_idx, 0); // 0,1,0,1,... (tid reset on I-frames). |
| 1922 EXPECT_LE(vp9.temporal_idx, 1); |
| 1923 EXPECT_EQ(vp9.temporal_idx > 0, vp9.temporal_up_switch); |
| 1924 if (IsNewPictureId(vp9)) { |
| 1925 uint8_t expected_tid = |
| 1926 (!vp9.inter_pic_predicted || last_vp9_.temporal_idx == 1) ? 0 : 1; |
| 1927 EXPECT_EQ(expected_tid, vp9.temporal_idx); |
| 1928 } |
| 1929 } |
| 1930 |
| 1931 void VerifyTemporalLayerStructure3(const RTPVideoHeaderVP9& vp9) const { |
| 1932 EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx); |
| 1933 EXPECT_GE(vp9.temporal_idx, 0); // 0,2,1,2,... (tid reset on I-frames). |
| 1934 EXPECT_LE(vp9.temporal_idx, 2); |
| 1935 if (IsNewPictureId(vp9) && vp9.inter_pic_predicted) { |
| 1936 EXPECT_NE(vp9.temporal_idx, last_vp9_.temporal_idx); |
| 1937 switch (vp9.temporal_idx) { |
| 1938 case 0: |
| 1939 EXPECT_EQ(2, last_vp9_.temporal_idx); |
| 1940 EXPECT_FALSE(vp9.temporal_up_switch); |
| 1941 break; |
| 1942 case 1: |
| 1943 EXPECT_EQ(2, last_vp9_.temporal_idx); |
| 1944 EXPECT_TRUE(vp9.temporal_up_switch); |
| 1945 break; |
| 1946 case 2: |
| 1947 EXPECT_EQ(last_vp9_.temporal_idx == 0, vp9.temporal_up_switch); |
| 1948 break; |
| 1949 } |
| 1950 } |
| 1951 } |
| 1952 |
| 1953 void VerifyTl0Idx(const RTPVideoHeaderVP9& vp9) const { |
| 1954 if (vp9.tl0_pic_idx == kNoTl0PicIdx) |
| 1955 return; |
| 1956 |
| 1957 uint8_t expected_tl0_idx = last_vp9_.tl0_pic_idx; |
| 1958 if (vp9.temporal_idx == 0) |
| 1959 ++expected_tl0_idx; |
| 1960 EXPECT_EQ(expected_tl0_idx, vp9.tl0_pic_idx); |
| 1961 } |
| 1962 |
| 1963 bool IsNewPictureId(const RTPVideoHeaderVP9& vp9) const { |
| 1964 return frames_sent_ > 0 && (vp9.picture_id != last_vp9_.picture_id); |
| 1965 } |
| 1966 |
| 1967 // Flexible mode (F=1): Non-flexible mode (F=0): |
| 1968 // |
| 1969 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ |
| 1970 // |I|P|L|F|B|E|V|-| |I|P|L|F|B|E|V|-| |
| 1971 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ |
| 1972 // I: |M| PICTURE ID | I: |M| PICTURE ID | |
| 1973 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ |
| 1974 // M: | EXTENDED PID | M: | EXTENDED PID | |
| 1975 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ |
| 1976 // L: | T |U| S |D| L: | T |U| S |D| |
| 1977 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ |
| 1978 // P,F: | P_DIFF |X|N| | TL0PICIDX | |
| 1979 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ |
| 1980 // X: |EXTENDED P_DIFF| V: | SS .. | |
| 1981 // +-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+ |
| 1982 // V: | SS .. | |
| 1983 // +-+-+-+-+-+-+-+-+ |
| 1984 void VerifyCommonHeader(const RTPVideoHeaderVP9& vp9) const { |
| 1985 EXPECT_EQ(kMaxTwoBytePictureId, vp9.max_picture_id); // M:1 |
| 1986 EXPECT_NE(kNoPictureId, vp9.picture_id); // I:1 |
| 1987 EXPECT_EQ(vp9_settings_.flexibleMode, vp9.flexible_mode); // F |
| 1988 EXPECT_GE(vp9.spatial_idx, 0); // S |
| 1989 EXPECT_LT(vp9.spatial_idx, vp9_settings_.numberOfSpatialLayers); |
| 1990 if (vp9.ss_data_available) // V |
| 1991 VerifySsData(vp9); |
| 1992 |
| 1993 if (frames_sent_ == 0) |
| 1994 EXPECT_FALSE(vp9.inter_pic_predicted); // P |
| 1995 |
| 1996 if (!vp9.inter_pic_predicted) { |
| 1997 EXPECT_TRUE(vp9.temporal_idx == 0 || vp9.temporal_idx == kNoTemporalIdx); |
| 1998 EXPECT_FALSE(vp9.temporal_up_switch); |
| 1999 } |
| 2000 } |
| 2001 |
| 2002 // Scalability structure (SS). |
| 2003 // |
| 2004 // +-+-+-+-+-+-+-+-+ |
| 2005 // V: | N_S |Y|G|-|-|-| |
| 2006 // +-+-+-+-+-+-+-+-+ |
| 2007 // Y: | WIDTH | N_S + 1 times |
| 2008 // +-+-+-+-+-+-+-+-+ |
| 2009 // | HEIGHT | |
| 2010 // +-+-+-+-+-+-+-+-+ |
| 2011 // G: | N_G | |
| 2012 // +-+-+-+-+-+-+-+-+ |
| 2013 // N_G: | T |U| R |-|-| N_G times |
| 2014 // +-+-+-+-+-+-+-+-+ |
| 2015 // | P_DIFF | R times |
| 2016 // +-+-+-+-+-+-+-+-+ |
| 2017 void VerifySsData(const RTPVideoHeaderVP9& vp9) const { |
| 2018 EXPECT_TRUE(vp9.ss_data_available); // V |
| 2019 EXPECT_EQ(vp9_settings_.numberOfSpatialLayers, // N_S + 1 |
| 2020 vp9.num_spatial_layers); |
| 2021 EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1 |
| 2022 size_t expected_width = encoder_config_.streams[0].width; |
| 2023 size_t expected_height = encoder_config_.streams[0].height; |
| 2024 for (int i = vp9.num_spatial_layers - 1; i >= 0; --i) { |
| 2025 EXPECT_EQ(expected_width, vp9.width[i]); // WIDTH |
| 2026 EXPECT_EQ(expected_height, vp9.height[i]); // HEIGHT |
| 2027 expected_width /= 2; |
| 2028 expected_height /= 2; |
| 2029 } |
| 2030 } |
| 2031 |
| 2032 void CompareConsecutiveFrames(const RTPHeader& header, |
| 2033 const RTPVideoHeader& video) const { |
| 2034 const RTPVideoHeaderVP9& vp9 = video.codecHeader.VP9; |
| 2035 |
| 2036 bool new_frame = packets_sent_ == 0 || |
| 2037 IsNewerTimestamp(header.timestamp, last_header_.timestamp); |
| 2038 EXPECT_EQ(new_frame, video.isFirstPacket); |
| 2039 if (!new_frame) { |
| 2040 EXPECT_FALSE(last_header_.markerBit); |
| 2041 EXPECT_EQ(last_header_.timestamp, header.timestamp); |
| 2042 EXPECT_EQ(last_vp9_.picture_id, vp9.picture_id); |
| 2043 EXPECT_EQ(last_vp9_.temporal_idx, vp9.temporal_idx); |
| 2044 EXPECT_EQ(last_vp9_.tl0_pic_idx, vp9.tl0_pic_idx); |
| 2045 VerifySpatialIdxWithinFrame(vp9); |
| 2046 return; |
| 2047 } |
| 2048 // New frame. |
| 2049 EXPECT_TRUE(vp9.beginning_of_frame); |
| 2050 |
| 2051 // Compare with last packet in previous frame. |
| 2052 if (frames_sent_ == 0) |
| 2053 return; |
| 2054 EXPECT_TRUE(last_vp9_.end_of_frame); |
| 2055 EXPECT_TRUE(last_header_.markerBit); |
| 2056 EXPECT_TRUE(ContinuousPictureId(vp9)); |
| 2057 VerifyTl0Idx(vp9); |
| 2058 } |
| 2059 |
1863 rtc::scoped_ptr<VP9Encoder> vp9_encoder_; | 2060 rtc::scoped_ptr<VP9Encoder> vp9_encoder_; |
1864 VideoCodecVP9 vp9_settings_; | 2061 VideoCodecVP9 vp9_settings_; |
| 2062 webrtc::VideoEncoderConfig encoder_config_; |
| 2063 RTPHeader last_header_; |
| 2064 RTPVideoHeaderVP9 last_vp9_; |
| 2065 size_t packets_sent_; |
| 2066 size_t frames_sent_; |
1865 }; | 2067 }; |
1866 | 2068 |
1867 TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) { | 2069 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) { |
1868 class FlexibleMode : public VP9HeaderObeserver { | 2070 const uint8_t kNumTemporalLayers = 1; |
| 2071 const uint8_t kNumSpatialLayers = 1; |
| 2072 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); |
| 2073 } |
| 2074 |
| 2075 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl1SLayers) { |
| 2076 const uint8_t kNumTemporalLayers = 2; |
| 2077 const uint8_t kNumSpatialLayers = 1; |
| 2078 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); |
| 2079 } |
| 2080 |
| 2081 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_3Tl1SLayers) { |
| 2082 const uint8_t kNumTemporalLayers = 3; |
| 2083 const uint8_t kNumSpatialLayers = 1; |
| 2084 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); |
| 2085 } |
| 2086 |
| 2087 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl2SLayers) { |
| 2088 const uint8_t kNumTemporalLayers = 1; |
| 2089 const uint8_t kNumSpatialLayers = 2; |
| 2090 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); |
| 2091 } |
| 2092 |
| 2093 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl2SLayers) { |
| 2094 const uint8_t kNumTemporalLayers = 2; |
| 2095 const uint8_t kNumSpatialLayers = 2; |
| 2096 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); |
| 2097 } |
| 2098 |
| 2099 TEST_F(VideoSendStreamTest, Vp9NonFlexMode_3Tl2SLayers) { |
| 2100 const uint8_t kNumTemporalLayers = 3; |
| 2101 const uint8_t kNumSpatialLayers = 2; |
| 2102 TestVp9NonFlexMode(kNumTemporalLayers, kNumSpatialLayers); |
| 2103 } |
| 2104 |
| 2105 void VideoSendStreamTest::TestVp9NonFlexMode(uint8_t num_temporal_layers, |
| 2106 uint8_t num_spatial_layers) { |
| 2107 static const size_t kNumFramesToSend = 100; |
| 2108 // Set to < kNumFramesToSend and coprime to length of temporal layer |
| 2109 // structures to verify temporal id reset on key frame. |
| 2110 static const int kKeyFrameInterval = 31; |
| 2111 class NonFlexibleMode : public Vp9HeaderObserver { |
| 2112 public: |
| 2113 NonFlexibleMode(uint8_t num_temporal_layers, uint8_t num_spatial_layers) |
| 2114 : num_temporal_layers_(num_temporal_layers), |
| 2115 num_spatial_layers_(num_spatial_layers), |
| 2116 l_field_(num_temporal_layers > 1 || num_spatial_layers > 1) {} |
1869 void ModifyConfigsHook( | 2117 void ModifyConfigsHook( |
1870 VideoSendStream::Config* send_config, | 2118 VideoSendStream::Config* send_config, |
1871 std::vector<VideoReceiveStream::Config>* receive_configs, | 2119 std::vector<VideoReceiveStream::Config>* receive_configs, |
1872 VideoEncoderConfig* encoder_config) override { | 2120 VideoEncoderConfig* encoder_config) override { |
1873 vp9_settings_.flexibleMode = true; | 2121 vp9_settings_.flexibleMode = false; |
1874 } | 2122 vp9_settings_.frameDroppingOn = false; |
1875 | 2123 vp9_settings_.keyFrameInterval = kKeyFrameInterval; |
1876 void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override { | 2124 vp9_settings_.numberOfTemporalLayers = num_temporal_layers_; |
1877 EXPECT_TRUE(vp9videoHeader->flexible_mode); | 2125 vp9_settings_.numberOfSpatialLayers = num_spatial_layers_; |
1878 observation_complete_->Set(); | 2126 } |
1879 } | 2127 |
1880 } test; | 2128 void InspectHeader(const RTPVideoHeaderVP9& vp9) override { |
| 2129 bool ss_data_expected = !vp9.inter_pic_predicted && |
| 2130 vp9.beginning_of_frame && vp9.spatial_idx == 0; |
| 2131 EXPECT_EQ(ss_data_expected, vp9.ss_data_available); |
| 2132 EXPECT_EQ(vp9.spatial_idx > 0, vp9.inter_layer_predicted); // D |
| 2133 |
| 2134 if (IsNewPictureId(vp9)) { |
| 2135 EXPECT_EQ(0, vp9.spatial_idx); |
| 2136 EXPECT_EQ(num_spatial_layers_ - 1, last_vp9_.spatial_idx); |
| 2137 } |
| 2138 |
| 2139 VerifyFixedTemporalLayerStructure(vp9, |
| 2140 l_field_ ? num_temporal_layers_ : 0); |
| 2141 |
| 2142 if (frames_sent_ > kNumFramesToSend) |
| 2143 observation_complete_->Set(); |
| 2144 } |
| 2145 const uint8_t num_temporal_layers_; |
| 2146 const uint8_t num_spatial_layers_; |
| 2147 const bool l_field_; |
| 2148 } test(num_temporal_layers, num_spatial_layers); |
1881 | 2149 |
1882 RunBaseTest(&test, FakeNetworkPipe::Config()); | 2150 RunBaseTest(&test, FakeNetworkPipe::Config()); |
1883 } | 2151 } |
1884 | 2152 |
1885 TEST_F(VideoSendStreamTest, VP9FlexModeHasPictureId) { | 2153 TEST_F(VideoSendStreamTest, Vp9FlexModeRefCount) { |
1886 class FlexibleMode : public VP9HeaderObeserver { | 2154 class FlexibleMode : public Vp9HeaderObserver { |
1887 void ModifyConfigsHook( | 2155 void ModifyConfigsHook( |
1888 VideoSendStream::Config* send_config, | 2156 VideoSendStream::Config* send_config, |
1889 std::vector<VideoReceiveStream::Config>* receive_configs, | 2157 std::vector<VideoReceiveStream::Config>* receive_configs, |
1890 VideoEncoderConfig* encoder_config) override { | 2158 VideoEncoderConfig* encoder_config) override { |
| 2159 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; |
1891 vp9_settings_.flexibleMode = true; | 2160 vp9_settings_.flexibleMode = true; |
1892 } | 2161 vp9_settings_.numberOfTemporalLayers = 1; |
1893 | 2162 vp9_settings_.numberOfSpatialLayers = 2; |
1894 void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override { | 2163 } |
1895 EXPECT_NE(vp9videoHeader->picture_id, kNoPictureId); | 2164 |
1896 observation_complete_->Set(); | 2165 void InspectHeader(const RTPVideoHeaderVP9& vp9_header) override { |
1897 } | 2166 EXPECT_TRUE(vp9_header.flexible_mode); |
1898 } test; | 2167 EXPECT_EQ(kNoTl0PicIdx, vp9_header.tl0_pic_idx); |
1899 | 2168 if (vp9_header.inter_pic_predicted) { |
1900 RunBaseTest(&test, FakeNetworkPipe::Config()); | 2169 EXPECT_GT(vp9_header.num_ref_pics, 0u); |
1901 } | |
1902 | |
1903 TEST_F(VideoSendStreamTest, VP9FlexModeRefCount) { | |
1904 class FlexibleMode : public VP9HeaderObeserver { | |
1905 void ModifyConfigsHook( | |
1906 VideoSendStream::Config* send_config, | |
1907 std::vector<VideoReceiveStream::Config>* receive_configs, | |
1908 VideoEncoderConfig* encoder_config) override { | |
1909 vp9_settings_.flexibleMode = true; | |
1910 } | |
1911 | |
1912 void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override { | |
1913 EXPECT_TRUE(vp9videoHeader->flexible_mode); | |
1914 if (vp9videoHeader->inter_pic_predicted) { | |
1915 EXPECT_GT(vp9videoHeader->num_ref_pics, 0u); | |
1916 observation_complete_->Set(); | 2170 observation_complete_->Set(); |
1917 } | 2171 } |
1918 } | 2172 } |
1919 } test; | 2173 } test; |
1920 | 2174 |
1921 RunBaseTest(&test, FakeNetworkPipe::Config()); | 2175 RunBaseTest(&test, FakeNetworkPipe::Config()); |
1922 } | |
1923 | |
1924 TEST_F(VideoSendStreamTest, VP9FlexModeRefs) { | |
1925 class FlexibleMode : public VP9HeaderObeserver { | |
1926 void ModifyConfigsHook( | |
1927 VideoSendStream::Config* send_config, | |
1928 std::vector<VideoReceiveStream::Config>* receive_configs, | |
1929 VideoEncoderConfig* encoder_config) override { | |
1930 vp9_settings_.flexibleMode = true; | |
1931 } | |
1932 | |
1933 void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override { | |
1934 EXPECT_TRUE(vp9videoHeader->flexible_mode); | |
1935 if (vp9videoHeader->inter_pic_predicted) { | |
1936 EXPECT_GT(vp9videoHeader->num_ref_pics, 0u); | |
1937 observation_complete_->Set(); | |
1938 } | |
1939 } | |
1940 | |
1941 } test; | |
1942 | |
1943 RunBaseTest(&test, FakeNetworkPipe::Config()); | |
1944 } | 2176 } |
1945 | 2177 |
1946 } // namespace webrtc | 2178 } // namespace webrtc |
OLD | NEW |