Hook up EncodedVideoSource on the browser side

media/video/capture/fake_video_capture_device.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 "media/video/capture/fake_video_capture_device.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/audio/fake_audio_input_stream.h"
+#include "media/base/encoded_bitstream_buffer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 
 namespace media {
 
-static const int kFakeCaptureTimeoutMs = 50;
-static const int kFakeCaptureBeepCycle = 20;  // Visual beep every 1s.
+namespace {

[Ami GONE FROM CHROMIUM, 2013/06/18 18:35:55]

not adding value

[sheu, 2013/08/22 22:40:31]

Fine :-P

+
+const int kFakeCaptureTimeoutMs = 50;
+const int kFakeCaptureBeepCycle = 20;  // Visual beep every 1s.
 enum { kNumberOfFakeDevices = 2 };
 
+}  // anonymous namespace
+
 bool FakeVideoCaptureDevice::fail_next_create_ = false;
 
-void FakeVideoCaptureDevice::GetDeviceNames(Names* const device_names) {
+void FakeVideoCaptureDevice::GetDeviceNames(Names* const device_names,
+                                            bool encoded_capture) {
   // Empty the name list.
   device_names->erase(device_names->begin(), device_names->end());
 
   for (int n = 0; n < kNumberOfFakeDevices; n++) {
     Name name;
     name.unique_id = base::StringPrintf("/dev/video%d", n);
-    name.device_name = base::StringPrintf("fake_device_%d", n);
+    name.device_name = base::StringPrintf(
+        "fake_%sdevice_%d",
+        (encoded_capture ? "encoded_" : ""),
+        n);
     device_names->push_back(name);
   }
 }
 
-VideoCaptureDevice* FakeVideoCaptureDevice::Create(const Name& device_name) {
+VideoCaptureDevice* FakeVideoCaptureDevice::Create(const Name& device_name,
+                                                   bool encoded_capture) {
   if (fail_next_create_) {
     fail_next_create_ = false;
     return NULL;
   }
   for (int n = 0; n < kNumberOfFakeDevices; ++n) {
     std::string possible_id = base::StringPrintf("/dev/video%d", n);
     if (device_name.unique_id.compare(possible_id) == 0) {
-      return new FakeVideoCaptureDevice(device_name);
+      return new FakeVideoCaptureDevice(device_name, encoded_capture);
     }
   }
   return NULL;
 }
 
 void FakeVideoCaptureDevice::SetFailNextCreate() {
   fail_next_create_ = true;
 }
 
-FakeVideoCaptureDevice::FakeVideoCaptureDevice(const Name& device_name)
+FakeVideoCaptureDevice::FakeVideoCaptureDevice(const Name& device_name,
+                                               bool encoded_capture)
     : device_name_(device_name),
+      encoded_capture_(encoded_capture),
       observer_(NULL),
       state_(kIdle),
       capture_thread_("CaptureThread"),
       frame_size_(0),
       frame_count_(0),
       frame_width_(0),
       frame_height_(0) {
 }
 
 FakeVideoCaptureDevice::~FakeVideoCaptureDevice() {
   // Check if the thread is running.
   // This means that the device have not been DeAllocated properly.
   DCHECK(!capture_thread_.IsRunning());
 }
 
+VideoEncodingCapabilities FakeVideoCaptureDevice::GetEncodingCapabilities() {
+  media::VideoEncodingCapabilities capabilities;
+  if (encoded_capture_) {
+    media::VideoEncodingConfig config;
+    config.codec_type = kCodecVP8;
+    config.codec_name = "VP8";
+    config.max_resolution.SetSize(640, 480);
+    config.max_frames_per_second = 30;
+    config.max_bitrate = 1024 * 1024;
+    capabilities.push_back(config);
+  }
+  return capabilities;
+}
+
+void FakeVideoCaptureDevice::TryConfigureEncodedBitstream(
+    const RuntimeVideoEncodingParameters& params) {
+  DCHECK(encoded_capture_);
+  DCHECK(observer_);
+  observer_->OnBitstreamConfigChanged(params);
+}
+
 void FakeVideoCaptureDevice::Allocate(int width,
-                                       int height,
-                                       int frame_rate,
-                                       EventHandler* observer) {
+                                      int height,
+                                      int frame_rate,
+                                      EventHandler* observer) {
   if (state_ != kIdle) {
     return;  // Wrong state.
   }
 
+  DCHECK(!observer_);
   observer_ = observer;
-  VideoCaptureCapability current_settings;
-  current_settings.color = VideoCaptureCapability::kI420;
-  current_settings.expected_capture_delay = 0;
-  current_settings.interlaced = false;
-  if (width > 320) {  // VGA
-    current_settings.width = 640;
-    current_settings.height = 480;
-    current_settings.frame_rate = 30;
-  } else {  // QVGA
-    current_settings.width = 320;
-    current_settings.height = 240;
-    current_settings.frame_rate = 30;
+  state_ = kAllocated;
+
+  if (encoded_capture_) {
+    media::VideoEncodingParameters params;
+    params.codec_name = std::string("VP8");
+    params.resolution.SetSize(640, 480);
+    params.runtime_params.target_bitrate = 512;
+    params.runtime_params.max_bitrate = 1024;
+    params.runtime_params.frames_per_second = 30;
+    observer_->OnEncodedFrameInfo(params);
+  } else {
+    VideoCaptureCapability current_settings;
+    current_settings.color = VideoCaptureCapability::kI420;
+    current_settings.expected_capture_delay = 0;
+    current_settings.interlaced = false;
+    if (width > 320) {  // VGA
+      current_settings.width = 640;
+      current_settings.height = 480;
+      current_settings.frame_rate = 30;
+    } else {  // QVGA
+      current_settings.width = 320;
+      current_settings.height = 240;
+      current_settings.frame_rate = 30;
+    }
+
+    size_t fake_frame_size =
+        current_settings.width * current_settings.height * 3 / 2;
+    fake_frame_.reset(new uint8[fake_frame_size]);
+    memset(fake_frame_.get(), 0, fake_frame_size);
+    frame_size_ = fake_frame_size;
+    frame_width_ = current_settings.width;
+    frame_height_ = current_settings.height;
+    observer_->OnFrameInfo(current_settings);
   }
-
-  size_t fake_frame_size =
-      current_settings.width * current_settings.height * 3 / 2;
-  fake_frame_.reset(new uint8[fake_frame_size]);
-  memset(fake_frame_.get(), 0, fake_frame_size);
-  frame_size_ = fake_frame_size;
-  frame_width_ = current_settings.width;
-  frame_height_ = current_settings.height;
-
-  state_ = kAllocated;
-  observer_->OnFrameInfo(current_settings);
 }
 
 void FakeVideoCaptureDevice::Start() {
   if (state_ != kAllocated) {
       return;  // Wrong state.
   }
   state_ = kCapturing;
   capture_thread_.Start();
   capture_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&FakeVideoCaptureDevice::OnCaptureTask,
                  base::Unretained(this)));
 }
 
 void FakeVideoCaptureDevice::Stop() {
   if (state_ != kCapturing) {
       return;  // Wrong state.
   }
   capture_thread_.Stop();
   state_ = kAllocated;
 }
 
 void FakeVideoCaptureDevice::DeAllocate() {
   if (state_ != kAllocated && state_ != kCapturing) {
       return;  // Wrong state.
   }
   capture_thread_.Stop();
   state_ = kIdle;
+  observer_ = NULL;
 }
 
 const VideoCaptureDevice::Name& FakeVideoCaptureDevice::device_name() {
   return device_name_;
 }
 
 void FakeVideoCaptureDevice::OnCaptureTask() {
   if (state_ != kCapturing) {
     return;
   }
 
   memset(fake_frame_.get(), 0, frame_size_);

[Ami GONE FROM CHROMIUM, 2013/06/18 18:35:55]

only used in the not-encoding case

[sheu, 2013/08/22 22:40:31]

Also used for encoding.  Changed up a bit here.

 
-  SkBitmap bitmap;
-  bitmap.setConfig(SkBitmap::kA8_Config, frame_width_, frame_height_,
-                   frame_width_);
-  bitmap.setPixels(fake_frame_.get());
+  if (encoded_capture_) {
+    // Just return empty frames.
+    scoped_refptr<media::EncodedBitstreamBuffer> buffer =
+        observer_->ReserveOutputEncodedBitstreamBuffer();
+    if (buffer) {
+      observer_->OnIncomingCapturedEncodedBitstreamBuffer(
+         buffer,
+         0,
+         base::Time::Now());
+    }
+  } else {
+    SkBitmap bitmap;
+    bitmap.setConfig(SkBitmap::kA8_Config, frame_width_, frame_height_,
+                     frame_width_);
+    bitmap.setPixels(fake_frame_.get());
 
-  SkCanvas canvas(bitmap);
+    SkCanvas canvas(bitmap);
 
-  // Draw a sweeping circle to show an animation.
-  int radius = std::min(frame_width_, frame_height_) / 4;
-  SkRect rect = SkRect::MakeXYWH(
-      frame_width_ / 2 - radius, frame_height_ / 2 - radius,
-      2 * radius, 2 * radius);
+    // Draw a sweeping circle to show an animation.
+    int radius = std::min(frame_width_, frame_height_) / 4;
+    SkRect rect = SkRect::MakeXYWH(
+        frame_width_ / 2 - radius, frame_height_ / 2 - radius,
+        2 * radius, 2 * radius);
 
-  SkPaint paint;
-  paint.setStyle(SkPaint::kFill_Style);
+    SkPaint paint;
+    paint.setStyle(SkPaint::kFill_Style);
 
-  // Only Y plane is being drawn and this gives 50% grey on the Y
-  // plane. The result is a light green color in RGB space.
-  paint.setAlpha(128);
+    // Only Y plane is being drawn and this gives 50% grey on the Y
+    // plane. The result is a light green color in RGB space.
+    paint.setAlpha(128);
 
-  int end_angle = (frame_count_ % kFakeCaptureBeepCycle * 360) /
-      kFakeCaptureBeepCycle;
-  if (!end_angle)
-    end_angle = 360;
-  canvas.drawArc(rect, 0, end_angle, true, paint);
+    int end_angle = (frame_count_ % kFakeCaptureBeepCycle * 360) /
+        kFakeCaptureBeepCycle;
+    if (!end_angle)
+      end_angle = 360;
+    canvas.drawArc(rect, 0, end_angle, true, paint);
 
-  // Draw current time.
-  int elapsed_ms = kFakeCaptureTimeoutMs * frame_count_;
-  int milliseconds = elapsed_ms % 1000;
-  int seconds = (elapsed_ms / 1000) % 60;
-  int minutes = (elapsed_ms / 1000 / 60) % 60;
-  int hours = (elapsed_ms / 1000 / 60 / 60) % 60;
+    // Draw current time.
+    int elapsed_ms = kFakeCaptureTimeoutMs * frame_count_;
+    int milliseconds = elapsed_ms % 1000;
+    int seconds = (elapsed_ms / 1000) % 60;
+    int minutes = (elapsed_ms / 1000 / 60) % 60;
+    int hours = (elapsed_ms / 1000 / 60 / 60) % 60;
 
-  std::string time_string =
-      base::StringPrintf("%d:%02d:%02d:%03d %d", hours, minutes,
-                         seconds, milliseconds, frame_count_);
-  canvas.scale(3, 3);
-  canvas.drawText(time_string.data(), time_string.length(), 30, 20,
-                  paint);
+    std::string time_string =
+        base::StringPrintf("%d:%02d:%02d:%03d %d", hours, minutes,
+                           seconds, milliseconds, frame_count_);
+    canvas.scale(3, 3);
+    canvas.drawText(time_string.data(), time_string.length(), 30, 20,
+                    paint);
 
-  if (frame_count_ % kFakeCaptureBeepCycle == 0) {
-    // Generate a synchronized beep sound if there is one audio input
-    // stream created.
-    FakeAudioInputStream::BeepOnce();
- }
+    if (frame_count_ % kFakeCaptureBeepCycle == 0) {
+      // Generate a synchronized beep sound if there is one audio input
+      // stream created.
+      FakeAudioInputStream::BeepOnce();
+   }
 
-  frame_count_++;
+    frame_count_++;
 
-  // Give the captured frame to the observer.
-  observer_->OnIncomingCapturedFrame(
-      fake_frame_.get(), frame_size_, base::Time::Now(), 0, false, false);
+    // Give the captured frame to the observer.
+    observer_->OnIncomingCapturedFrame(
+        fake_frame_.get(), frame_size_, base::Time::Now(), 0, false, false);
+  }
+
   // Reschedule next CaptureTask.
   capture_thread_.message_loop()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeVideoCaptureDevice::OnCaptureTask,
                    base::Unretained(this)),
         base::TimeDelta::FromMilliseconds(kFakeCaptureTimeoutMs));
 }
 
 }  // namespace media