16 bpp video stream capture, render and WebGL usage - Realsense R200 & SR300 support.

media/capture/video/win/sink_input_pin_win.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/win/sink_input_pin_win.h"
 
 #include <cstring>
 
 // Avoid including strsafe.h via dshow as it will cause build warnings.
 #define NO_DSHOW_STRSAFE
 #include <dshow.h>
 #include <stdint.h>
 
+#include "base/big_endian.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 const REFERENCE_TIME kSecondsToReferenceTime = 10000000;
 
 static DWORD GetArea(const BITMAPINFOHEADER& info_header) {
   return info_header.biWidth * info_header.biHeight;
@@ skipping 65 matching lines @@
       pvi->bmiHeader.biCompression == BI_RGB) {
     resulting_format_.pixel_format = PIXEL_FORMAT_RGB24;
     return true;
   }
   if (sub_type == MEDIASUBTYPE_RGB32 &&
       pvi->bmiHeader.biCompression == BI_RGB) {
     resulting_format_.pixel_format = PIXEL_FORMAT_RGB32;
     return true;
   }
 
+  if (sub_type.Data1 == pvi->bmiHeader.biCompression) {
+    // TODO(astojilj) Define GUIDs and move this to common place as the code is
+    // replicated around.
+    uint32_t fourcc;
+    base::ReadBigEndian(reinterpret_cast<const char*>(&sub_type.Data1),
+                        &fourcc);
+    if (fourcc == 'Z16 ' || fourcc == 'INVZ') {
+      resulting_format_.pixel_format = PIXEL_FORMAT_Y16;
+      return true;
+    } else if (fourcc == 'Y8  ') {
+      resulting_format_.pixel_format = PIXEL_FORMAT_Y8;
+      return true;
+    }
+  }
+
 #ifndef NDEBUG
   WCHAR guid_str[128];
   StringFromGUID2(sub_type, guid_str, arraysize(guid_str));
   DVLOG(2) << __func__ << " unsupported media type: " << guid_str;
 #endif
   return false;
 }
 
 bool SinkInputPin::GetValidMediaType(int index, AM_MEDIA_TYPE* media_type) {
   if (media_type->cbFormat < sizeof(VIDEOINFOHEADER))
     return false;
 
   VIDEOINFOHEADER* const pvi =
       reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
 
   ZeroMemory(pvi, sizeof(VIDEOINFOHEADER));
   pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
   pvi->bmiHeader.biPlanes = 1;
   pvi->bmiHeader.biClrImportant = 0;
   pvi->bmiHeader.biClrUsed = 0;
   if (requested_frame_rate_ > 0)
     pvi->AvgTimePerFrame = kSecondsToReferenceTime / requested_frame_rate_;
 
   media_type->majortype = MEDIATYPE_Video;
   media_type->formattype = FORMAT_VideoInfo;
   media_type->bTemporalCompression = FALSE;
 
-  if (requested_pixel_format_ == PIXEL_FORMAT_MJPEG) {
+  if (requested_pixel_format_ == PIXEL_FORMAT_MJPEG ||
+      requested_pixel_format_ == PIXEL_FORMAT_Y8 ||
+      requested_pixel_format_ == PIXEL_FORMAT_Y16) {
     // If the requested pixel format is MJPEG, accept only MJPEG.
+    // If the requested pixel format is Y16 or Y8, accept only those.
     // This is ok since the capabilities of the capturer have been
     // enumerated and we know that it is supported.
     if (index != 0)
       return false;
 
     pvi->bmiHeader = requested_info_header_;
     return true;
   }
 
   switch (index) {
@@ skipping 71 matching lines @@
   }
 
   observer_->FrameReceived(buffer, length, timestamp);
   return S_OK;
 }
 
 SinkInputPin::~SinkInputPin() {
 }
 
 }  // namespace media