[PCLF] Prepare to add extra scaling step before passing frame to analyzer and video sinks

Bug: b/240540204
Change-Id: Ic9774ea07316e59e842d1f4e8362c06ec9c3bf87
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/278623
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38348}

test/pc/e2e/BUILD.gn

@@ -42,6 +42,7 @@ if (!build_with_chromium) {
         ":names_collection_test",
         ":peer_connection_e2e_smoke_test",
         ":peer_connection_quality_test_metric_names_test",
+        ":simulcast_dummy_buffer_helper_test",
         ":single_process_encoded_image_data_injector_unittest",
         ":stats_poller_test",
         ":video_dumping_test",
@@ -127,6 +128,17 @@ if (!build_with_chromium) {
     deps = [ "../../../api/video:video_frame" ]
   }
 
+  rtc_library("simulcast_dummy_buffer_helper_test") {
+    testonly = true
+    sources = [ "analyzer/video/simulcast_dummy_buffer_helper_test.cc" ]
+    deps = [
+      ":simulcast_dummy_buffer_helper",
+      "../..:test_support",
+      "../../../api/video:video_frame",
+      "../../../rtc_base:random",
+    ]
+  }
+
   rtc_library("quality_analyzing_video_decoder") {
     visibility = [ "*" ]
     testonly = true

test/pc/e2e/analyzer/video/simulcast_dummy_buffer_helper.cc

@@ -10,7 +10,9 @@
 
 #include "test/pc/e2e/analyzer/video/simulcast_dummy_buffer_helper.h"
 
-#include <cstring>
+#include "api/video/i420_buffer.h"
+#include "api/video/video_frame.h"
+#include "api/video/video_frame_buffer.h"
 
 namespace webrtc {
 namespace webrtc_pc_e2e {
@@ -32,13 +34,12 @@ rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateDummyFrameBuffer() {
   return buffer;
 }
 
-bool IsDummyFrameBuffer(
-    rtc::scoped_refptr<webrtc::VideoFrameBuffer> video_frame_buffer) {
-  if (video_frame_buffer->width() != 2 || video_frame_buffer->height() != 2) {
+bool IsDummyFrame(const webrtc::VideoFrame& video_frame) {
+  if (video_frame.width() != 2 || video_frame.height() != 2) {
     return false;
   }
   rtc::scoped_refptr<webrtc::I420BufferInterface> buffer =
-      video_frame_buffer->ToI420();
+      video_frame.video_frame_buffer()->ToI420();
   if (memcmp(buffer->DataY(), kIrrelatedSimulcastStreamFrameData, 2) != 0) {
     return false;
   }

test/pc/e2e/analyzer/video/simulcast_dummy_buffer_helper.h

@@ -11,16 +11,22 @@
 #ifndef TEST_PC_E2E_ANALYZER_VIDEO_SIMULCAST_DUMMY_BUFFER_HELPER_H_
 #define TEST_PC_E2E_ANALYZER_VIDEO_SIMULCAST_DUMMY_BUFFER_HELPER_H_
 
-#include "api/video/i420_buffer.h"
+#include "api/video/video_frame.h"
 #include "api/video/video_frame_buffer.h"
 
 namespace webrtc {
 namespace webrtc_pc_e2e {
 
+// Creates a special video frame buffer that should be used to create frames
+// during Selective Forwarding Unit (SFU) emulation. Such frames are used when
+// original was discarded and some frame is required to be passed upstream
+// to make WebRTC pipeline happy and not request key frame on the received
+// stream due to lack of incoming frames.
 rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateDummyFrameBuffer();
 
-bool IsDummyFrameBuffer(
-    rtc::scoped_refptr<webrtc::VideoFrameBuffer> video_frame_buffer);
+// Tests if provided frame contains a buffer created by
+// `CreateDummyFrameBuffer`.
+bool IsDummyFrame(const webrtc::VideoFrame& video_frame);
 
 }  // namespace webrtc_pc_e2e
 }  // namespace webrtc

test/pc/e2e/analyzer/video/simulcast_dummy_buffer_helper_test.cc

@@ -0,0 +1,61 @@
+/*
+ *  Copyright (c) 2022 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 "test/pc/e2e/analyzer/video/simulcast_dummy_buffer_helper.h"
+
+#include "api/video/i420_buffer.h"
+#include "api/video/video_frame.h"
+#include "api/video/video_frame_buffer.h"
+#include "rtc_base/random.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+namespace webrtc_pc_e2e {
+namespace {
+
+uint8_t RandByte(Random& random) {
+  return random.Rand(255);
+}
+
+VideoFrame CreateRandom2x2VideoFrame(uint16_t id, Random& random) {
+  rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(2, 2);
+
+  uint8_t data[6] = {RandByte(random), RandByte(random), RandByte(random),
+                     RandByte(random), RandByte(random), RandByte(random)};
+
+  memcpy(buffer->MutableDataY(), data, 2);
+  memcpy(buffer->MutableDataY() + buffer->StrideY(), data + 2, 2);
+  memcpy(buffer->MutableDataU(), data + 4, 1);
+  memcpy(buffer->MutableDataV(), data + 5, 1);
+
+  return VideoFrame::Builder()
+      .set_id(id)
+      .set_video_frame_buffer(buffer)
+      .set_timestamp_us(1)
+      .build();
+}
+
+TEST(CreateDummyFrameBufferTest, CreatedBufferIsDummy) {
+  VideoFrame dummy_frame = VideoFrame::Builder()
+                               .set_video_frame_buffer(CreateDummyFrameBuffer())
+                               .build();
+
+  EXPECT_TRUE(IsDummyFrame(dummy_frame));
+}
+
+TEST(IsDummyFrameTest, NotEveryFrameIsDummy) {
+  Random random(/*seed=*/100);
+  VideoFrame frame = CreateRandom2x2VideoFrame(1, random);
+  EXPECT_FALSE(IsDummyFrame(frame));
+}
+
+}  // namespace
+}  // namespace webrtc_pc_e2e
+}  // namespace webrtc

test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.cc

@@ -19,6 +19,7 @@
 #include "absl/memory/memory.h"
 #include "absl/strings/string_view.h"
 #include "api/array_view.h"
+#include "api/video/i420_buffer.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/strings/string_builder.h"
@@ -186,16 +187,15 @@ void VideoQualityAnalyzerInjectionHelper::Stop() {
 
 void VideoQualityAnalyzerInjectionHelper::OnFrame(absl::string_view peer_name,
                                                   const VideoFrame& frame) {
-  rtc::scoped_refptr<I420BufferInterface> i420_buffer =
-      frame.video_frame_buffer()->ToI420();
-  if (IsDummyFrameBuffer(i420_buffer)) {
+  if (IsDummyFrame(frame)) {
     // This is dummy frame, so we  don't need to process it further.
     return;
   }
   // Copy entire video frame including video buffer to ensure that analyzer
   // won't hold any WebRTC internal buffers.
   VideoFrame frame_copy = frame;
-  frame_copy.set_video_frame_buffer(I420Buffer::Copy(*i420_buffer));
+  frame_copy.set_video_frame_buffer(
+      I420Buffer::Copy(*frame.video_frame_buffer()->ToI420()));
   analyzer_->OnFrameRendered(peer_name, frame_copy);
 
   if (frame.id() != VideoFrame::kNotSetId) {