enable video capture to support sharing across multiple renderer processes

content/renderer/media/video_capture_module_impl.cc

 // 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 "content/renderer/media/video_capture_module_impl.h"
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 
+namespace {
+
+static void CopyOnePlane(uint8* src, int src_stride, int src_rows,
+                         uint8* dest, int dest_stride, int dest_rows) {
+  // Clamp in case source frame has smaller stride.
+  int bytes_to_copy_per_row = std::min(src_stride, dest_stride);
+  // Clamp in case source frame has smaller height.
+  int rows_to_copy = std::min(src_rows, dest_rows);
+  // Copy Y plane.
+  for (int row = 0; row < rows_to_copy; ++row) {
+    memcpy(dest, src, bytes_to_copy_per_row);
+    src += src_stride;
+    dest += dest_stride;
+  }
+}
+
+static void CopyI420(uint8* src, int src_stride, int src_rows,
+                     uint8* dest, int dest_stride, int dest_rows) {
+  int src_plane_size = src_stride * src_rows;
+  int dest_plane_size = dest_stride * dest_rows;
+  CopyOnePlane(src, src_stride, src_rows, dest, dest_stride, dest_rows);
+
+  src += src_plane_size;
+  dest += dest_plane_size;
+  src_stride /= 2;
+  src_rows /= 2;
+  dest_stride /= 2;
+  dest_rows /= 2;
+  CopyOnePlane(src, src_stride, src_rows, dest, dest_stride, dest_rows);
+  src += src_plane_size / 4;
+  dest += dest_plane_size / 4;
+  CopyOnePlane(src, src_stride, src_rows, dest, dest_stride, dest_rows);
+}
+
+}  // namespace
+
 VideoCaptureModuleImpl::VideoCaptureModuleImpl(
     const media::VideoCaptureSessionId id,
     VideoCaptureImplManager* vc_manager)
     : webrtc::videocapturemodule::VideoCaptureImpl(id),
       session_id_(id),
       thread_("VideoCaptureModuleImpl"),
       vc_manager_(vc_manager),
       state_(media::VideoCapture::kStopped),
       got_first_frame_(false),
       width_(-1),
@@ skipping 132 matching lines @@
   width_ = capability.width;
   height_ = capability.height;
   frame_rate_ = capability.maxFPS;
   state_ = media::VideoCapture::kStarted;
 
   media::VideoCapture::VideoCaptureCapability cap;
   cap.width = capability.width;
   cap.height = capability.height;
   cap.max_fps = capability.maxFPS;
   cap.raw_type = media::VideoFrame::I420;
-  cap.resolution_fixed = true;
   capture_engine_->StartCapture(this, cap);
 }
 
 void VideoCaptureModuleImpl::StopCaptureOnCaptureThread() {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
 
   if (pending_start_) {
     VLOG(1) << "Got a StopCapture with one pending start!!! ";
     pending_start_ = false;
     return;
@@ skipping 26 matching lines @@
     VLOG(1) << "restart pending start ";
     pending_start_ = false;
     StartCaptureInternal(pending_cap_);
   }
 }
 
 void VideoCaptureModuleImpl::OnBufferReadyOnCaptureThread(
     media::VideoCapture* capture,
     scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK_GE(buf->width, static_cast<int>(width_));
+  DCHECK_GE(buf->height, static_cast<int>(height_));
 
   if (state_ != media::VideoCapture::kStarted)
     return;
 
   if (!got_first_frame_) {

[perkj_chrome, 2011/10/28 08:37:19]

Why is this necessary? Why compensate the time? ViE don't care about the
timestamp of the first frame.

[wjia(left Chromium), 2011/10/29 02:34:40]

removed.

     got_first_frame_ = true;
     start_time_ = buf->timestamp;
   }
 
   frameInfo_.width = buf->width;
   frameInfo_.height = buf->height;
   frameInfo_.rawType = video_type_;
 
-  IncomingFrame(
-      static_cast<WebRtc_UWord8*>(buf->memory_pointer),
-      static_cast<WebRtc_Word32>(buf->buffer_size),
-      frameInfo_,
-      static_cast<WebRtc_Word64>(
-          (buf->timestamp - start_time_).InMicroseconds()));
+  if (buf->width == static_cast<int>(width_) &&

[perkj_chrome, 2011/10/28 08:37:19]

You should never have to care about the frame size. ViE will have to scale
before doing encoding. Just make sure the frameInfo is correct in each frame.

[wjia(left Chromium), 2011/10/29 02:34:40]

reverted the change.

+      buf->height == static_cast<int>(height_)) {
+    IncomingFrame(
+        static_cast<WebRtc_UWord8*>(buf->memory_pointer),
+        static_cast<WebRtc_Word32>(buf->buffer_size),
+        frameInfo_,
+        static_cast<WebRtc_Word64>(
+            (buf->timestamp - start_time_).InMicroseconds()));
+
+  } else {
+    webrtc::VideoFrame out_frame;
+    out_frame.VerifyAndAllocate(CalcBufferSize(webrtc::kI420, width_, height_));
+    if (out_frame.Buffer()) {
+      // TODO(wjia): Use resampling to get larger view field.
+      CopyI420(buf->memory_pointer, buf->stride, buf->height,
+               out_frame.Buffer(), width_, height_);
+      out_frame.SetLength(width_ * height_ * 3 / 2);
+
+      DeliverCapturedFrame(out_frame, width_, height_,
+          static_cast<WebRtc_Word64>(
+              (buf->timestamp - start_time_).InMicroseconds()),
+          frameInfo_.codecType);
+    }
+  }
 
   capture->FeedBuffer(buf);
 }