Adds fake hardware video encoder.

media/video/fake_video_encode_accelerator.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 "media/cast/test/fake_video_encode_accelerator.h"
+#include "media/video/fake_video_encode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
 
 namespace media {
-namespace cast {
-namespace test {
 
 static const unsigned int kMinimumInputCount = 1;
 static const size_t kMinimumOutputBufferSize = 123456;
 
 FakeVideoEncodeAccelerator::FakeVideoEncodeAccelerator(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    std::vector<uint32>* stored_bitrates)
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
-      stored_bitrates_(stored_bitrates),
+      will_initialization_succeed_(true),
       client_(NULL),
       first_(true),
-      will_initialization_succeed_(true),
-      weak_this_factory_(this) {
-  DCHECK(stored_bitrates_);
-}
+      weak_this_factory_(this) {}
 
 FakeVideoEncodeAccelerator::~FakeVideoEncodeAccelerator() {
   weak_this_factory_.InvalidateWeakPtrs();
 }
 
 std::vector<VideoEncodeAccelerator::SupportedProfile>
 FakeVideoEncodeAccelerator::GetSupportedProfiles() {
   return std::vector<VideoEncodeAccelerator::SupportedProfile>();
 }
 
 bool FakeVideoEncodeAccelerator::Initialize(
-    media::VideoFrame::Format input_format,
+    VideoFrame::Format input_format,
     const gfx::Size& input_visible_size,
     VideoCodecProfile output_profile,
     uint32 initial_bitrate,
     Client* client) {
-  if (!will_initialization_succeed_)
-    return false;
-  client_ = client;
-  if (output_profile != media::VP8PROFILE_ANY &&
-      output_profile != media::H264PROFILE_MAIN) {
+  if (!will_initialization_succeed_) {
     return false;
   }
+  if (output_profile == VIDEO_CODEC_PROFILE_UNKNOWN ||
+      output_profile > VIDEO_CODEC_PROFILE_MAX) {
+    return false;
+  }
+  client_ = client;
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeVideoEncodeAccelerator::DoRequireBitstreamBuffers,
                  weak_this_factory_.GetWeakPtr(),
                  kMinimumInputCount,
                  input_visible_size,
                  kMinimumOutputBufferSize));
   return true;
 }
 
-void FakeVideoEncodeAccelerator::Encode(const scoped_refptr<VideoFrame>& frame,
-                                        bool force_keyframe) {
+void FakeVideoEncodeAccelerator::Encode(
+    const scoped_refptr<VideoFrame>& frame,
+    bool force_keyframe) {
   DCHECK(client_);
-  DCHECK(!available_buffer_ids_.empty());
-
-  // Fake that we have encoded the frame; resulting in using the full output
-  // buffer.
-  int32 id = available_buffer_ids_.front();
-  available_buffer_ids_.pop_front();
-
-  bool is_key_fame = force_keyframe;
-  if (first_) {
-    is_key_fame = true;
-    first_ = false;
-  }
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&FakeVideoEncodeAccelerator::DoBitstreamBufferReady,
-                 weak_this_factory_.GetWeakPtr(),
-                 id,
-                 kMinimumOutputBufferSize,
-                 is_key_fame));
+  queued_frames_.push(force_keyframe);
+  EncodeTask();
 }
 
 void FakeVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const BitstreamBuffer& buffer) {
-  available_buffer_ids_.push_back(buffer.id());
+  available_buffers_.push_back(buffer);
+  EncodeTask();
 }
 
 void FakeVideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32 bitrate,
     uint32 framerate) {
-  stored_bitrates_->push_back(bitrate);
+  stored_bitrates_.push_back(bitrate);
 }
 
 void FakeVideoEncodeAccelerator::Destroy() { delete this; }
 
 void FakeVideoEncodeAccelerator::SendDummyFrameForTesting(bool key_frame) {
-  DoBitstreamBufferReady(0, 23, key_frame);
+  queued_frames_.push(key_frame);
+  EncodeTask();

[wuchengli, 2014/12/16 02:21:48]

This should call DoBitstreamBufferReady to have the same behavior as before.
Otherwise |available_buffers_| may be empty and the frame may not be sent.

[hellner1, 2014/12/16 20:14:08]

What should I use for |bitstream_buffer_id| if there are no available buffers?

[wuchengli, 2014/12/17 03:21:22]

You are right. The original FakeVideoEncodeAccelerator::SendDummyFrameForTesting
didn't even pop |available_buffers_| and use id 0 directly. It was a potential
issue. But another problem is cast unittests intent to force a non keyframe
using SendDummyFrameForTesting.
https://code.google.com/p/chromium/codesearch#chromium/src/media/cast/sender/...
 In the current patchset, , |key_frame| will be overriden by |first_| and won't
be a non keyframe request.

We have several options.
1. Keep the original cast version of SendDummyFrameForTesting and send 0 for
bitstream buffer id. Leave the problem for cast team to fix in the future.

2. Remove |first_| completely. SendDummyFrameForTesting can simply call
Encode(NULL, key_frame) here. You need to check with cast team if cast unittests
really require the first encoded frame to be keyframe.

3. Skip |first_| here.
void FakeVEA::SendDummyFrameForTesting(bool key_frame) {
  DCHECK(available_buffers_.size() > 0);
  int32 bitstream_buffer_id = available_buffers_.front().id();
  available_buffers_.pop_front();
  task_runner_->PostTask(FROM_HERE,    
base::Bind(&FakeVideoEncodeAccelerator::DoBitstreamBufferReady,
      weak_this_factory_.GetWeakPtr(),
      bitstream_buffer_id,
      kMinimumOutputBufferSize,
      key_frame));
}

+}
+
+void FakeVideoEncodeAccelerator::SetWillInitializationSucceed(
+    bool will_initialization_succeed) {
+  will_initialization_succeed_ = will_initialization_succeed;
 }
 
 void FakeVideoEncodeAccelerator::DoRequireBitstreamBuffers(
     unsigned int input_count,
     const gfx::Size& input_coded_size,
     size_t output_buffer_size) const {
   client_->RequireBitstreamBuffers(
       input_count, input_coded_size, output_buffer_size);
 }
 
