FakeVideoCaptureDevice: Y16 testing support.

media/capture/video/fake_video_capture_device.cc

 // Copyright (c) 2012 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 "media/capture/video/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 10 matching lines @@
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace media {
 
 // Sweep at 600 deg/sec.
 static const float kPacmanAngularVelocity = 600;
 // Beep every 500 ms.
 static const int kBeepInterval = 500;
+// Gradient travels from bottom to top in 5 seconds.
+static const float kGradientFrequency = 1.f / 5;
 
 static const uint32_t kMinZoom = 100;
 static const uint32_t kMaxZoom = 400;
 static const uint32_t kZoomStep = 1;
 
-void DrawPacman(bool use_argb,
+// Starting from top left, -45 deg gradient.  Value at point (row, column) is
+// calculated as (top_left_value + (row + column) * step) % MAX_VALUE, where
+// step is MAX_VALUE / (width + height).  MAX_VALUE is 255 (for 8 bit per
+// component) or 65535 for Y16.
+// This is handy for pixel tests where we use the squares to verify rendering.
+void DrawGradientSquares(VideoPixelFormat frame_format,
+                         uint8_t* const pixels,
+                         base::TimeDelta elapsed_time,
+                         const gfx::Size& frame_size) {
+  const int width = frame_size.width();
+  const int height = frame_size.height();
+  const int side = width / 16;  // square side length.
+  DCHECK(side);
+  gfx::Point squares[] = {{0, 0},

[mcasas, 2016/10/25 22:13:12]

const ?
Also |start| in the next line.

[aleksandar.stojiljkovic, 2016/10/25 23:20:40]

Done.

+                          {width - side, 0},
+                          {0, height - side},
+                          {width - side, height - side}};
+  float start =
+      fmod(65536 * elapsed_time.InSecondsF() * kGradientFrequency, 65536);
+  const float color_step = 65535 / static_cast<float>(width + height);
+  for (unsigned i = 0; i < sizeof(squares) / sizeof(gfx::Point); ++i) {

[mcasas, 2016/10/25 22:13:12]

Suggestion:

  for (const auto& corner : squares) {
    for (int y = corner.y(); y < corner.y() + side; ++y) {
      for (int x = corner.x(); y < corner.x() + side; ++x) {
        // same here
        

[aleksandar.stojiljkovic, 2016/10/25 23:20:39]

Done.

+    for (int y = squares[i].y(); y < squares[i].y() + side; ++y) {
+      for (int x = squares[i].x(); x < squares[i].x() + side; ++x) {
+        unsigned value =

[mcasas, 2016/10/25 22:13:12]

const unsigned int?

[aleksandar.stojiljkovic, 2016/10/25 23:20:39]

Done.

+            static_cast<unsigned>(start + (x + y) * color_step) & 0xFFFF;
+        size_t offset = (y * width) + x;
+        switch (frame_format) {
+          case PIXEL_FORMAT_Y16:
+            pixels[offset * sizeof(uint16_t)] = value & 0xFF;
+            pixels[offset * sizeof(uint16_t) + 1] = value >> 8;
+            break;
+          case PIXEL_FORMAT_ARGB:
+            pixels[offset * sizeof(uint32_t) + 1] = value >> 8;
+            pixels[offset * sizeof(uint32_t) + 2] = value >> 8;
+            pixels[offset * sizeof(uint32_t) + 3] = value >> 8;
+            break;
+          default:
+            pixels[offset] = value >> 8;
+            break;
+        }
+      }
+    }
+  }
+}
+
+void DrawPacman(VideoPixelFormat frame_format,
                 uint8_t* const data,
                 base::TimeDelta elapsed_time,
                 float frame_rate,
                 const gfx::Size& frame_size,
                 uint32_t zoom) {
   // |kN32_SkColorType| stands for the appropriate RGBA/BGRA format.
-  const SkColorType colorspace =
-      use_argb ? kN32_SkColorType : kAlpha_8_SkColorType;
+  const SkColorType colorspace = (frame_format == PIXEL_FORMAT_ARGB)
+                                     ? kN32_SkColorType
+                                     : kAlpha_8_SkColorType;
+  // Skia doesn't support 16 bit alpha rendering, so we 8 bit alpha and then use
+  // this as high byte values in 16 bit pixels.
   const SkImageInfo info = SkImageInfo::Make(
       frame_size.width(), frame_size.height(), colorspace, kOpaque_SkAlphaType);
   SkBitmap bitmap;
   bitmap.setInfo(info);
   bitmap.setPixels(data);
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   SkCanvas canvas(bitmap);
 
   const SkScalar unscaled_zoom = zoom / 100.f;
   SkMatrix matrix;
   matrix.setScale(unscaled_zoom, unscaled_zoom, frame_size.width() / 2,
                   frame_size.height() / 2);
   canvas.setMatrix(matrix);
 
   // Equalize Alpha_8 that has light green background while RGBA has white.
-  if (use_argb) {
+  if (frame_format == PIXEL_FORMAT_ARGB) {
     const SkRect full_frame =
         SkRect::MakeWH(frame_size.width(), frame_size.height());
     paint.setARGB(255, 0, 127, 0);
     canvas.drawRect(full_frame, paint);
   }
   paint.setColor(SK_ColorGREEN);
 
   // Draw a sweeping circle to show an animation.
   const float end_angle =
       fmod(kPacmanAngularVelocity * elapsed_time.InSecondsF(), 361);
   const int radius = std::min(frame_size.width(), frame_size.height()) / 4;
   const SkRect rect = SkRect::MakeXYWH(frame_size.width() / 2 - radius,
                                        frame_size.height() / 2 - radius,
                                        2 * radius, 2 * radius);
   canvas.drawArc(rect, 0, end_angle, true, paint);
 
   // Draw current time.
   const int milliseconds = elapsed_time.InMilliseconds() % 1000;
   const int seconds = elapsed_time.InSeconds() % 60;
   const int minutes = elapsed_time.InMinutes() % 60;
   const int hours = elapsed_time.InHours();
   const int frame_count = elapsed_time.InMilliseconds() * frame_rate / 1000;
 
   const std::string time_string =
       base::StringPrintf("%d:%02d:%02d:%03d %d", hours, minutes, seconds,
                          milliseconds, frame_count);
   canvas.scale(3, 3);
   canvas.drawText(time_string.data(), time_string.length(), 30, 20, paint);
+
+  if (frame_format == PIXEL_FORMAT_Y16) {
+    // Use 8 bit bitmap rendered to first half of the buffer as high byte values
+    // for the whole buffer. Low byte values are not important.
+    for (int i = frame_size.GetArea() - 1; i >= 0; --i) {
+      data[i * 2 + 1] = data[i];
+    }

[mcasas, 2016/10/25 22:13:12]

No need for {} in one-line bodies.

[aleksandar.stojiljkovic, 2016/10/25 23:20:39]

Done.

+  }
+  DrawGradientSquares(frame_format, data, elapsed_time, frame_size);

[mcasas, 2016/10/25 22:13:12]

So, just to make sure, I think you mentioned
elsewhere that this is not going to throw off
tests that expect some green pixels on pixels
in the upper left corner or its vicinity, correct?

[aleksandar.stojiljkovic, 2016/10/25 23:20:40]

I run CQ in Patch Set 1: all passed - layout test issue on one of linux bots
linux seems unrelated.

webrtc tests like this one here [1] use central point:
https://cs.chromium.org/chromium/src/content/browser/media/capture/web_conten...

 }
 
 // Creates a PNG-encoded frame and sends it back to |callback|. The other
 // parameters are used to replicate the PacMan rendering.
 void DoTakeFakePhoto(VideoCaptureDevice::TakePhotoCallback callback,
                      const VideoCaptureFormat& capture_format,
                      base::TimeDelta elapsed_time,
                      float fake_capture_rate,
                      uint32_t zoom) {
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[VideoFrame::AllocationSize(
       PIXEL_FORMAT_ARGB, capture_format.frame_size)]);
 
-  DrawPacman(true /* use_argb */, buffer.get(), elapsed_time, fake_capture_rate,
+  DrawPacman(PIXEL_FORMAT_ARGB, buffer.get(), elapsed_time, fake_capture_rate,
              capture_format.frame_size, zoom);
 
   mojom::BlobPtr blob = mojom::Blob::New();
   const bool result = gfx::PNGCodec::Encode(
       buffer.get(), gfx::PNGCodec::FORMAT_RGBA, capture_format.frame_size,
       capture_format.frame_size.width() * 4, true /* discard_transparency */,
       std::vector<gfx::PNGCodec::Comment>(), &blob->data);
   DCHECK(result);
 
   blob->mime_type = "image/png";
   callback.Run(std::move(blob));
 }
 
 FakeVideoCaptureDevice::FakeVideoCaptureDevice(BufferOwnership buffer_ownership,
-                                               float fake_capture_rate)
+                                               float fake_capture_rate,
+                                               VideoPixelFormat pixel_format)
     : buffer_ownership_(buffer_ownership),
       fake_capture_rate_(fake_capture_rate),
+      pixel_format_(pixel_format),
       current_zoom_(kMinZoom),
       weak_factory_(this) {}
 
 FakeVideoCaptureDevice::~FakeVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void FakeVideoCaptureDevice::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_ = std::move(client);
 
   // Incoming |params| can be none of the supported formats, so we get the
   // closest thing rounded up. TODO(mcasas): Use the |params|, if they belong to
   // the supported ones, when http://crbug.com/309554 is verified.
   capture_format_.frame_rate = fake_capture_rate_;
   if (params.requested_format.frame_size.width() > 1280)
     capture_format_.frame_size.SetSize(1920, 1080);
   else if (params.requested_format.frame_size.width() > 640)
     capture_format_.frame_size.SetSize(1280, 720);
   else if (params.requested_format.frame_size.width() > 320)
     capture_format_.frame_size.SetSize(640, 480);
+  else if (params.requested_format.frame_size.width() > 96)
+    capture_format_.frame_size.SetSize(320, 240);
   else
-    capture_format_.frame_size.SetSize(320, 240);
+    capture_format_.frame_size.SetSize(96, 96);
 
+  capture_format_.pixel_format = pixel_format_;
   if (buffer_ownership_ == BufferOwnership::CLIENT_BUFFERS) {
     capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
     capture_format_.pixel_format = PIXEL_FORMAT_ARGB;
     DVLOG(1) << "starting with client argb buffers";
   } else if (buffer_ownership_ == BufferOwnership::OWN_BUFFERS) {
     capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
-    capture_format_.pixel_format = PIXEL_FORMAT_I420;
-    DVLOG(1) << "starting with own I420 buffers";
+    DVLOG(1) << "starting with own" << VideoPixelFormatToString(pixel_format_)
+             << "buffers";

[mcasas, 2016/10/25 22:13:12]

nit: whitespace here before "buffers" and after "own" in l.217.

[aleksandar.stojiljkovic, 2016/10/25 23:20:39]

Done.

   }
 
-  if (capture_format_.pixel_format == PIXEL_FORMAT_I420) {
+  if (buffer_ownership_ == BufferOwnership::OWN_BUFFERS) {
     fake_frame_.reset(new uint8_t[VideoFrame::AllocationSize(
-        PIXEL_FORMAT_I420, capture_format_.frame_size)]);
+        pixel_format_, capture_format_.frame_size)]);
   }
 
   beep_time_ = base::TimeDelta();
   elapsed_time_ = base::TimeDelta();
 
   if (buffer_ownership_ == BufferOwnership::CLIENT_BUFFERS)
     BeepAndScheduleNextCapture(
         base::TimeTicks::Now(),
         base::Bind(&FakeVideoCaptureDevice::CaptureUsingClientBuffers,
                    weak_factory_.GetWeakPtr()));
@@ skipping 58 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&DoTakeFakePhoto, base::Passed(&callback), capture_format_,
                  elapsed_time_, fake_capture_rate_, current_zoom_));
 }
 
 void FakeVideoCaptureDevice::CaptureUsingOwnBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const size_t frame_size = capture_format_.ImageAllocationSize();
