Consolidate duplicated frame / capability structures in video_capture_types.h

media/video/capture/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/video/capture/win/video_capture_device_win.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/command_line.h"
@@ skipping 364 matching lines @@
     }
     // Set the sink filter to request this capability.
     sink_filter_->SetRequestedMediaCapability(capability);
     // Order the capture device to use this capability.
     hr = stream_config->SetFormat(pmt);
   }
 
   if (FAILED(hr))
     SetErrorState("Failed to set capture device output format");
 
-  if (capability.color == VideoCaptureCapability::kMJPEG &&
+  if (capability.color == kMJPEG &&
       !mjpg_filter_.get()) {
     // Create MJPG filter if we need it.
     hr = mjpg_filter_.CreateInstance(CLSID_MjpegDec, NULL, CLSCTX_INPROC);
 
     if (SUCCEEDED(hr)) {
       GetPin(mjpg_filter_, PINDIR_INPUT, GUID_NULL, input_mjpg_pin_.Receive());
       GetPin(mjpg_filter_, PINDIR_OUTPUT, GUID_NULL,
              output_mjpg_pin_.Receive());
       hr = graph_builder_->AddFilter(mjpg_filter_, NULL);
     }
 
     if (FAILED(hr)) {
       mjpg_filter_.Release();
       input_mjpg_pin_.Release();
       output_mjpg_pin_.Release();
     }
   }
 
-  if (capability.color == VideoCaptureCapability::kMJPEG &&
+  if (capability.color == kMJPEG &&
       mjpg_filter_.get()) {
     // Connect the camera to the MJPEG decoder.
     hr = graph_builder_->ConnectDirect(output_capture_pin_, input_mjpg_pin_,
                                        NULL);
     // Connect the MJPEG filter to the Capture filter.
     hr += graph_builder_->ConnectDirect(output_mjpg_pin_, input_sink_pin_,
                                         NULL);
   } else {
     hr = graph_builder_->ConnectDirect(output_capture_pin_, input_sink_pin_,
                                        NULL);
@@ skipping 159 matching lines @@
         capability.frame_rate = (time_per_frame > 0) ?
             static_cast<int>(kSecondsToReferenceTime / time_per_frame) : 0;
       }
       // DirectShow works at the moment only on integer frame_rate but the
       // best capability matching class works on rational frame rates.
       capability.frame_rate_numerator = capability.frame_rate;
       capability.frame_rate_denominator = 1;
 
       // We can't switch MEDIATYPE :~(.
       if (media_type->subtype == kMediaSubTypeI420) {
-        capability.color = VideoCaptureCapability::kI420;
+        capability.color = kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_IYUV) {
         // This is identical to kI420.
-        capability.color = VideoCaptureCapability::kI420;
+        capability.color = kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_RGB24) {
-        capability.color = VideoCaptureCapability::kRGB24;
+        capability.color = kRGB24;
       } else if (media_type->subtype == MEDIASUBTYPE_YUY2) {
-        capability.color = VideoCaptureCapability::kYUY2;
+        capability.color = kYUY2;
       } else if (media_type->subtype == MEDIASUBTYPE_MJPG) {
-        capability.color = VideoCaptureCapability::kMJPEG;
+        capability.color = kMJPEG;
       } else if (media_type->subtype == MEDIASUBTYPE_UYVY) {
-        capability.color = VideoCaptureCapability::kUYVY;
+        capability.color = kUYVY;
       } else if (media_type->subtype == MEDIASUBTYPE_ARGB32) {
-        capability.color = VideoCaptureCapability::kARGB;
+        capability.color = kARGB;
       } else {
         WCHAR guid_str[128];
         StringFromGUID2(media_type->subtype, guid_str, arraysize(guid_str));
         DVLOG(2) << "Device supports (also) an unknown media type " << guid_str;
         continue;
       }
       capabilities_.Add(capability);
     }
     DeleteMediaType(media_type);
     media_type = NULL;
   }
 
   return !capabilities_.empty();
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const char* reason) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   observer_->OnError();
 }
 }  // namespace media