Revert 236927 "Reorganize media::VideoCapture* types"

trunk/src/content/browser/renderer_host/media/video_capture_controller.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 "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/base/yuv_convert.h"
 
 #if !defined(AVOID_LIBYUV_FOR_ANDROID_WEBVIEW)
 #include "third_party/libyuv/include/libyuv.h"
 #endif
 
-using media::VideoCaptureFormat;
+using media::VideoCaptureCapability;
 
 namespace content {
 
 namespace {
 
 // The number of buffers that VideoCaptureBufferPool should allocate.
 const int kNoOfBuffers = 3;
 
 class PoolBuffer : public media::VideoCaptureDevice::Client::Buffer {
  public:
   PoolBuffer(const scoped_refptr<VideoCaptureBufferPool>& pool,
              int buffer_id,
              void* data,
              size_t size)
       : Buffer(buffer_id, data, size), pool_(pool) {
     DCHECK(pool_);
   }
 
  private:
   virtual ~PoolBuffer() { pool_->RelinquishProducerReservation(id()); }
 
   const scoped_refptr<VideoCaptureBufferPool> pool_;
 };
 
 }  // anonymous namespace
 
 struct VideoCaptureController::ControllerClient {
-  ControllerClient(const VideoCaptureControllerID& id,
-                   VideoCaptureControllerEventHandler* handler,
-                   base::ProcessHandle render_process,
-                   media::VideoCaptureSessionId session_id,
-                   const media::VideoCaptureParams& params)
+  ControllerClient(
+      const VideoCaptureControllerID& id,
+      VideoCaptureControllerEventHandler* handler,
+      base::ProcessHandle render_process,
+      const media::VideoCaptureParams& params)
       : controller_id(id),
         event_handler(handler),
         render_process_handle(render_process),
-        session_id(session_id),
         parameters(params),
-        session_closed(false) {}
+        session_closed(false) {
+  }
 
   ~ControllerClient() {}
 
   // ID used for identifying this object.
-  const VideoCaptureControllerID controller_id;
-  VideoCaptureControllerEventHandler* const event_handler;
+  VideoCaptureControllerID controller_id;
+  VideoCaptureControllerEventHandler* event_handler;
 
   // Handle to the render process that will receive the capture buffers.
-  const base::ProcessHandle render_process_handle;
-  const media::VideoCaptureSessionId session_id;
-  const media::VideoCaptureParams parameters;
+  base::ProcessHandle render_process_handle;
+  media::VideoCaptureParams parameters;
 
   // Buffers that are currently known to this client.
   std::set<int> known_buffers;
 
   // Buffers currently held by this client.
   std::set<int> active_buffers;
 
   // State of capture session, controlled by VideoCaptureManager directly. This
   // transitions to true as soon as StopSession() occurs, at which point the
   // client is sent an OnEnded() event. However, because the client retains a
@@ skipping 26 matching lines @@
   // VideoCaptureDevice::Client implementation.
   virtual scoped_refptr<Buffer> ReserveOutputBuffer(
       media::VideoFrame::Format format,
       const gfx::Size& size) OVERRIDE;
   virtual void OnIncomingCapturedFrame(const uint8* data,
                                        int length,
                                        base::Time timestamp,
                                        int rotation,
                                        bool flip_vert,
                                        bool flip_horiz,
-                                       const VideoCaptureFormat& frame_format)
+                                       const VideoCaptureCapability& frame_info)
       OVERRIDE;
   virtual void OnIncomingCapturedBuffer(const scoped_refptr<Buffer>& buffer,
                                         media::VideoFrame::Format format,
                                         const gfx::Size& dimensions,
                                         base::Time timestamp,
                                         int frame_rate) OVERRIDE;
   virtual void OnError() OVERRIDE;
 
  private:
   scoped_refptr<Buffer> DoReserveOutputBuffer(media::VideoFrame::Format format,
@@ skipping 31 matching lines @@
 VideoCaptureController::NewDeviceClient() {
   scoped_ptr<media::VideoCaptureDevice::Client> result(
       new VideoCaptureDeviceClient(this->GetWeakPtr(), buffer_pool_));
   return result.Pass();
 }
 
 void VideoCaptureController::AddClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
-    media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::AddClient, id " << id.device_id
-           << ", " << params.requested_format.frame_size.ToString()
+           << ", (" << params.requested_format.width
+           << ", " << params.requested_format.height
            << ", " << params.requested_format.frame_rate
-           << ", " << session_id
+           << ", " << params.session_id
            << ")";
 
   // Signal error in case device is already in error state.
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
   // Do nothing if this client has called AddClient before.
   if (FindClient(id, event_handler, controller_clients_))
     return;
 
-  ControllerClient* client = new ControllerClient(
-      id, event_handler, render_process, session_id, params);
+  ControllerClient* client = new ControllerClient(id, event_handler,
+                                                  render_process, params);
   // If we already have gotten frame_info from the device, repeat it to the new
   // client.
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     controller_clients_.push_back(client);
     return;
   }
 }
 
 int VideoCaptureController::RemoveClient(
     const VideoCaptureControllerID& id,
     VideoCaptureControllerEventHandler* event_handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::RemoveClient, id " << id.device_id;
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
   if (!client)
     return kInvalidMediaCaptureSessionId;
 
   // Take back all buffers held by the |client|.
   for (std::set<int>::iterator buffer_it = client->active_buffers.begin();
        buffer_it != client->active_buffers.end();
        ++buffer_it) {
     int buffer_id = *buffer_it;
     buffer_pool_->RelinquishConsumerHold(buffer_id, 1);
   }
   client->active_buffers.clear();
 
-  int session_id = client->session_id;
+  int session_id = client->parameters.session_id;
   controller_clients_.remove(client);
   delete client;
 
   return session_id;
 }
 
 void VideoCaptureController::StopSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureController::StopSession, id " << session_id;
 
