Implement device enumeration for PPB_VideoCapture_Dev.

ppapi/examples/video_capture/video_capture.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 <assert.h>
 #include <string.h>
 
 #include <map>
 #include <vector>
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_opengles2.h"
 #include "ppapi/cpp/dev/buffer_dev.h"
+#include "ppapi/cpp/dev/device_ref_dev.h"
 #include "ppapi/cpp/dev/video_capture_dev.h"
 #include "ppapi/cpp/dev/video_capture_client_dev.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/graphics_3d_client.h"
 #include "ppapi/cpp/graphics_3d.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
+#include "ppapi/cpp/var.h"
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
 // Assert |context_| isn't holding any GL Errors.  Done as a macro instead of a
 // function to preserve line number information in the failure message.
 #define assertNoGLError() \
   assert(!gles2_if_->GetError(context_->pp_resource()));
 
 namespace {
 
@@ skipping 10 matching lines @@
 class VCDemoInstance : public pp::Instance,
                        public pp::Graphics3DClient,
                        public pp::VideoCaptureClient_Dev {
  public:
   VCDemoInstance(PP_Instance instance, pp::Module* module);
   virtual ~VCDemoInstance();
 
   // pp::Instance implementation (see PPP_Instance).
   virtual void DidChangeView(const pp::Rect& position,
                              const pp::Rect& clip_ignored);
+  virtual void HandleMessage(const pp::Var& message_data);
 
   // pp::Graphics3DClient implementation.
   virtual void Graphics3DContextLost() {
     InitGL();
     CreateYUVTextures();
     Render();
   }
 
   virtual void OnDeviceInfo(PP_Resource resource,
                             const PP_VideoCaptureDeviceInfo_Dev& info,
                             const std::vector<pp::Buffer_Dev>& buffers) {
     capture_info_ = info;
     buffers_ = buffers;
     CreateYUVTextures();
   }
 
   virtual void OnStatus(PP_Resource resource, uint32_t status) {
+    status_ = static_cast<PP_VideoCaptureStatus_Dev>(status);
+    if (status_ == PP_VIDEO_CAPTURE_STATUS_STOPPED)
+      StartCapture();
   }
 
   virtual void OnError(PP_Resource resource, uint32_t error) {
   }
 
   virtual void OnBufferReady(PP_Resource resource, uint32_t buffer) {
     const char* data = static_cast<const char*>(buffers_[buffer].data());
     int32_t width = capture_info_.width;
     int32_t height = capture_info_.height;
     gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
@@ skipping 21 matching lines @@
       needs_paint_ = true;
     else
       Render();
   }
 
  private:
   void Render();
 
   // GL-related functions.
   void InitGL();
-  void InitializeCapture();
   GLuint CreateTexture(int32_t width, int32_t height, int unit);
   void CreateGLObjects();
   void CreateShader(GLuint program, GLenum type, const char* source, int size);
   void PaintFinished(int32_t result);
   void CreateYUVTextures();
 
+  void EnumerateDevicesFinished(int32_t result);
+  void StartCapture();
+
   pp::Size position_size_;
   bool is_painting_;
   bool needs_paint_;
   GLuint texture_y_;
   GLuint texture_u_;
   GLuint texture_v_;
   pp::VideoCapture_Dev video_capture_;
   PP_VideoCaptureDeviceInfo_Dev capture_info_;
   std::vector<pp::Buffer_Dev> buffers_;
   pp::CompletionCallbackFactory<VCDemoInstance> callback_factory_;
 
   // Unowned pointers.
   const struct PPB_OpenGLES2* gles2_if_;
 
   // Owned data.
   pp::Graphics3D* context_;
+
+  bool page_initialized_;
+  PP_VideoCaptureStatus_Dev status_;
+  std::vector<pp::DeviceRef_Dev> devices_;
+
+  // >= 0 means index of |devices_|;
+  // -1 means the default device;
+  // -2 means no pending request to start capture.
+  int pending_start_capture_device_;
 };
 
 VCDemoInstance::VCDemoInstance(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
       pp::Graphics3DClient(this),
       pp::VideoCaptureClient_Dev(this),
       is_painting_(false),
       needs_paint_(false),
       texture_y_(0),
       texture_u_(0),
       texture_v_(0),
       video_capture_(*this),
       callback_factory_(this),
-      context_(NULL) {
+      context_(NULL),
+      page_initialized_(false),
+      status_(PP_VIDEO_CAPTURE_STATUS_STOPPED),
+      pending_start_capture_device_(-2) {
   gles2_if_ = static_cast<const struct PPB_OpenGLES2*>(
       module->GetBrowserInterface(PPB_OPENGLES2_INTERFACE));
   assert(gles2_if_);
-  InitializeCapture();
+
+  capture_info_.width = 320;
+  capture_info_.height = 240;
+  capture_info_.frames_per_second = 30;
 }
 
 VCDemoInstance::~VCDemoInstance() {
   delete context_;
 }
 
 void VCDemoInstance::DidChangeView(
     const pp::Rect& position, const pp::Rect& clip_ignored) {
   if (position.width() == 0 || position.height() == 0)
     return;
   if (position.size() == position_size_)
     return;
 
   position_size_ = position.size();
 
   // Initialize graphics.
   InitGL();
 
   Render();
 }
 
-void VCDemoInstance::InitializeCapture() {
-  capture_info_.width = 320;
-  capture_info_.height = 240;
-  capture_info_.frames_per_second = 30;
-
-  video_capture_.StartCapture(capture_info_, 4);
+void VCDemoInstance::HandleMessage(const pp::Var& message_data) {
+  if (message_data.is_string()) {
+    std::string event = message_data.AsString();
+    if (event == "PageInitialized") {
+      pp::CompletionCallback callback = callback_factory_.NewCallback(
+          &VCDemoInstance::EnumerateDevicesFinished);
+      video_capture_.EnumerateDevices(callback);
+    } else if (event == "UseDefault") {
+      pending_start_capture_device_ = -1;
+      StartCapture();
+    }
+  } else if (message_data.is_number()) {
+    int index = message_data.AsInt();
+    if (index >= 0 && index < static_cast<int>(devices_.size())) {
+      pending_start_capture_device_= index;
+      StartCapture();
+    } else {
+      assert(false);
+    }
+  }
 }
 
 void VCDemoInstance::InitGL() {
   assert(position_size_.width() && position_size_.height());
   is_painting_ = false;
 
   delete context_;
   int32_t attributes[] = {
     PP_GRAPHICS3DATTRIB_ALPHA_SIZE, 0,
     PP_GRAPHICS3DATTRIB_BLUE_SIZE, 8,
@@ skipping 169 matching lines @@
   int32_t width = capture_info_.width;
   int32_t height = capture_info_.height;
   texture_y_ = CreateTexture(width, height, 0);
 
   width /= 2;
   height /= 2;
   texture_u_ = CreateTexture(width, height, 1);
   texture_v_ = CreateTexture(width, height, 2);
 }
 
+void VCDemoInstance::EnumerateDevicesFinished(int32_t result) {
+  static const char* const kDelimiter = "#__#";
+
+  if (result == PP_OK) {
+    std::string device_names;
+    video_capture_.GetDevices(&devices_);
+    for (size_t index = 0; index < devices_.size(); ++index) {
+      pp::Var name = devices_[index].GetName();
+      assert(name.is_string());
+
+      if (index != 0)
+        device_names += kDelimiter;
+      device_names += name.AsString();
+    }
+    PostMessage(pp::Var(device_names));
+  } else {
+    PostMessage(pp::Var("EnumerationFailed"));
+  }
+}
+
+void VCDemoInstance::StartCapture() {
+  if (status_ != PP_VIDEO_CAPTURE_STATUS_STOPPED) {
+    video_capture_.StopCapture();
+    return;
+  }
+
+  if (pending_start_capture_device_ > -2 &&
+      pending_start_capture_device_ < static_cast<int>(devices_.size())) {
+    video_capture_.StartCapture(
+        pending_start_capture_device_ == -1 ?
+            pp::DeviceRef_Dev() : devices_[pending_start_capture_device_],
+        capture_info_, 4);
+  }
+  pending_start_capture_device_ = -2;
+}
+
 pp::Instance* VCDemoModule::CreateInstance(PP_Instance instance) {
   return new VCDemoInstance(instance, this);
 }
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new VCDemoModule();
 }
 }  // namespace pp