+void FakeVideoEncodeAccelerator::EncodeTask() {
+  while (!queued_frames_.empty() && !available_buffers_.empty()) {
+    bool force_key_frame = queued_frames_.front();
+    queued_frames_.pop();
+    int32 bitstream_buffer_id = available_buffers_.front().id();
+    available_buffers_.pop_front();
+    bool key_frame = first_ ||  force_key_frame;
+    first_ = false;
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&FakeVideoEncodeAccelerator::DoBitstreamBufferReady,
+                   weak_this_factory_.GetWeakPtr(),
+                   bitstream_buffer_id,
+                   kMinimumOutputBufferSize,
+                   key_frame));
+  }
+}
+
 void FakeVideoEncodeAccelerator::DoBitstreamBufferReady(
     int32 bitstream_buffer_id,
-    size_t payload_size,
-    bool key_frame) const {
-  client_->BitstreamBufferReady(bitstream_buffer_id, payload_size, key_frame);
+    size_t kMinimumOutputBufferSize,

[wuchengli, 2014/12/16 02:21:48]

s/kMinimumOutputBufferSize/payload_size/

[hellner1, 2014/12/16 20:14:08]

Done. Thanks!

+    bool key_frame) {
+  client_->BitstreamBufferReady(bitstream_buffer_id,
+                                kMinimumOutputBufferSize,

[wuchengli, 2014/12/16 02:21:48]

s/kMinimumOutputBufferSize/payload_size/

[hellner1, 2014/12/16 20:14:08]

Done.

+                                key_frame);
 }
 
-}  // namespace test
-}  // namespace cast
 }  // namespace media