+
   memset(fake_frame_.get(), 0, frame_size);
-
-  DrawPacman(false /* use_argb */, fake_frame_.get(), elapsed_time_,
+  DrawPacman(capture_format_.pixel_format, fake_frame_.get(), elapsed_time_,
              fake_capture_rate_, capture_format_.frame_size, current_zoom_);
-
   // Give the captured frame to the client.
   base::TimeTicks now = base::TimeTicks::Now();
   if (first_ref_time_.is_null())
     first_ref_time_ = now;
   client_->OnIncomingCapturedData(fake_frame_.get(), frame_size,
                                   capture_format_, 0 /* rotation */, now,
                                   now - first_ref_time_);
   BeepAndScheduleNextCapture(
       expected_execution_time,
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::unique_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
       client_->ReserveOutputBuffer(capture_format_.frame_size,
                                    capture_format_.pixel_format,
                                    capture_format_.pixel_storage));
   DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
   DCHECK(capture_buffer->data()) << "Buffer has NO backing memory";
 
   DCHECK_EQ(PIXEL_STORAGE_CPU, capture_format_.pixel_storage);
-  DCHECK_EQ(PIXEL_FORMAT_ARGB, capture_format_.pixel_format);
   uint8_t* data_ptr = static_cast<uint8_t*>(capture_buffer->data());
   memset(data_ptr, 0, capture_buffer->mapped_size());
-  DrawPacman(true /* use_argb */, data_ptr, elapsed_time_, fake_capture_rate_,
-             capture_format_.frame_size, current_zoom_);
+  DrawPacman(capture_format_.pixel_format, data_ptr, elapsed_time_,
+             fake_capture_rate_, capture_format_.frame_size, current_zoom_);
 
   // Give the captured frame to the client.
   base::TimeTicks now = base::TimeTicks::Now();
   if (first_ref_time_.is_null())
     first_ref_time_ = now;
   client_->OnIncomingCapturedBuffer(std::move(capture_buffer), capture_format_,
                                     now, now - first_ref_time_);
 
   BeepAndScheduleNextCapture(
       expected_execution_time,
@@ skipping 22 matching lines @@
   // Don't accumulate any debt if we are lagging behind - just post the next
   // frame immediately and continue as normal.
   const base::TimeTicks next_execution_time =
       std::max(current_time, expected_execution_time + frame_interval);
   const base::TimeDelta delay = next_execution_time - current_time;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(next_capture, next_execution_time), delay);
 }
 
 }  // namespace media