Move NV21 colorspace treatment from VideoCapture java to C++

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"
@@ skipping 121 matching lines @@
   // The pool of shared-memory buffers used for capturing.
   scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
 
   // Chopped pixels in width/height in case video capture device has odd
   // numbers for width/height.
   int chopped_width_;
   int chopped_height_;
 
   // Tracks the current frame format.
   media::VideoCaptureCapability frame_info_;
+
+  // For NV21 we have to do color conversion into the intermediate buffer and
+  // from there the rotations. This variable won't be needed after
+  // http://crbug.com/292400
+#if defined(OS_IOS) || defined(OS_ANDROID)
+  scoped_ptr<uint8[]> i420_intermediate_buffer_;
+#endif  // #if defined(OS_IOS) || defined(OS_ANDROID)
 };
 
 VideoCaptureController::VideoCaptureController()
     : state_(VIDEO_CAPTURE_STATE_STARTED),
       weak_ptr_factory_(this) {
   memset(&current_params_, 0, sizeof(current_params_));
 }
 
 VideoCaptureController::VideoCaptureDeviceClient::VideoCaptureDeviceClient(
     const base::WeakPtr<VideoCaptureController>& controller)
@@ skipping 246 matching lines @@
 #else
 void VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz) {
   DCHECK(frame_info_.color == media::PIXEL_FORMAT_I420 ||
          frame_info_.color == media::PIXEL_FORMAT_YV12 ||
+         frame_info_.color == media::PIXEL_FORMAT_NV21 ||
          (rotation == 0 && !flip_vert && !flip_horiz));
 
   TRACE_EVENT0("video", "VideoCaptureController::OnIncomingCapturedFrame");
 
   if (!buffer_pool_)
     return;
   scoped_refptr<media::VideoFrame> dst =
       buffer_pool_->ReserveI420VideoFrame(gfx::Size(frame_info_.width,
                                                     frame_info_.height),
                                           rotation);
@@ skipping 14 matching lines @@
       RotatePackedYV12Frame(
           data, yplane, uplane, vplane, frame_info_.width, frame_info_.height,
           rotation, flip_vert, flip_horiz);
       break;
     case media::PIXEL_FORMAT_YV12:
       DCHECK(!chopped_width_ && !chopped_height_);
       RotatePackedYV12Frame(
           data, yplane, vplane, uplane, frame_info_.width, frame_info_.height,
           rotation, flip_vert, flip_horiz);
       break;
-    case media::PIXEL_FORMAT_NV21:
+    case media::PIXEL_FORMAT_NV21: {
       DCHECK(!chopped_width_ && !chopped_height_);
-      media::ConvertNV21ToYUV(data, yplane, uplane, vplane, frame_info_.width,
+      int num_pixels = frame_info_.width * frame_info_.height;
+      media::ConvertNV21ToYUV(data,
+                              &i420_intermediate_buffer_[0],
+                              &i420_intermediate_buffer_[num_pixels],
+                              &i420_intermediate_buffer_[num_pixels * 5 / 4],
+                              frame_info_.width,
                               frame_info_.height);
-      break;
+      RotatePackedYV12Frame(
+          i420_intermediate_buffer_.get(), yplane, uplane, vplane,
+          frame_info_.width, frame_info_.height,
+          rotation, flip_vert, flip_horiz);
+       break;
+    }
     case media::PIXEL_FORMAT_YUY2:
       DCHECK(!chopped_width_ && !chopped_height_);
       if (frame_info_.width * frame_info_.height * 2 != length) {
         // If |length| of |data| does not match the expected width and height
         // we can't convert the frame to I420. YUY2 is 2 bytes per pixel.
         break;
       }
 
       media::ConvertYUY2ToYUV(data, yplane, uplane, vplane, frame_info_.width,
                               frame_info_.height);
@@ skipping 22 matching lines @@
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
                  controller_, dst, timestamp));
 }
 #endif  // #if !defined(OS_IOS) && !defined(OS_ANDROID)
 
 void
 VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     base::Time timestamp) {
-
   if (!buffer_pool_)
     return;
 
   // If this is a frame that belongs to the buffer pool, we can forward it
   // directly to the IO thread and be done.
   if (buffer_pool_->RecognizeReservedBuffer(
       frame->shared_memory_handle()) >= 0) {
     BrowserThread::PostTask(BrowserThread::IO,
         FROM_HERE,
         base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
@@ skipping 112 matching lines @@
     chopped_width_ = 1;
   } else {
     chopped_width_ = 0;
   }
   if (info.height & 1) {
     --frame_info_.height;
     chopped_height_ = 1;
   } else {
     chopped_height_ = 0;
   }
+#if defined(OS_IOS) || defined(OS_ANDROID)
+  if (frame_info_.color == media::PIXEL_FORMAT_NV21 &&
+      !i420_intermediate_buffer_) {
+    i420_intermediate_buffer_.reset(
+        new uint8[frame_info_.width * frame_info_.height * 12 / 8]);
+  }
+#endif  // #if defined(OS_IOS) || defined(OS_ANDROID)
 
   DCHECK(!buffer_pool_.get());
 
   // TODO(nick): Give BufferPool the same lifetime as the controller, have it
   // support frame size changes, and stop checking it for NULL everywhere.
   // http://crbug.com/266082
   buffer_pool_ = new VideoCaptureBufferPool(
       media::VideoFrame::AllocationSize(
             media::VideoFrame::I420,
             gfx::Size(frame_info_.width, frame_info_.height)),
@@ skipping 155 matching lines @@
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return controller_clients_.size();
 }
 
 }  // namespace content