Add tests for vp9 (non-flexible mode) using different spatial and temporal configurations.

webrtc/video/video_send_stream_tests.cc

 /*
  *  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 <algorithm>  // max
@@ skipping 1770 matching lines @@
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     VideoSendStream* send_stream_;
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
-class VP9HeaderObeserver : public test::SendTest {
+class Vp9HeaderObserver : public test::SendTest {
  public:
-  VP9HeaderObeserver()
+  Vp9HeaderObserver()
       : SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
         vp9_encoder_(VP9Encoder::Create()),
-        vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {
-    vp9_settings_.numberOfTemporalLayers = 1;
-    vp9_settings_.numberOfSpatialLayers = 2;
-  }
+        vp9_settings_(VideoEncoder::GetDefaultVp9Settings()),
+        packets_sent_(0),
+        frames_sent_(0) {}
 
   virtual void ModifyConfigsHook(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) {}
 
-  virtual void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) = 0;
+  virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0;
 
  private:
   const int kVp9PayloadType = 105;
 
   void ModifyConfigs(VideoSendStream::Config* send_config,
                      std::vector<VideoReceiveStream::Config>* receive_configs,
                      VideoEncoderConfig* encoder_config) override {
     encoder_config->encoder_specific_settings = &vp9_settings_;
-    encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
     send_config->encoder_settings.encoder = vp9_encoder_.get();
     send_config->encoder_settings.payload_name = "VP9";
     send_config->encoder_settings.payload_type = kVp9PayloadType;
     ModifyConfigsHook(send_config, receive_configs, encoder_config);
+    EXPECT_EQ(1u, encoder_config->streams.size());
+    encoder_config->streams[0].temporal_layer_thresholds_bps.resize(
+        vp9_settings_.numberOfTemporalLayers - 1);
+    encoder_config_ = *encoder_config;
   }
 
   void PerformTest() override {
     EXPECT_EQ(kEventSignaled, Wait())
         << "Test timed out waiting for VP9 packet";
   }
 
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
-    if (header.payloadType == kVp9PayloadType) {
-      RtpDepacketizerVp9 vp9depacketizer;
-      RtpDepacketizer::ParsedPayload vp9payload;
-      const uint8_t* vp9_packet = packet + header.headerLength;
-      size_t payload_length =
-          length - header.headerLength - header.paddingLength;
-
-      if (payload_length > 0) {
-        bool parse_vp9header_successful =
-            vp9depacketizer.Parse(&vp9payload, vp9_packet, payload_length);
-        bool is_vp9_codec_type =
-            vp9payload.type.Video.codec == RtpVideoCodecTypes::kRtpVideoVp9;
-        EXPECT_TRUE(parse_vp9header_successful);
-        EXPECT_TRUE(is_vp9_codec_type);
-
-        RTPVideoHeaderVP9* vp9videoHeader =
-            &vp9payload.type.Video.codecHeader.VP9;
-        if (parse_vp9header_successful && is_vp9_codec_type) {
-          InspectHeader(vp9videoHeader);
-        } else {
-          observation_complete_->Set();
-        }
+    EXPECT_EQ(kVp9PayloadType, header.payloadType);
+    const uint8_t* payload = packet + header.headerLength;
+    size_t payload_length = length - header.headerLength - header.paddingLength;
+
+    bool new_packet = packets_sent_ == 0 ||
+                      IsNewerSequenceNumber(header.sequenceNumber,
+                                            last_header_.sequenceNumber);
+    if (payload_length > 0 && new_packet) {
+      RtpDepacketizer::ParsedPayload parsed;
+      RtpDepacketizerVp9 depacketizer;
+      EXPECT_TRUE(depacketizer.Parse(&parsed, payload, payload_length));
+      EXPECT_EQ(RtpVideoCodecTypes::kRtpVideoVp9, parsed.type.Video.codec);
+
+      VerifyHeader(parsed.type.Video.codecHeader.VP9);
+      CompareConsecutiveFrames(header, parsed.type.Video.codecHeader.VP9);
+      InspectHeader(parsed.type.Video.codecHeader.VP9);
+
+      ++packets_sent_;
+      if (header.markerBit) {
+        ++frames_sent_;
       }
-    }
-
+      last_header_ = header;
+      last_vp9_ = parsed.type.Video.codecHeader.VP9;
+    }
     return SEND_PACKET;
   }
 
  protected:
+  bool ContinuousPictureId(const RTPVideoHeaderVP9& vp9) const {
+    if (last_vp9_.picture_id > vp9.picture_id) {
+      return vp9.picture_id == 0;  // Wrap.
+    } else {
+      return vp9.picture_id == last_vp9_.picture_id + 1;
+    }
+  }
+
+  void VerifyTl0idx(const RTPVideoHeaderVP9& vp9) const {
+    if (vp9.tl0_pic_idx == kNoTl0PicIdx)
+      return;
+
+    uint8_t expected_tl0_idx = last_vp9_.tl0_pic_idx;
+    if (vp9.temporal_idx == 0)
+      ++expected_tl0_idx;
+    EXPECT_EQ(expected_tl0_idx, vp9.tl0_pic_idx);
+  }
+
+  bool IsNewPictureId(const RTPVideoHeaderVP9& vp9) const {
+    return frames_sent_ > 0 && (vp9.picture_id != last_vp9_.picture_id);
+  }
+
+  bool IsFirstPacketInKeyFrame(const RTPVideoHeaderVP9& vp9) const {
+    return !vp9.inter_pic_predicted &&  // P
+           vp9.beginning_of_frame &&    // B
+           vp9.spatial_idx == 0;
+  }
+
+  // Flexible mode (F=1):    Non-flexible mode (F=0):
+  //
+  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
+  //      |I|P|L|F|B|E|V|-|     |I|P|L|F|B|E|V|-|
+  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
+  // I:   |M| PICTURE ID  |  I: |M| PICTURE ID  |
+  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
+  // M:   | EXTENDED PID  |  M: | EXTENDED PID  |
+  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
+  // L:   |  T  |U|  S  |D|  L: |  T  |U|  S  |D|
+  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
+  // P,F: | P_DIFF    |X|N|     |   TL0PICIDX   |
+  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
+  // X:   |EXTENDED P_DIFF|  V: | SS  ..        |
+  //      +-+-+-+-+-+-+-+-+     +-+-+-+-+-+-+-+-+
+  // V:   | SS  ..        |
+  //      +-+-+-+-+-+-+-+-+
+  void VerifyHeader(const RTPVideoHeaderVP9& vp9) const {
+    EXPECT_EQ(vp9_settings_.flexibleMode, vp9.flexible_mode);   // F
+    EXPECT_EQ(kMaxTwoBytePictureId, vp9.max_picture_id);        // M:1
+    EXPECT_NE(kNoPictureId, vp9.picture_id);                    // I:1
+    EXPECT_GE(vp9.spatial_idx, 0);                              // S
+    EXPECT_LE(vp9.spatial_idx, vp9_settings_.numberOfSpatialLayers - 1);
+    EXPECT_EQ(vp9.spatial_idx > 0, vp9.inter_layer_predicted);  // D
+    if (vp9.ss_data_available)                                  // V
+      VerifySsData(vp9);
+    if (packets_sent_ == 0)
+      EXPECT_TRUE(IsFirstPacketInKeyFrame(vp9));
+    if (frames_sent_ == 0)
+      EXPECT_FALSE(vp9.inter_pic_predicted);  // P (0:key, 1:delta)
+  }
+
+  // Scalability structure (SS).
+  //
+  //      +-+-+-+-+-+-+-+-+
+  // V:   | N_S |Y|G|-|-|-|
+  //      +-+-+-+-+-+-+-+-+
+  // Y:   |    WIDTH      |  N_S + 1 times
+  //      +-+-+-+-+-+-+-+-+
+  //      |    HEIGHT     |
+  //      +-+-+-+-+-+-+-+-+
+  // G:   |      N_G      |
+  //      +-+-+-+-+-+-+-+-+
+  // N_G: |  T  |U| R |-|-|  N_G times
+  //      +-+-+-+-+-+-+-+-+
+  //      |    P_DIFF     |  R times
+  //      +-+-+-+-+-+-+-+-+
+  void VerifySsData(const RTPVideoHeaderVP9& vp9) const {
+    EXPECT_TRUE(vp9.ss_data_available);             // V
+    EXPECT_EQ(vp9_settings_.numberOfSpatialLayers,  // N_S + 1
+              vp9.num_spatial_layers);
+    EXPECT_TRUE(vp9.spatial_layer_resolution_present);  // Y:1
+    size_t expected_width = encoder_config_.streams[0].width;
+    size_t expected_height = encoder_config_.streams[0].height;
+    for (int i = vp9.num_spatial_layers - 1; i >= 0; --i) {
+      EXPECT_EQ(expected_width, vp9.width[i]);    // WIDTH
+      EXPECT_EQ(expected_height, vp9.height[i]);  // HEIGHT
+      expected_width /= 2;
+      expected_height /= 2;
+    }
+  }
+
+  void CompareConsecutiveFrames(const RTPHeader& header,
+                                const RTPVideoHeaderVP9& vp9) const {
+    bool new_frame = packets_sent_ == 0 ||
+                     IsNewerTimestamp(header.timestamp, last_header_.timestamp);
+    if (!new_frame) {
+      EXPECT_EQ(last_header_.timestamp, header.timestamp);
+      EXPECT_EQ(last_vp9_.picture_id, vp9.picture_id);
+      EXPECT_EQ(last_vp9_.tl0_pic_idx, vp9.tl0_pic_idx);
+      return;
+    }
+    // New frame.
+    EXPECT_TRUE(vp9.beginning_of_frame);
+
+    // Compare with last packet in previous frame.
+    if (frames_sent_ == 0)
+      return;
+    EXPECT_TRUE(last_vp9_.end_of_frame);
+    EXPECT_TRUE(last_header_.markerBit);
+    EXPECT_TRUE(ContinuousPictureId(vp9));
+    VerifyTl0idx(vp9);
+  }
+
   rtc::scoped_ptr<VP9Encoder> vp9_encoder_;
   VideoCodecVP9 vp9_settings_;
+  webrtc::VideoEncoderConfig encoder_config_;
+  RTPHeader last_header_;
+  RTPVideoHeaderVP9 last_vp9_;
+  size_t packets_sent_;
+  size_t frames_sent_;
 };
 
-TEST_F(VideoSendStreamTest, DISABLED_VP9FlexMode) {
-  class FlexibleMode : public VP9HeaderObeserver {
-    void ModifyConfigsHook(
-        VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
-        VideoEncoderConfig* encoder_config) override {
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) {

[pbos-webrtc, 2015/11/10 18:21:19]

This (and below) looks like something that can be parameterized?

[åsapersson, 2015/11/16 15:54:00]

Changed how this is setup, ptal.

+  static const size_t kNumFramesToSend = 100;
+  static const size_t kNumExpectedFramesInGof = 1;
+  class NonFlexibleMode : public Vp9HeaderObserver {
+    void ModifyConfigsHook(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      vp9_settings_.frameDroppingOn = false;
+      vp9_settings_.flexibleMode = false;
+      vp9_settings_.numberOfTemporalLayers = 1;
+      vp9_settings_.numberOfSpatialLayers = 1;
+    }
+
+    void InspectHeader(const RTPVideoHeaderVP9& vp9) override {
+      EXPECT_EQ(kNoTl0PicIdx, vp9.tl0_pic_idx);
+      EXPECT_EQ(0, vp9.spatial_idx);
+      EXPECT_EQ(IsFirstPacketInKeyFrame(vp9), vp9.ss_data_available);
+
+      if (vp9.ss_data_available)
+        EXPECT_EQ(kNumExpectedFramesInGof, vp9.gof.num_frames_in_gof);
+
+      if (frames_sent_ > kNumFramesToSend)
+        observation_complete_->Set();
+    }
+  } test;
+
+  RunBaseTest(&test, FakeNetworkPipe::Config());
+}
+
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl1SLayers) {
+  static const size_t kNumFramesToSend = 100;
+  static const size_t kNumExpectedFramesInGof = 2;
+  class NonFlexibleMode : public Vp9HeaderObserver {
+    void ModifyConfigsHook(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      vp9_settings_.frameDroppingOn = false;
+      vp9_settings_.flexibleMode = false;
+      vp9_settings_.numberOfTemporalLayers = 2;
+      vp9_settings_.numberOfSpatialLayers = 1;
+    }
+
+    void InspectHeader(const RTPVideoHeaderVP9& vp9) override {
+      EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx);
+      EXPECT_GE(vp9.temporal_idx, 0);
+      EXPECT_LE(vp9.temporal_idx, 1);
+      EXPECT_EQ(0, vp9.spatial_idx);
+      EXPECT_EQ(IsFirstPacketInKeyFrame(vp9), vp9.ss_data_available);
+
+      if (vp9.ss_data_available)
+        EXPECT_EQ(kNumExpectedFramesInGof, vp9.gof.num_frames_in_gof);
+
+      if (frames_sent_ > kNumFramesToSend)
+        observation_complete_->Set();
+    }
+  } test;
+
+  RunBaseTest(&test, FakeNetworkPipe::Config());
+}
+
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_3Tl1SLayers) {
+  static const size_t kNumFramesToSend = 100;
+  static const size_t kNumExpectedFramesInGof = 4;
+  class NonFlexibleMode : public Vp9HeaderObserver {
+    void ModifyConfigsHook(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      vp9_settings_.frameDroppingOn = false;
+      vp9_settings_.flexibleMode = false;
+      vp9_settings_.numberOfTemporalLayers = 3;
+      vp9_settings_.numberOfSpatialLayers = 1;
+    }
+
+    void InspectHeader(const RTPVideoHeaderVP9& vp9) override {
+      EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx);
+      EXPECT_GE(vp9.temporal_idx, 0);
+      EXPECT_LE(vp9.temporal_idx, 2);
+      EXPECT_EQ(0, vp9.spatial_idx);
+      EXPECT_EQ(IsFirstPacketInKeyFrame(vp9), vp9.ss_data_available);
+
+      if (vp9.ss_data_available)
+        EXPECT_EQ(kNumExpectedFramesInGof, vp9.gof.num_frames_in_gof);
+
+      if (frames_sent_ > kNumFramesToSend)
+        observation_complete_->Set();
+    }
+  } test;
+
+  RunBaseTest(&test, FakeNetworkPipe::Config());
+}
+
+
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl2SLayers) {
+  static const size_t kNumFramesToSend = 100;
+  class NonFlexibleMode : public Vp9HeaderObserver {
+    void ModifyConfigsHook(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      vp9_settings_.frameDroppingOn = false;
+      vp9_settings_.flexibleMode = false;
+      vp9_settings_.numberOfTemporalLayers = 1;
+      vp9_settings_.numberOfSpatialLayers = 2;
+    }
+
+    void InspectHeader(const RTPVideoHeaderVP9& vp9) override {
+      EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx);
+      EXPECT_EQ(0, vp9.temporal_idx);
+      EXPECT_EQ(IsFirstPacketInKeyFrame(vp9), vp9.ss_data_available);
+
+      if (IsNewPictureId(vp9)) {
+        EXPECT_EQ(0, vp9.spatial_idx);
+        EXPECT_EQ(1, last_vp9_.spatial_idx);
+      }
+      if (frames_sent_ > kNumFramesToSend)
+        observation_complete_->Set();
+    }
+  } test;
+
+  RunBaseTest(&test, FakeNetworkPipe::Config());
+}
+
+TEST_F(VideoSendStreamTest, Vp9NonFlexMode_2Tl2SLayers) {
+  static const size_t kNumFramesToSend = 100;
+  class NonFlexibleMode : public Vp9HeaderObserver {
+    void ModifyConfigsHook(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      vp9_settings_.frameDroppingOn = false;
+      vp9_settings_.flexibleMode = false;
+      vp9_settings_.numberOfTemporalLayers = 2;
+      vp9_settings_.numberOfSpatialLayers = 2;
+      vp9_settings_.keyFrameInterval = 50;
+    }
+
+    void InspectHeader(const RTPVideoHeaderVP9& vp9) override {
+      EXPECT_NE(kNoTl0PicIdx, vp9.tl0_pic_idx);
+      EXPECT_GE(vp9.temporal_idx, 0);
+      EXPECT_LE(vp9.temporal_idx, 1);
+      EXPECT_EQ(IsFirstPacketInKeyFrame(vp9), vp9.ss_data_available);
+
+      if (IsNewPictureId(vp9)) {
+        EXPECT_EQ(0, vp9.spatial_idx);
+        EXPECT_EQ(1, last_vp9_.spatial_idx);
+      }
+      if (frames_sent_ > kNumFramesToSend)
+        observation_complete_->Set();
+    }
+  } test;
+
+  RunBaseTest(&test, FakeNetworkPipe::Config());
+}
+
+TEST_F(VideoSendStreamTest, Vp9FlexModeRefCount) {
+  class FlexibleMode : public Vp9HeaderObserver {
+    void ModifyConfigsHook(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
       vp9_settings_.flexibleMode = true;
-    }
-
-    void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
-      EXPECT_TRUE(vp9videoHeader->flexible_mode);
-      observation_complete_->Set();
-    }
-  } test;
-
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(VideoSendStreamTest, VP9FlexModeHasPictureId) {
-  class FlexibleMode : public VP9HeaderObeserver {
-    void ModifyConfigsHook(
-        VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
-        VideoEncoderConfig* encoder_config) override {
-      vp9_settings_.flexibleMode = true;
-    }
-
-    void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
-      EXPECT_NE(vp9videoHeader->picture_id, kNoPictureId);
-      observation_complete_->Set();
-    }
-  } test;
-
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(VideoSendStreamTest, VP9FlexModeRefCount) {
-  class FlexibleMode : public VP9HeaderObeserver {
-    void ModifyConfigsHook(
-        VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
-        VideoEncoderConfig* encoder_config) override {
-      vp9_settings_.flexibleMode = true;
-    }
-
-    void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
-      EXPECT_TRUE(vp9videoHeader->flexible_mode);
-      if (vp9videoHeader->inter_pic_predicted) {
-        EXPECT_GT(vp9videoHeader->num_ref_pics, 0u);
+      vp9_settings_.numberOfTemporalLayers = 1;
+      vp9_settings_.numberOfSpatialLayers = 2;
+    }
+
+    void InspectHeader(const RTPVideoHeaderVP9& vp9_header) override {
+      EXPECT_TRUE(vp9_header.flexible_mode);
+      EXPECT_EQ(kNoTl0PicIdx, vp9_header.tl0_pic_idx);
+      if (vp9_header.inter_pic_predicted) {
+        EXPECT_GT(vp9_header.num_ref_pics, 0u);
         observation_complete_->Set();
       }
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(VideoSendStreamTest, VP9FlexModeRefs) {
-  class FlexibleMode : public VP9HeaderObeserver {
-    void ModifyConfigsHook(
-        VideoSendStream::Config* send_config,
-        std::vector<VideoReceiveStream::Config>* receive_configs,
-        VideoEncoderConfig* encoder_config) override {
-      vp9_settings_.flexibleMode = true;
-    }
-
-    void InspectHeader(RTPVideoHeaderVP9* vp9videoHeader) override {
-      EXPECT_TRUE(vp9videoHeader->flexible_mode);
-      if (vp9videoHeader->inter_pic_predicted) {
-        EXPECT_GT(vp9videoHeader->num_ref_pics, 0u);
-        observation_complete_->Set();
-      }
-    }
-
-  } test;
-
-  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 }  // namespace webrtc