move //media/capture to //device/capture

device/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 "device/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/logging.h"
 #include "base/macros.h"
 #include "media/base/timestamp_constants.h"
 
-namespace media {
+namespace device {
 
 const REFERENCE_TIME kSecondsToReferenceTime = 10000000;
 
 static DWORD GetArea(const BITMAPINFOHEADER& info_header) {
   return info_header.biWidth * info_header.biHeight;
 }
 
 SinkInputPin::SinkInputPin(IBaseFilter* filter, SinkFilterObserver* observer)
     : PinBase(filter), requested_frame_rate_(0), observer_(observer) {
 }
 
 void SinkInputPin::SetRequestedMediaFormat(
     VideoPixelFormat pixel_format,
     float frame_rate,
     const BITMAPINFOHEADER& info_header) {
   requested_pixel_format_ = pixel_format;
   requested_frame_rate_ = frame_rate;
   requested_info_header_ = info_header;
   resulting_format_.frame_size.SetSize(0, 0);
   resulting_format_.frame_rate = 0;
-  resulting_format_.pixel_format = PIXEL_FORMAT_UNKNOWN;
+  resulting_format_.pixel_format = media::PIXEL_FORMAT_UNKNOWN;
 }
 
 bool SinkInputPin::IsMediaTypeValid(const AM_MEDIA_TYPE* media_type) {
   const GUID type = media_type->majortype;
   if (type != MEDIATYPE_Video)
     return false;
 
   const GUID format_type = media_type->formattype;
   if (format_type != FORMAT_VideoInfo)
     return false;
 
   // Check for the sub types we support.
   const GUID sub_type = media_type->subtype;
   VIDEOINFOHEADER* pvi =
       reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
   if (pvi == NULL)
     return false;
 
   // Store the incoming width and height.
   resulting_format_.frame_size.SetSize(pvi->bmiHeader.biWidth,
                                        abs(pvi->bmiHeader.biHeight));
   if (pvi->AvgTimePerFrame > 0) {
     resulting_format_.frame_rate =
         static_cast<int>(kSecondsToReferenceTime / pvi->AvgTimePerFrame);
   } else {
     resulting_format_.frame_rate = requested_frame_rate_;
   }
   if (sub_type == kMediaSubTypeI420 &&
       pvi->bmiHeader.biCompression == MAKEFOURCC('I', '4', '2', '0')) {
-    resulting_format_.pixel_format = PIXEL_FORMAT_I420;
+    resulting_format_.pixel_format = media::PIXEL_FORMAT_I420;
     return true;
   }
   if (sub_type == MEDIASUBTYPE_YUY2 &&
       pvi->bmiHeader.biCompression == MAKEFOURCC('Y', 'U', 'Y', '2')) {
-    resulting_format_.pixel_format = PIXEL_FORMAT_YUY2;
+    resulting_format_.pixel_format = media::PIXEL_FORMAT_YUY2;
     return true;
   }
   // This format is added after http:/crbug.com/508413.
   if (sub_type == MEDIASUBTYPE_UYVY &&
       pvi->bmiHeader.biCompression == MAKEFOURCC('U', 'Y', 'V', 'Y')) {
-    resulting_format_.pixel_format = PIXEL_FORMAT_UYVY;
+    resulting_format_.pixel_format = media::PIXEL_FORMAT_UYVY;
     return true;
   }
   if (sub_type == MEDIASUBTYPE_MJPG &&
       pvi->bmiHeader.biCompression == MAKEFOURCC('M', 'J', 'P', 'G')) {
-    resulting_format_.pixel_format = PIXEL_FORMAT_MJPEG;
+    resulting_format_.pixel_format = media::PIXEL_FORMAT_MJPEG;
     return true;
   }
   if (sub_type == MEDIASUBTYPE_RGB24 &&
       pvi->bmiHeader.biCompression == BI_RGB) {
-    resulting_format_.pixel_format = PIXEL_FORMAT_RGB24;
+    resulting_format_.pixel_format = media::PIXEL_FORMAT_RGB24;
     return true;
   }
   if (sub_type == MEDIASUBTYPE_RGB32 &&
       pvi->bmiHeader.biCompression == BI_RGB) {
-    resulting_format_.pixel_format = PIXEL_FORMAT_RGB32;
+    resulting_format_.pixel_format = media::PIXEL_FORMAT_RGB32;
     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;
 }
@@ skipping 10 matching lines @@
   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_ == media::PIXEL_FORMAT_MJPEG) {
     // If the requested pixel format is MJPEG, accept only MJPEG.
     // 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;
   }
 
@@ skipping 71 matching lines @@
     timestamp = base::TimeDelta::FromMicroseconds(start_time / 10);
   }
 
   observer_->FrameReceived(buffer, length, timestamp);
   return S_OK;
 }
 
 SinkInputPin::~SinkInputPin() {
 }
 
-}  // namespace media
+}  // namespace device