Adding VideoCaptureDevice for Mac.

media/video/capture/mac/video_capture_device_mac.mm

+// Copyright (c) 2011 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/mac/video_capture_device_mac.h"
+
+#import <QTKit/QTKit.h>
+
+#include "base/logging.h"
+#include "base/time.h"
+#include "media/video/capture/mac/video_capture_device_mac_qtkit.h"
+
+namespace media {
+
+void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
+  // Loop through all available devices and add to |device_names|.
+  device_names->clear();
+  // TODO(mflodman) Return name and id as NSArray* instead of QTCaptureDevice*.

[dmac, 2011/10/17 17:02:29]

NIT: I usually expect a blank line before a comment that isn't indented.

[mflodman_chromium_OOO, 2011/10/17 18:40:38]

Done.

+  for (QTCaptureDevice* device in [VideoCaptureDeviceMacQTKit deviceNames]) {
+    Name name;

[dmac, 2011/10/17 17:02:29]

NIT: would be nice if name was a class that just had a c'tor and two getters to
keep it immutable, but I know that's not your fault ;-)

[mflodman_chromium_OOO, 2011/10/17 18:40:38]

That is a really good point. I won't do anything about that in this CL, but I'll
make a note about it and implement that later for all platforms in the same CL.

+    NSString* qt_device_name = [device localizedDisplayName];
+    name.device_name = [qt_device_name UTF8String];
+    NSString* qt_unique_id = [device uniqueID];
+    name.unique_id = [qt_unique_id UTF8String];
+    device_names->push_back(name);
+  }
+}
+
+VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
+  VideoCaptureDeviceMac* capture_device =
+      new VideoCaptureDeviceMac(device_name);
+  if (!capture_device->Init()) {
+    LOG(ERROR) << "Could not initialize VideoCaptureDevice.";
+    delete capture_device;
+    return NULL;

[dmac, 2011/10/17 17:02:29]

NIT: I would assign capture_device to NULL here and just have a single exit
point for the method.

[mflodman_chromium_OOO, 2011/10/17 18:40:38]

Done.

+  }
+  return capture_device;
+}
+
+VideoCaptureDeviceMac::VideoCaptureDeviceMac(const Name& device_name)
+    : device_name_(device_name),
+      observer_(NULL),
+      state_(kNotInitialized),
+      capture_device_(NULL) {

[dmac, 2011/10/17 17:02:29]

capture_device_ should be initiailized to nil not NULL.

[mflodman_chromium_OOO, 2011/10/17 18:40:38]

Done.

+}
+
+VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
+  [capture_device_ release];
+}
+
+void VideoCaptureDeviceMac::Allocate(int width, int height, int frame_rate,
+                                     EventHandler* observer) {
+  if (state_ != kIdle) {
+    return;
+  }
+  observer_ = observer;
+  NSString* deviceId =
+      [NSString stringWithUTF8String:device_name_.unique_id.c_str()];
+
+  if (![capture_device_ setCaptureDevice:deviceId]) {
+    SetErrorState("Could not open capture device.");
+    return;
+  }
+  if ([capture_device_ setCaptureHeight:height

[dmac, 2011/10/17 17:02:29]

NIT: normally we would say if (![capture... instead of compating to NO)

[mflodman_chromium_OOO, 2011/10/17 18:40:38]

Done.

+                                  width:width
+                              frameRate:frame_rate] == NO) {
+    SetErrorState("Could not configure capture device.");
+    return;
+  }
+
+  state_ = kAllocated;
+  Capability current_settings;

[dmac, 2011/10/17 17:02:29]

NIT: again, if you are playing in the future, it would be great if this struct
was turned into a class with a c'tor and setters so that it was immutable.
Immutables are just significantly safer for passing around between threads and
such.

[mflodman_chromium_OOO, 2011/10/17 18:40:38]

Will do.

+  current_settings.color = kARGB;
+  current_settings.width = width;
+  current_settings.height = height;
+  current_settings.frame_rate = frame_rate;
+
+  observer_->OnFrameInfo(current_settings);
+}
+
+void VideoCaptureDeviceMac::Start() {
+  DCHECK_EQ(state_, kAllocated);
+  if (![capture_device_ startCapture]) {
+    SetErrorState("Could not start capture device.");
+    return;
+  }
+  state_ = kCapturing;
+}
+
+void VideoCaptureDeviceMac::Stop() {
+  DCHECK_EQ(state_, kCapturing);
+  [capture_device_ stopCapture];
+  state_ = kAllocated;
+}
+
+void VideoCaptureDeviceMac::DeAllocate() {
+  if (state_ != kAllocated && state_ != kCapturing) {
+    return;
+  }
+  if (state_ == kCapturing) {
+    [capture_device_ stopCapture];
+  }
+  [capture_device_ setCaptureDevice:nil];
+  state_ = kIdle;
+}
+
+const VideoCaptureDevice::Name& VideoCaptureDeviceMac::device_name() {
+  return device_name_;

[dmac, 2011/10/17 17:02:29]

NIT: worth inlining?

[mflodman_chromium_OOO, 2011/10/17 18:40:38]

After this CL, I'll check if this can be removed completely instead, but I'd
like to follow up with another patch doing this for all three platforms.

+}
+
+bool VideoCaptureDeviceMac::Init() {
+  DCHECK_EQ(state_, kNotInitialized);
+
+  Names device_names;
+  GetDeviceNames(&device_names);
+  for (Names::iterator it = device_names.begin();
+       it != device_names.end();
+       ++it) {
+    if (device_name_.unique_id == it->unique_id) {
+      capture_device_ =
+          [[VideoCaptureDeviceMacQTKit alloc] initWithFrameReceiver:this];
+      if (!capture_device_) {
+        return false;
+      }
+      state_ = kIdle;
+      return true;
+    }
+  }
+  return false;
+}
+
+void VideoCaptureDeviceMac::ReceiveFrame(const uint8* video_frame,
+                                         int video_frame_length,
+                                         const Capability& frame_info) {
+  observer_->OnIncomingCapturedFrame(video_frame, video_frame_length,
+                                     base::Time::Now());
+}
+
+void VideoCaptureDeviceMac::SetErrorState(const std::string& reason) {
+  DLOG(ERROR) << reason;
+  state_ = kError;
+  observer_->OnError();
+}
+
+} // namespace media