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

device/capture/video/win/video_capture_device_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/video_capture_device_win.h"
+#include "device/capture/video/win/video_capture_device_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
 #include <list>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "media/base/timestamp_constants.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
-namespace media {
+namespace device {
 
 // Check if a Pin matches a category.
 bool PinMatchesCategory(IPin* pin, REFGUID category) {
   DCHECK(pin);
   bool found = false;
   ScopedComPtr<IKsPropertySet> ks_property;
   HRESULT hr = ks_property.QueryFrom(pin);
   if (SUCCEEDED(hr)) {
     GUID pin_category;
     DWORD return_value;
@@ skipping 108 matching lines @@
 }
 
 // static
 VideoPixelFormat
 VideoCaptureDeviceWin::TranslateMediaSubtypeToPixelFormat(
     const GUID& sub_type) {
   static struct {
     const GUID& sub_type;
     VideoPixelFormat format;
   } const kMediaSubtypeToPixelFormatCorrespondence[] = {
-      {kMediaSubTypeI420, PIXEL_FORMAT_I420},
-      {MEDIASUBTYPE_IYUV, PIXEL_FORMAT_I420},
-      {MEDIASUBTYPE_RGB24, PIXEL_FORMAT_RGB24},
-      {MEDIASUBTYPE_YUY2, PIXEL_FORMAT_YUY2},
-      {MEDIASUBTYPE_MJPG, PIXEL_FORMAT_MJPEG},
-      {MEDIASUBTYPE_UYVY, PIXEL_FORMAT_UYVY},
-      {MEDIASUBTYPE_ARGB32, PIXEL_FORMAT_ARGB},
-      {kMediaSubTypeHDYC, PIXEL_FORMAT_UYVY},
+      {kMediaSubTypeI420, media::PIXEL_FORMAT_I420},
+      {MEDIASUBTYPE_IYUV, media::PIXEL_FORMAT_I420},
+      {MEDIASUBTYPE_RGB24, media::PIXEL_FORMAT_RGB24},
+      {MEDIASUBTYPE_YUY2, media::PIXEL_FORMAT_YUY2},
+      {MEDIASUBTYPE_MJPG, media::PIXEL_FORMAT_MJPEG},
+      {MEDIASUBTYPE_UYVY, media::PIXEL_FORMAT_UYVY},
+      {MEDIASUBTYPE_ARGB32, media::PIXEL_FORMAT_ARGB},
+      {kMediaSubTypeHDYC, media::PIXEL_FORMAT_UYVY},
   };
   for (const auto& pixel_format : kMediaSubtypeToPixelFormatCorrespondence) {
     if (sub_type == pixel_format.sub_type)
       return pixel_format.format;
   }
 #ifndef NDEBUG
   WCHAR guid_str[128];
   StringFromGUID2(sub_type, guid_str, arraysize(guid_str));
   DVLOG(2) << "Device (also) supports an unknown media type " << guid_str;
 #endif
-  return PIXEL_FORMAT_UNKNOWN;
+  return media::PIXEL_FORMAT_UNKNOWN;
 }
 
 void VideoCaptureDeviceWin::ScopedMediaType::Free() {
   if (!media_type_)
     return;
 
   DeleteMediaType(media_type_);
   media_type_ = NULL;
 }
 
@@ skipping 319 matching lines @@
       DLOG(ERROR) << "Failed to GetStreamCaps: "
                   << logging::SystemErrorCodeToString(hr);
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
       VideoCaptureFormat format;
       format.pixel_format =
           TranslateMediaSubtypeToPixelFormat(media_type->subtype);
-      if (format.pixel_format == PIXEL_FORMAT_UNKNOWN)
+      if (format.pixel_format == media::PIXEL_FORMAT_UNKNOWN)
         continue;
 
       VIDEOINFOHEADER* h =
           reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
       format.frame_size.SetSize(h->bmiHeader.biWidth, h->bmiHeader.biHeight);
 
       // Try to get a better |time_per_frame| from IAMVideoControl. If not, use
       // the value from VIDEOINFOHEADER.
       REFERENCE_TIME time_per_frame = h->AvgTimePerFrame;
       if (video_control.get()) {
@@ skipping 22 matching lines @@
       capabilities_.emplace_back(stream_index, format, h->bmiHeader);
     }
   }
 
   return !capabilities_.empty();
 }
 
 // Set the power line frequency removal in |capture_filter_| if available.
 void VideoCaptureDeviceWin::SetAntiFlickerInCaptureFilter(
     const VideoCaptureParams& params) {
-  const PowerLineFrequency power_line_frequency = GetPowerLineFrequency(params);
+  const media::PowerLineFrequency power_line_frequency =
+      GetPowerLineFrequency(params);
   if (power_line_frequency != media::PowerLineFrequency::FREQUENCY_50HZ &&
       power_line_frequency != media::PowerLineFrequency::FREQUENCY_60HZ) {
     return;
   }
   ScopedComPtr<IKsPropertySet> ks_propset;
   DWORD type_support = 0;
   HRESULT hr;
   if (SUCCEEDED(hr = ks_propset.QueryFrom(capture_filter_.get())) &&
       SUCCEEDED(hr = ks_propset->QuerySupported(
                     PROPSETID_VIDCAP_VIDEOPROCAMP,
@@ skipping 19 matching lines @@
   }
 }
 
 void VideoCaptureDeviceWin::SetErrorState(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   state_ = kError;
   client_->OnError(from_here, reason);
 }
-}  // namespace media
+}  // namespace device