Delete RawVideoType enum, use the VideoType enum instead.

webrtc/modules/video_capture/linux/video_capture_linux.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 30 matching lines @@
 
 VideoCaptureModuleV4L2::VideoCaptureModuleV4L2()
     : VideoCaptureImpl(),
       _deviceId(-1),
       _deviceFd(-1),
       _buffersAllocatedByDevice(-1),
       _currentWidth(-1),
       _currentHeight(-1),
       _currentFrameRate(-1),
       _captureStarted(false),
-      _captureVideoType(kVideoI420),
-      _pool(NULL)
-{
-}
+      _captureVideoType(VideoType::kI420),
+      _pool(NULL) {}
 
 int32_t VideoCaptureModuleV4L2::Init(const char* deviceUniqueIdUTF8)
 {
     int len = strlen((const char*) deviceUniqueIdUTF8);
     _deviceUniqueId = new (std::nothrow) char[len + 1];
     if (_deviceUniqueId)
     {
         memcpy(_deviceUniqueId, deviceUniqueIdUTF8, len + 1);
     }
 
@@ skipping 42 matching lines @@
     StopCapture();
     if (_deviceFd != -1)
       close(_deviceFd);
 }
 
 int32_t VideoCaptureModuleV4L2::StartCapture(
     const VideoCaptureCapability& capability)
 {
     if (_captureStarted)
     {
-        if (capability.width == _currentWidth &&
-            capability.height == _currentHeight &&
-            _captureVideoType == capability.rawType)
-        {
-            return 0;
+      if (capability.width == _currentWidth &&
+          capability.height == _currentHeight &&
+          _captureVideoType == capability.videoType) {
+        return 0;
         }
         else
         {
             StopCapture();
         }
     }
 
     rtc::CritScope cs(&_captureCritSect);
     //first open /dev/video device
     char device[20];
@@ skipping 62 matching lines @@
 
     struct v4l2_format video_fmt;
     memset(&video_fmt, 0, sizeof(struct v4l2_format));
     video_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     video_fmt.fmt.pix.sizeimage = 0;
     video_fmt.fmt.pix.width = capability.width;
     video_fmt.fmt.pix.height = capability.height;
     video_fmt.fmt.pix.pixelformat = fmts[fmtsIdx];
 
     if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
-        _captureVideoType = kVideoYUY2;
+      _captureVideoType = VideoType::kYUY2;
     else if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420)
-        _captureVideoType = kVideoI420;
+      _captureVideoType = VideoType::kI420;
     else if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_UYVY)
-        _captureVideoType = kVideoUYVY;
+      _captureVideoType = VideoType::kUYVY;
     else if (video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG ||
              video_fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG)
-        _captureVideoType = kVideoMJPEG;
+      _captureVideoType = VideoType::kMJPEG;
 
     //set format and frame size now
     if (ioctl(_deviceFd, VIDIOC_S_FMT, &video_fmt) < 0)
     {
         WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "error in VIDIOC_S_FMT, errno = %d", errno);
         return -1;
     }
 
     // initialize current width and height
@@ skipping 23 matching lines @@
                    "Failed to set the framerate. errno=%d", errno);
           driver_framerate_support = false;
         } else {
           _currentFrameRate = capability.maxFPS;
         }
       }
     }
     // If driver doesn't support framerate control, need to hardcode.
     // Hardcoding the value based on the frame size.
     if (!driver_framerate_support) {
-      if(_currentWidth >= 800 && _captureVideoType != kVideoMJPEG) {
+      if (_currentWidth >= 800 && _captureVideoType != VideoType::kMJPEG) {
         _currentFrameRate = 15;
       } else {
         _currentFrameRate = 30;
       }
     }
 
     if (!AllocateVideoBuffers())
     {
         WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                    "failed to allocate video capture buffers");
@@ skipping 174 matching lines @@
             if (errno != EINTR)
             {
                 WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCapture, 0,
                            "could not sync on a buffer on device %s", strerror(errno));
                 return true;
             }
         }
         VideoCaptureCapability frameInfo;
         frameInfo.width = _currentWidth;
         frameInfo.height = _currentHeight;
-        frameInfo.rawType = _captureVideoType;
+        frameInfo.videoType = _captureVideoType;
 
         // convert to to I420 if needed
         IncomingFrame((unsigned char*) _pool[buf.index].start,
                       buf.bytesused, frameInfo);
         // enqueue the buffer again
         if (ioctl(_deviceFd, VIDIOC_QBUF, &buf) == -1)
         {
             WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideoCapture, 0,
                        "Failed to enqueue capture buffer");
         }
     }
     usleep(0);
     return true;
 }
 
 int32_t VideoCaptureModuleV4L2::CaptureSettings(VideoCaptureCapability& settings)
 {
     settings.width = _currentWidth;
     settings.height = _currentHeight;
     settings.maxFPS = _currentFrameRate;
-    settings.rawType=_captureVideoType;
+    settings.videoType = _captureVideoType;
 
     return 0;
 }
 }  // namespace videocapturemodule
 }  // namespace webrtc