VideoTrackRecorder: add support for texture backed ARGB VideoFrames

content/renderer/media/video_track_recorder_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/video_track_recorder.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 22 matching lines @@
 using ::testing::SaveArg;
 using ::testing::TestWithParam;
 using ::testing::ValuesIn;
 
 namespace content {
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
+// VideoFrame holding ARGB memory-backed pixels (VideoFrame has no public API
+// surface for creating this type of frames nor their storage).
+class ARGBVideoFrame : public media::VideoFrame {
+ public:
+  ARGBVideoFrame(const gfx::Size& size)
+      : VideoFrame(media::PIXEL_FORMAT_ARGB,
+                   STORAGE_OWNED_MEMORY,
+                   size,
+                   gfx::Rect(size),
+                   size,
+                   base::TimeDelta()),
+        buffer_(size.GetArea()) {
+    set_data(kARGBPlane, buffer_.data());
+    set_stride(kARGBPlane, size.GetArea());
+  }
+
+ private:
+  ~ARGBVideoFrame() final {}
+
+  std::vector<uint8_t> buffer_;
+  DISALLOW_COPY_AND_ASSIGN(ARGBVideoFrame);
+};
+
 const VideoTrackRecorder::CodecId kTrackRecorderTestCodec[] = {
     VideoTrackRecorder::CodecId::VP8,
     VideoTrackRecorder::CodecId::VP9
 #if BUILDFLAG(RTC_USE_H264)
     , VideoTrackRecorder::CodecId::H264
 #endif
 };
 
+// Typical frame size; cannot be arbitrarily small, should be reasonable.
+static const gfx::Size kFrameSize(80,40);
+
+static void DummyReleaseMailboxCB(const gpu::SyncToken& sync_token) {}
+
 class VideoTrackRecorderTest
     : public TestWithParam<VideoTrackRecorder::CodecId> {
  public:
   VideoTrackRecorderTest()
       : mock_source_(new MockMediaStreamVideoSource(false)) {
     const blink::WebString webkit_track_id(base::UTF8ToUTF16("dummy"));
     blink_source_.initialize(webkit_track_id,
                              blink::WebMediaStreamSource::TypeVideo,
                              webkit_track_id);
     blink_source_.setExtraData(mock_source_);
@@ skipping 60 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(VideoTrackRecorderTest);
 };
 
 // Construct and destruct all objects, in particular |video_track_recorder_| and
 // its inner object(s). This is a non trivial sequence.
 TEST_P(VideoTrackRecorderTest, ConstructAndDestruct) {}
 
 // Creates the encoder and encodes 2 frames of the same size; the encoder should
 // be initialised and produce a keyframe, then a non-keyframe. Finally a frame
 // of larger size is sent and is expected to be encoded as a keyframe.
-TEST_P(VideoTrackRecorderTest, VideoEncoding) {
-  // |frame_size| cannot be arbitrarily small, should be reasonable.
-  const gfx::Size frame_size(160, 80);
+TEST_P(VideoTrackRecorderTest, Encoding) {
   const scoped_refptr<VideoFrame> video_frame =
-      VideoFrame::CreateBlackFrame(frame_size);
+      VideoFrame::CreateBlackFrame(kFrameSize);
   const double kFrameRate = 60.0f;
   video_frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                      kFrameRate);
 
   InSequence s;
   const base::TimeTicks timeticks_now = base::TimeTicks::Now();
   base::StringPiece first_frame_encoded_data;
   EXPECT_CALL(*this, DoOnEncodedVideo(video_frame, _, timeticks_now, true))
       .Times(1)
       .WillOnce(SaveArg<1>(&first_frame_encoded_data));
@@ skipping 25 matching lines @@
   run_loop.Run();
 
   const size_t kEncodedSizeThreshold = 14;
   EXPECT_GE(first_frame_encoded_data.size(), kEncodedSizeThreshold);
   EXPECT_GE(second_frame_encoded_data.size(), kEncodedSizeThreshold);
   EXPECT_GE(third_frame_encoded_data.size(), kEncodedSizeThreshold);
 
   Mock::VerifyAndClearExpectations(this);
 }
 
+// Verifies that a Mappable ARGB Video Frame can be correctly encoded.
+TEST_P(VideoTrackRecorderTest, EncodingARGBFrame) {
+  const scoped_refptr<VideoFrame> video_frame(new ARGBVideoFrame(kFrameSize));
+
+  InSequence s;
+  base::RunLoop run_loop;
+  base::Closure quit_closure = run_loop.QuitClosure();
+  scoped_refptr<VideoFrame> encoded_frame;
+  base::StringPiece encoded_data;
+  EXPECT_CALL(*this, DoOnEncodedVideo(_, _, _, true))
+      .Times(1)
+      .WillOnce(DoAll(SaveArg<0>(&encoded_frame),
+                      SaveArg<1>(&encoded_data),
+                      RunClosure(quit_closure)));
+  Encode(video_frame, base::TimeTicks::Now());
+  run_loop.Run();
+
+  EXPECT_EQ(media::PIXEL_FORMAT_I420, encoded_frame->format());
+  EXPECT_EQ(video_frame->coded_size(), encoded_frame->coded_size());
+
+  const size_t kEncodedSizeThreshold = 14;
+  EXPECT_GE(encoded_data.size(), kEncodedSizeThreshold);
+
+  Mock::VerifyAndClearExpectations(this);
+}
+
+// Tests that a not IsMappable() frame is encoded as a full black one.
+TEST_P(VideoTrackRecorderTest, EncodingNonMappableFrame) {
+  gpu::MailboxHolder mailbox_holders[media::VideoFrame::kMaxPlanes] = {};
+  const scoped_refptr<VideoFrame> video_frame = VideoFrame::WrapNativeTextures(
+      media::PIXEL_FORMAT_ARGB, mailbox_holders,
+      base::Bind(&DummyReleaseMailboxCB), kFrameSize, gfx::Rect(kFrameSize),
+      kFrameSize, base::TimeDelta());
+  ASSERT_FALSE(video_frame->IsMappable());
+
+  InSequence s;
+  base::RunLoop run_loop;
+  base::Closure quit_closure = run_loop.QuitClosure();
+  scoped_refptr<VideoFrame> encoded_frame;
+  EXPECT_CALL(*this, DoOnEncodedVideo(_, _, _, true))
+      .Times(1)
+      .WillOnce(DoAll(SaveArg<0>(&encoded_frame), RunClosure(quit_closure)));
+  Encode(video_frame, base::TimeTicks::Now());
+  run_loop.Run();
+
+  // |encoded_frame| should be full-black, since |video_frame| is not mappable.
+  ASSERT_EQ(media::PIXEL_FORMAT_YV12, encoded_frame->format());
+  EXPECT_EQ(video_frame->coded_size(), encoded_frame->coded_size());
+  const uint8_t* y_plane = encoded_frame->data(media::VideoFrame::kYPlane);

[emircan, 2016/07/12 22:57:00]

Can we have this in a for loop?

[mcasas, 2016/07/13 00:45:31]

Do you mean:

for (int i = 0; i < y_plane_size; ++i)
  EXPECT_EQ(0u, encoded_frame->data(media::VideoFrame::kYPlane)[i]);

Wouldn't that evaluate a function call every loop iteration?

FTR, there is 
{ASSERT,EXPECT}_THAT(Collection, Each(Eq(kValue)));
but that only works with types having iterators. So sad.

+  const int y_plane_size = encoded_frame->row_bytes(media::VideoFrame::kYPlane);
+  for (int i = 0; i < y_plane_size; ++i)
+    EXPECT_EQ(0u, y_plane[i]);
+  const uint8_t* u_plane = encoded_frame->data(media::VideoFrame::kUPlane);
+  const int u_plane_size = encoded_frame->row_bytes(media::VideoFrame::kUPlane);
+  for (int i = 0; i < u_plane_size; ++i)
+    EXPECT_EQ(0x80, u_plane[i]);
+  const uint8_t* v_plane = encoded_frame->data(media::VideoFrame::kVPlane);
+  const int v_plane_size = encoded_frame->row_bytes(media::VideoFrame::kVPlane);
+  for (int i = 0; i < v_plane_size; ++i)
+    EXPECT_EQ(0x80, v_plane[i]);
+
+  Mock::VerifyAndClearExpectations(this);
+}
+
 INSTANTIATE_TEST_CASE_P(,
                         VideoTrackRecorderTest,
                         ValuesIn(kTrackRecorderTestCodec));
 
 }  // namespace content