16 bpp video stream capture, render and createImageBitmap(video) using (CPU) shared memory buffers

media/renderers/skcanvas_video_renderer_unittest.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 <stdint.h>
 
 #include "base/macros.h"
+#include "base/memory/aligned_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface_stub.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/skia/include/core/SkCanvas.h"
@@ skipping 487 matching lines @@
   EXPECT_EQ(SK_ColorBLACK, GetColorAt(target_canvas(), kWidth * 1 / 8 - 1,
                                       kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorRED,
             GetColorAt(target_canvas(), kWidth * 3 / 8, kHeight * 1 / 6 - 1));
   EXPECT_EQ(SK_ColorGREEN,
             GetColorAt(target_canvas(), kWidth * 1 / 8 - 1, kHeight * 3 / 6));
   EXPECT_EQ(SK_ColorBLUE,
             GetColorAt(target_canvas(), kWidth * 3 / 8, kHeight * 3 / 6));
 }
 
+TEST_F(SkCanvasVideoRendererTest, Y16) {
+  SkBitmap bitmap;
+  bitmap.allocPixels(SkImageInfo::MakeN32(16, 16, kPremul_SkAlphaType));
+
+  // |offset_x| and |offset_y| define visible rect's offset to coded rect.
+  const int offset_x = 3;
+  const int offset_y = 5;
+  const int stride = bitmap.width() + offset_x;
+  const size_t byte_size = stride * (bitmap.height() + offset_y) * 2;
+  std::unique_ptr<unsigned char, base::AlignedFreeDeleter> memory(
+      static_cast<unsigned char*>(base::AlignedAlloc(
+          byte_size, media::VideoFrame::kFrameAddressAlignment)));
+
+  // In the visible rect, fill upper byte with [0-255] and lower with [255-0].
+  uint16_t* data = reinterpret_cast<uint16_t*>(memory.get());
+  for (int j = 0; j < bitmap.height(); j++) {
+    for (int i = 0; i < bitmap.width(); i++) {
+      const int value = i + j * bitmap.width();
+      data[(stride * (j + offset_y)) + i + offset_x] =
+          ((value & 0xFF) << 8) | (~value & 0xFF);
+    }
+  }
+  const gfx::Rect rect(offset_x, offset_y, bitmap.width(), bitmap.height());
+  scoped_refptr<media::VideoFrame> video_frame =
+      media::VideoFrame::WrapExternalData(
+          media::PIXEL_FORMAT_Y16,
+          gfx::Size(stride, offset_y + bitmap.height()), rect, rect.size(),
+          memory.get(), byte_size, cropped_frame()->timestamp());
+
+  SkCanvas canvas(bitmap);
+  SkPaint paint;
+  paint.setFilterQuality(kNone_SkFilterQuality);
+  renderer_.Paint(video_frame, &canvas,
+                  gfx::RectF(bitmap.width(), bitmap.height()), paint,
+                  VIDEO_ROTATION_0, Context3D());
+  SkAutoLockPixels lock(bitmap);
+  for (int j = 0; j < bitmap.height(); j++) {
+    for (int i = 0; i < bitmap.width(); i++) {
+      const int value = i + j * bitmap.width();
+      EXPECT_EQ(SkColorSetRGB(value, value, value), bitmap.getColor(i, j));
+    }
+  }
+}
+
 namespace {
 class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
  public:
   void GenTextures(GLsizei n, GLuint* textures) override {
     DCHECK_EQ(1, n);
     *textures = 1;
   }
 };
 void MailboxHoldersReleased(const gpu::SyncToken& sync_token) {}
 }  // namespace
@@ skipping 59 matching lines @@
   gfx::RectF visible_rect(visible_size.width(), visible_size.height());
   SkPaint paint;
   renderer_.Paint(video_frame, canvas, visible_rect, paint, VIDEO_ROTATION_0,
                   context_3d);
 
   EXPECT_EQ(fWidth / 2, renderer_.LastImageDimensionsForTesting().width());
   EXPECT_EQ(fWidth / 2, renderer_.LastImageDimensionsForTesting().height());
 }
 
 }  // namespace media