VideoCapturerDelegate: Retrieve supported/in-use format(s) for constraint negotiation

content/renderer/media/media_stream_video_capturer_source.cc

 // Copyright 2014 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/media_stream_video_capturer_source.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/video_frame.h"
 
 namespace {
 
 struct SourceVideoFormat {
   int width;
   int height;
   int frame_rate;
 };
 
 // List of formats used if the source doesn't support capability enumeration.
 const SourceVideoFormat kVideoFormats[] = {
     {1920, 1080, 30},

[tommi (sloooow) - chröme, 2014/03/13 17:19:38]

nit: can you un-indent these by 2 spaces?

[mcasas, 2014/03/14 08:06:39]

Done.

     {1280, 720, 30},
     {960, 720, 30},
     {640, 480, 30},
     {640, 360, 30},
     {320, 240, 30},
     {320, 180, 30}
 };
 
 }  // namespace
 
@@ skipping 33 matching lines @@
         max_requested_height : MediaStreamVideoSource::kDefaultHeight;
     formats.push_back(
           media::VideoCaptureFormat(
               gfx::Size(width, height),
               MediaStreamVideoSource::kDefaultFrameRate,
               media::PIXEL_FORMAT_I420));
     callback.Run(formats);
     return;
   }
 
-  // This delegate implementation doesn't support capability enumeration.
-  // We need to guess what it supports.
-  media::VideoCaptureFormats formats;
-  for (size_t i = 0; i < arraysize(kVideoFormats); ++i) {
-    formats.push_back(
-        media::VideoCaptureFormat(
-            gfx::Size(kVideoFormats[i].width,
-                      kVideoFormats[i].height),
-            kVideoFormats[i].frame_rate,
-            media::PIXEL_FORMAT_I420));
-  }
-  callback.Run(formats);
+  DCHECK(source_formats_callback_.is_null());
+  source_formats_callback_ = callback;
+  capture_engine_->GetDeviceFormatsInUse(base::Bind(
+      &VideoCapturerDelegate::OnDeviceFormatsInUseReceived, this));
 }
 
 void VideoCapturerDelegate::StartDeliver(
     const media::VideoCaptureParams& params,
     const NewFrameCallback& new_frame_callback,
     const StartedCallback& started_callback) {
   DCHECK(params.requested_format.IsValid());
   message_loop_proxy_ = base::MessageLoopProxy::current();
   new_frame_callback_ = new_frame_callback;
   started_callback_ = started_callback;
   got_first_frame_ = false;
 
   // Increase the reference count to ensure the object is not deleted until
   // it is unregistered in VideoCapturerDelegate::OnRemoved.
   AddRef();
   capture_engine_->StartCapture(this, params);
 }
 
 void VideoCapturerDelegate::StopDeliver() {
   // Immediately make sure we don't provide more frames.
   DVLOG(3) << "VideoCapturerDelegate::StopCapture()";
   DCHECK(message_loop_proxy_ == base::MessageLoopProxy::current());
   capture_engine_->StopCapture(this);
   new_frame_callback_.Reset();
   started_callback_.Reset();
+  source_formats_callback_.Reset();
 }
 
 void VideoCapturerDelegate::OnStarted(media::VideoCapture* capture) {
   DVLOG(3) << "VideoCapturerDelegate::OnStarted";
 }
 
 void VideoCapturerDelegate::OnStopped(media::VideoCapture* capture) {
 }
 
 void VideoCapturerDelegate::OnPaused(media::VideoCapture* capture) {
@@ skipping 41 matching lines @@
     new_frame_callback_.Run(frame);
   }
 }
 
 void VideoCapturerDelegate::OnErrorOnCaptureThread(
     media::VideoCapture* capture) {
   if (!started_callback_.is_null())
     started_callback_.Run(false);
 }
 
+void VideoCapturerDelegate::OnDeviceFormatsInUseReceived(
+    const media::VideoCaptureFormats& formats_in_use) {
+  DVLOG(3) << "OnDeviceFormatsInUseReceived: " << formats_in_use.size();
+  if (!formats_in_use.empty()) {
+    if (!source_formats_callback_.is_null())
+      source_formats_callback_.Run(formats_in_use);
+  } else {
+    DCHECK(!source_formats_callback_.is_null());
+    // If there are no formats in use, try to retrieve the whole list of them.
+    capture_engine_->GetDeviceSupportedFormats(base::Bind(
+        &VideoCapturerDelegate::OnDeviceSupportedFormatsEnumerated, this));
+  }
+}
+
+void VideoCapturerDelegate::OnDeviceSupportedFormatsEnumerated(
+    const media::VideoCaptureFormats& formats) {
+  DVLOG(3) << "OnDeviceSupportedFormatsEnumerated: " << formats.size()
+           << " received";
+  if (formats.size()) {
+    if (!source_formats_callback_.is_null())
+      source_formats_callback_.Run(formats);
+  } else {
+    // The capture device doesn't seem to support capability enumeration,
+    // compose a fallback list of capabilities.
+    media::VideoCaptureFormats default_formats;
+    for (size_t i = 0; i < arraysize(kVideoFormats); ++i) {
+      default_formats.push_back(media::VideoCaptureFormat(
+          gfx::Size(kVideoFormats[i].width, kVideoFormats[i].height),
+          kVideoFormats[i].frame_rate,
+          media::PIXEL_FORMAT_I420));
+    }
+    if (!source_formats_callback_.is_null())
+      source_formats_callback_.Run(default_formats);

[tommi (sloooow) - chröme, 2014/03/13 17:19:38]

whenever we call source_formats_callback_.Run(), should we call
source_formats_callback_.Reset() or is it OK to call
source_formats_callback_.Run() more than once in some situation?

[mcasas, 2014/03/14 08:06:39]

There should only be one call back, so Reset() is fine.

+  }
+}
+
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
     const StreamDeviceInfo& device_info,
     const SourceStoppedCallback& stop_callback,
     const scoped_refptr<VideoCapturerDelegate>& delegate,
     MediaStreamDependencyFactory* factory)
     : MediaStreamVideoSource(factory),
       delegate_(delegate) {
   SetDeviceInfo(device_info);
   SetStopCallback(stop_callback);
 }
@@ skipping 19 matching lines @@
                  base::Unretained(this)),
       base::Bind(&MediaStreamVideoCapturerSource::OnStartDone,
                  base::Unretained(this)));
 }
 
 void MediaStreamVideoCapturerSource::StopSourceImpl() {
   delegate_->StopDeliver();
 }
 
 }  // namespace content