Media Capture Depth Stream Extensions API: focal length and depth range.

content/browser/renderer_host/media/video_capture_manager.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_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 1007 matching lines @@
 
   // Walk the |devices_info_cache_| and produce a
   // media::VideoCaptureDeviceDescriptors for return purposes.
   media::VideoCaptureDeviceDescriptors devices;
   std::vector<std::tuple<media::VideoCaptureDeviceDescriptor,
                          media::VideoCaptureFormats>>
       descriptors_and_formats;
   for (const auto& it : devices_info_cache_) {
     devices.emplace_back(it.descriptor);
     descriptors_and_formats.emplace_back(it.descriptor, it.supported_formats);
+  }
+
+  if (!descriptors_and_formats.empty()) {
     MediaInternals::GetInstance()->UpdateVideoCaptureDeviceCapabilities(
         descriptors_and_formats);
   }
 
   client_callback.Run(devices);
 }
 
 bool VideoCaptureManager::IsOnDeviceThread() const {
   return device_task_runner_->BelongsToCurrentThread();
 }
@@ skipping 182 matching lines @@
     VideoCaptureDevice::TakePhotoCallback callback,
     VideoCaptureDevice* device) {
   // Unretained() is safe to use here because |device| would be null if it
   // was scheduled for shutdown and destruction, and because this task is
   // guaranteed to run before the task that destroys the |device|.
   device_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureDevice::TakePhoto,
                             base::Unretained(device), base::Passed(&callback)));
 }
 
+bool VideoCaptureManager::GetCameraCalibration(
+    const std::string& device_id,
+    MediaStreamDevice::CameraCalibration* calibration) {
+  VideoCaptureManager::DeviceInfo* info = GetDeviceInfoById(device_id);
+  if (!info || !info->descriptor.camera_calibration)
+    return false;
+  calibration->valid = true;
+  calibration->focal_length_x =
+      info->descriptor.camera_calibration->focal_length_x;
+  calibration->focal_length_y =
+      info->descriptor.camera_calibration->focal_length_y;
+  calibration->depth_near = info->descriptor.camera_calibration->depth_near;
+  calibration->depth_far = info->descriptor.camera_calibration->depth_far;
+  return true;
+}
+
 #if defined(OS_ANDROID)
 void VideoCaptureManager::OnApplicationStateChange(
     base::android::ApplicationState state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Only release/resume devices when the Application state changes from
   // RUNNING->STOPPED->RUNNING.
   if (state == base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES &&
       !application_state_has_running_activities_) {
     ResumeDevices();
@@ skipping 38 matching lines @@
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, entry.get(), entry->parameters);
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content