@@ skipping 30 matching lines @@
   return DoReserveOutputBuffer(format, size, 0);
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz,
-    const VideoCaptureFormat& frame_format) {
+    const VideoCaptureCapability& frame_info) {
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedFrame");
 
-  if (!frame_format.IsValid())
+  if (!frame_info.IsValid())
     return;
 
   // Chopped pixels in width/height in case video capture device has odd
   // numbers for width/height.
   int chopped_width = 0;
   int chopped_height = 0;
-  int new_width = frame_format.frame_size.width();
-  int new_height = frame_format.frame_size.height();
+  int new_width = frame_info.width;
+  int new_height = frame_info.height;
 
-  if (new_width & 1) {
+  if (frame_info.width & 1) {
     --new_width;
     chopped_width = 1;
   }
-  if (new_height & 1) {
+  if (frame_info.height & 1) {
     --new_height;
     chopped_height = 1;
   }
 
   const gfx::Size dimensions(new_width, new_height);
   scoped_refptr<Buffer> buffer =
       DoReserveOutputBuffer(media::VideoFrame::I420, dimensions, rotation);
 
   if (!buffer)
     return;
@@ skipping 20 matching lines @@
   // new_vertical_flip = horizontal_flip XOR vertical_flip
   int new_rotation_angle = (rotation + 180 * flip_vert) % 360;
   libyuv::RotationMode rotation_mode = libyuv::kRotate0;
   if (new_rotation_angle == 90)
     rotation_mode = libyuv::kRotate90;
   else if (new_rotation_angle == 180)
     rotation_mode = libyuv::kRotate180;
   else if (new_rotation_angle == 270)
     rotation_mode = libyuv::kRotate270;
 
-  switch (frame_format.pixel_format) {
+  switch (frame_info.color) {
     case media::PIXEL_FORMAT_UNKNOWN:  // Color format not set.
       break;
     case media::PIXEL_FORMAT_I420:
       DCHECK(!chopped_width && !chopped_height);
       origin_colorspace = libyuv::FOURCC_I420;
       break;
     case media::PIXEL_FORMAT_YV12:
       DCHECK(!chopped_width && !chopped_height);
       origin_colorspace = libyuv::FOURCC_YV12;
       break;
@@ skipping 19 matching lines @@
       origin_colorspace = libyuv::FOURCC_MJPG;
       break;
     default:
       NOTREACHED();
   }
 
   int need_convert_rgb24_on_win = false;
 #if defined(OS_WIN)
   // kRGB24 on Windows start at the bottom line and has a negative stride. This
   // is not supported by libyuv, so the media API is used instead.
-  if (frame_format.pixel_format == media::PIXEL_FORMAT_RGB24) {
+  if (frame_info.color == media::PIXEL_FORMAT_RGB24) {
     // Rotation and flipping is not supported in kRGB24 and OS_WIN case.
     DCHECK(!rotation && !flip_vert && !flip_horiz);
     need_convert_rgb24_on_win = true;
   }
 #endif
   if (need_convert_rgb24_on_win) {
     int rgb_stride = -3 * (new_width + chopped_width);
     const uint8* rgb_src = data + 3 * (new_width + chopped_width) *
                                       (new_height - 1 + chopped_height);
     media::ConvertRGB24ToYUV(rgb_src,
@@ skipping 49 matching lines @@
   NOTREACHED();
 #endif  // if !defined(AVOID_LIBYUV_FOR_ANDROID_WEBVIEW)
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &VideoCaptureController::DoIncomingCapturedI420BufferOnIOThread,
           controller_,
           buffer,
           dimensions,
-          frame_format.frame_rate,
+          frame_info.frame_rate,
           timestamp));
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     const scoped_refptr<Buffer>& buffer,
     media::VideoFrame::Format format,
     const gfx::Size& dimensions,
     base::Time timestamp,
     int frame_rate) {
   // The capture pipeline expects I420 for now.
@@ skipping 69 matching lines @@
 }
 
 void VideoCaptureController::DoIncomingCapturedI420BufferOnIOThread(
     scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer,
     const gfx::Size& dimensions,
     int frame_rate,
     base::Time timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_NE(buffer->id(), VideoCaptureBufferPool::kInvalidId);
 
-  VideoCaptureFormat frame_format(
-      dimensions, frame_rate, media::PIXEL_FORMAT_I420);
+  media::VideoCaptureFormat frame_format(
+      dimensions.width(),
+      dimensions.height(),
+      frame_rate,
+      media::VariableResolutionVideoCaptureDevice);
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     for (ControllerClients::iterator client_it = controller_clients_.begin();
          client_it != controller_clients_.end(); ++client_it) {
       ControllerClient* client = *client_it;
       if (client->session_closed)
         continue;
 
       bool is_new_buffer = client->known_buffers.insert(buffer->id()).second;
@@ skipping 62 matching lines @@
   }
   return NULL;
 }
 
 VideoCaptureController::ControllerClient*
 VideoCaptureController::FindClient(
     int session_id,
     const ControllerClients& clients) {
   for (ControllerClients::const_iterator client_it = clients.begin();
        client_it != clients.end(); ++client_it) {
-    if ((*client_it)->session_id == session_id) {
+    if ((*client_it)->parameters.session_id == session_id) {
       return *client_it;
     }
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return controller_clients_.size();
 }
 
 }  // namespace content