Delete RawVideoType enum, use the VideoType enum instead.

webrtc/media/engine/webrtcvideocapturer.cc

 /*
  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/media/engine/webrtcvideocapturer.h"
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 #include "webrtc/base/win32.h"  // Need this to #include the impl files.
 #include "webrtc/modules/video_capture/video_capture_factory.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace cricket {
 
+namespace {
 struct kVideoFourCCEntry {
   uint32_t fourcc;
-  webrtc::RawVideoType webrtc_type;
+  webrtc::VideoType webrtc_type;
 };
 
 // This indicates our format preferences and defines a mapping between
 // webrtc::RawVideoType (from video_capture_defines.h) to our FOURCCs.
-static kVideoFourCCEntry kSupportedFourCCs[] = {
-  { FOURCC_I420, webrtc::kVideoI420 },   // 12 bpp, no conversion.
-  { FOURCC_YV12, webrtc::kVideoYV12 },   // 12 bpp, no conversion.
-  { FOURCC_YUY2, webrtc::kVideoYUY2 },   // 16 bpp, fast conversion.
-  { FOURCC_UYVY, webrtc::kVideoUYVY },   // 16 bpp, fast conversion.
-  { FOURCC_NV12, webrtc::kVideoNV12 },   // 12 bpp, fast conversion.
-  { FOURCC_NV21, webrtc::kVideoNV21 },   // 12 bpp, fast conversion.
-  { FOURCC_MJPG, webrtc::kVideoMJPEG },  // compressed, slow conversion.
-  { FOURCC_ARGB, webrtc::kVideoARGB },   // 32 bpp, slow conversion.
-  { FOURCC_24BG, webrtc::kVideoRGB24 },  // 24 bpp, slow conversion.
+kVideoFourCCEntry kSupportedFourCCs[] = {
+    {FOURCC_I420, webrtc::VideoType::kI420},   // 12 bpp, no conversion.
+    {FOURCC_YV12, webrtc::VideoType::kYV12},   // 12 bpp, no conversion.
+    {FOURCC_YUY2, webrtc::VideoType::kYUY2},   // 16 bpp, fast conversion.
+    {FOURCC_UYVY, webrtc::VideoType::kUYVY},   // 16 bpp, fast conversion.
+    {FOURCC_NV12, webrtc::VideoType::kNV12},   // 12 bpp, fast conversion.
+    {FOURCC_NV21, webrtc::VideoType::kNV21},   // 12 bpp, fast conversion.
+    {FOURCC_MJPG, webrtc::VideoType::kMJPEG},  // compressed, slow conversion.
+    {FOURCC_ARGB, webrtc::VideoType::kARGB},   // 32 bpp, slow conversion.
+    {FOURCC_24BG, webrtc::VideoType::kRGB24},  // 24 bpp, slow conversion.
 };
 
-class WebRtcVcmFactory : public WebRtcVcmFactoryInterface {
- public:
-  virtual rtc::scoped_refptr<webrtc::VideoCaptureModule> Create(
-      const char* device) {
-    return webrtc::VideoCaptureFactory::Create(device);
-  }
-  virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo() {
-    return webrtc::VideoCaptureFactory::CreateDeviceInfo();
-  }
-  virtual void DestroyDeviceInfo(webrtc::VideoCaptureModule::DeviceInfo* info) {
-    delete info;
-  }
-};
-
-static bool CapabilityToFormat(const webrtc::VideoCaptureCapability& cap,
-                               VideoFormat* format) {
+bool CapabilityToFormat(const webrtc::VideoCaptureCapability& cap,
+                        VideoFormat* format) {
   uint32_t fourcc = 0;
   for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
-    if (kSupportedFourCCs[i].webrtc_type == cap.rawType) {
+    if (kSupportedFourCCs[i].webrtc_type == cap.videoType) {
       fourcc = kSupportedFourCCs[i].fourcc;
       break;
     }
   }
   if (fourcc == 0) {
     return false;
   }
 
   format->fourcc = fourcc;
   format->width = cap.width;
   format->height = cap.height;
   format->interval = VideoFormat::FpsToInterval(cap.maxFPS);
   return true;
 }
 
-static bool FormatToCapability(const VideoFormat& format,
-                               webrtc::VideoCaptureCapability* cap) {
-  webrtc::RawVideoType webrtc_type = webrtc::kVideoUnknown;
+bool FormatToCapability(const VideoFormat& format,
+                        webrtc::VideoCaptureCapability* cap) {
+  webrtc::VideoType webrtc_type = webrtc::VideoType::kUnknown;
   for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
     if (kSupportedFourCCs[i].fourcc == format.fourcc) {
       webrtc_type = kSupportedFourCCs[i].webrtc_type;
       break;
     }
   }
-  if (webrtc_type == webrtc::kVideoUnknown) {
+  if (webrtc_type == webrtc::VideoType::kUnknown) {
     return false;
   }
 
   cap->width = format.width;
   cap->height = format.height;
   cap->maxFPS = VideoFormat::IntervalToFps(format.interval);
-  cap->rawType = webrtc_type;
+  cap->videoType = webrtc_type;
   cap->interlaced = false;
   return true;
 }
 
+}  // namespace
+
+class WebRtcVcmFactory : public WebRtcVcmFactoryInterface {
+ public:
+  virtual rtc::scoped_refptr<webrtc::VideoCaptureModule> Create(
+      const char* device) {
+    return webrtc::VideoCaptureFactory::Create(device);
+  }
+  virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo() {
+    return webrtc::VideoCaptureFactory::CreateDeviceInfo();
+  }
+  virtual void DestroyDeviceInfo(webrtc::VideoCaptureModule::DeviceInfo* info) {
+    delete info;
+  }
+};
+
 ///////////////////////////////////////////////////////////////////////////
 // Implementation of class WebRtcVideoCapturer
 ///////////////////////////////////////////////////////////////////////////
 
 WebRtcVideoCapturer::WebRtcVideoCapturer()
     : factory_(new WebRtcVcmFactory),
       module_(nullptr),
       captured_frames_(0),
       start_thread_(nullptr),
       async_invoker_(nullptr) {}
@@ skipping 46 matching lines @@
   std::vector<VideoFormat> supported;
   int32_t num_caps = info->NumberOfCapabilities(vcm_id);
   for (int32_t i = 0; i < num_caps; ++i) {
     webrtc::VideoCaptureCapability cap;
     if (info->GetCapability(vcm_id, i, cap) != -1) {
       VideoFormat format;
       if (CapabilityToFormat(cap, &format)) {
         supported.push_back(format);
       } else {
         LOG(LS_WARNING) << "Ignoring unsupported WebRTC capture format "
-                        << cap.rawType;
+                        << static_cast<int>(cap.videoType);
       }
     }
   }
   factory_->DestroyDeviceInfo(info);
 
   if (supported.empty()) {
     LOG(LS_ERROR) << "Failed to find usable formats for id: " << device.id;
     return false;
   }
 
@@ skipping 162 matching lines @@
   if (1 == captured_frames_) {
     LOG(LS_INFO) << "Captured frame size "
                  << sample.width() << "x" << sample.height()
                  << ". Expected format " << GetCaptureFormat()->ToString();
   }
 
   VideoCapturer::OnFrame(sample, sample.width(), sample.height());
 }
 
 }  // namespace cricket