Reland: Reorganize media::VideoCapture* types

media/video/capture/android/video_capture_device_android.cc

 // Copyright (c) 2013 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/android/video_capture_device_android.h"
 
 #include <string>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 68 matching lines @@
     return ret.release();
   return NULL;
 }
 
 // static
 bool VideoCaptureDeviceAndroid::RegisterVideoCaptureDevice(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VideoCaptureDeviceAndroid::VideoCaptureDeviceAndroid(const Name& device_name)
-    : state_(kIdle),
-      got_first_frame_(false),
-      device_name_(device_name),
-      current_settings_() {
-}
+    : state_(kIdle), got_first_frame_(false), device_name_(device_name) {}
 
 VideoCaptureDeviceAndroid::~VideoCaptureDeviceAndroid() {
   StopAndDeAllocate();
 }
 
 bool VideoCaptureDeviceAndroid::Init() {
   int id;
   if (!base::StringToInt(device_name_.id(), &id))
     return false;
 
   JNIEnv* env = AttachCurrentThread();
 
   j_capture_.Reset(Java_VideoCapture_createVideoCapture(
       env, base::android::GetApplicationContext(), id,
       reinterpret_cast<intptr_t>(this)));
 
   return true;
 }
 
 void VideoCaptureDeviceAndroid::AllocateAndStart(
-    const VideoCaptureCapability& capture_format,
+    const VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   DVLOG(1) << "VideoCaptureDeviceAndroid::AllocateAndStart";
   {
     base::AutoLock lock(lock_);
     if (state_ != kIdle)
       return;
     client_ = client.Pass();
     got_first_frame_ = false;
   }
 
   JNIEnv* env = AttachCurrentThread();
 
-  jboolean ret = Java_VideoCapture_allocate(env,
-                                            j_capture_.obj(),
-                                            capture_format.width,
-                                            capture_format.height,
-                                            capture_format.frame_rate);
+  jboolean ret =
+      Java_VideoCapture_allocate(env,
+                                 j_capture_.obj(),
+                                 params.requested_format.frame_size.width(),
+                                 params.requested_format.frame_size.height(),
+                                 params.requested_format.frame_rate);
   if (!ret) {
     SetErrorState("failed to allocate");
     return;
   }
 
   // Store current width and height.
-  current_settings_.width =
-      Java_VideoCapture_queryWidth(env, j_capture_.obj());
-  current_settings_.height =
-      Java_VideoCapture_queryHeight(env, j_capture_.obj());
-  current_settings_.frame_rate =
+  capture_format_.frame_size.SetSize(
+      Java_VideoCapture_queryWidth(env, j_capture_.obj()),
+      Java_VideoCapture_queryHeight(env, j_capture_.obj()));
+  capture_format_.frame_rate =
       Java_VideoCapture_queryFrameRate(env, j_capture_.obj());
-  current_settings_.color = GetColorspace();
-  DCHECK_NE(current_settings_.color, media::PIXEL_FORMAT_UNKNOWN);
-  CHECK(current_settings_.width > 0 && !(current_settings_.width % 2));
-  CHECK(current_settings_.height > 0 && !(current_settings_.height % 2));
+  capture_format_.pixel_format = GetColorspace();
+  DCHECK_NE(capture_format_.pixel_format, media::PIXEL_FORMAT_UNKNOWN);
+  CHECK(capture_format_.frame_size.GetArea() > 0);
+  CHECK(!(capture_format_.frame_size.width() % 2));
+  CHECK(!(capture_format_.frame_size.height() % 2));
 
-  if (capture_format.frame_rate > 0) {
+  if (capture_format_.frame_rate > 0) {
     frame_interval_ = base::TimeDelta::FromMicroseconds(
-        (base::Time::kMicrosecondsPerSecond + capture_format.frame_rate - 1) /
-        capture_format.frame_rate);
+        (base::Time::kMicrosecondsPerSecond + capture_format_.frame_rate - 1) /
+        capture_format_.frame_rate);
   }
 
-  DVLOG(1) << "VideoCaptureDeviceAndroid::Allocate: queried width="
-           << current_settings_.width
-           << ", height="
-           << current_settings_.height
-           << ", frame_rate="
-           << current_settings_.frame_rate;
+  DVLOG(1) << "VideoCaptureDeviceAndroid::Allocate: queried frame_size="
+           << capture_format_.frame_size.ToString()
+           << ", frame_rate=" << capture_format_.frame_rate;
 
   jint result = Java_VideoCapture_startCapture(env, j_capture_.obj());
   if (result < 0) {
     SetErrorState("failed to start capture");
     return;
   }
 
   {
     base::AutoLock lock(lock_);
     state_ = kCapturing;
@@ skipping 56 matching lines @@
   // Deliver the frame when it doesn't arrive too early.
   if (expected_next_frame_time_ <= current_time) {
     expected_next_frame_time_ += frame_interval_;
 
     client_->OnIncomingCapturedFrame(reinterpret_cast<uint8*>(buffer),
                                      length,
                                      base::Time::Now(),
                                      rotation,
                                      flip_vert,
                                      flip_horiz,
-                                     current_settings_);
+                                     capture_format_);
   }
 
   env->ReleaseByteArrayElements(data, buffer, JNI_ABORT);
 }
 
 VideoPixelFormat VideoCaptureDeviceAndroid::GetColorspace() {
   JNIEnv* env = AttachCurrentThread();
   int current_capture_colorspace =
       Java_VideoCapture_getColorspace(env, j_capture_.obj());
   switch (current_capture_colorspace){
@@ skipping 16 matching lines @@
 void VideoCaptureDeviceAndroid::SetErrorState(const std::string& reason) {
   LOG(ERROR) << "VideoCaptureDeviceAndroid::SetErrorState: " << reason;
   {
     base::AutoLock lock(lock_);
     state_ = kError;
   }
   client_->OnError();
 }
 
 }  // namespace media