Add media::VideoEncodeAccelerator with WebRTC integration

media/filters/gpu_video_decoder.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/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/pipeline.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder_config.h"
-#include "media/filters/gpu_video_decoder_factories.h"
+#include "media/filters/gpu_video_accelerator_factories.h"
 
 namespace media {
 
 // Maximum number of concurrent VDA::Decode() operations GVD will maintain.
 // Higher values allow better pipelining in the GPU, but also require more
 // resources.
 enum { kMaxInFlightDecodes = 4 };
 
 // Size of shared-memory segments we allocate.  Since we reuse them we let them
 // be on the beefy side.
@@ skipping 14 matching lines @@
 
 GpuVideoDecoder::BufferData::BufferData(
     int32 bbid, base::TimeDelta ts, const gfx::Rect& vr, const gfx::Size& ns)
     : bitstream_buffer_id(bbid), timestamp(ts), visible_rect(vr),
       natural_size(ns) {
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
-    const scoped_refptr<GpuVideoDecoderFactories>& factories)
+    const scoped_refptr<GpuVideoAcceleratorFactories>& factories)
     : needs_bitstream_conversion_(false),
       gvd_loop_proxy_(factories->GetMessageLoop()),
       weak_factory_(this),
       factories_(factories),
       state_(kNormal),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       available_pictures_(0) {
   DCHECK(factories_.get());
@@ skipping 100 matching lines @@
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
 
   if (previously_initialized) {
     // Reinitialization with a different config (but same codec and profile).
     // VDA should handle it by detecting this in-stream by itself,
     // no need to notify it.
     status_cb.Run(PIPELINE_OK);
     return;
   }
 
-  vda_.reset(factories_->CreateVideoDecodeAccelerator(config.profile(), this));
+  vda_ =
+      factories_->CreateVideoDecodeAccelerator(config.profile(), this).Pass();
   if (!vda_) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   DVLOG(3) << "GpuVideoDecoder::Initialize() succeeded.";
   status_cb.Run(PIPELINE_OK);
 }
 
 void GpuVideoDecoder::DestroyTextures() {
@@ skipping 241 matching lines @@
           pb.texture_mailbox(),
           0,  // sync_point
           BindToCurrentLoop(base::Bind(&GpuVideoDecoder::ReusePictureBuffer,
                                        weak_this_,
                                        picture.picture_buffer_id()))),
       decoder_texture_target_,
       pb.size(),
       visible_rect,
       natural_size,
       timestamp,
-      base::Bind(&GpuVideoDecoderFactories::ReadPixels,
+      base::Bind(&GpuVideoAcceleratorFactories::ReadPixels,
                  factories_,
                  pb.texture_id(),
                  decoder_texture_target_,
                  gfx::Size(visible_rect.width(), visible_rect.height())),
       base::Closure()));
   CHECK_GT(available_pictures_, 0);
   --available_pictures_;
   bool inserted =
       picture_buffers_at_display_.insert(picture.picture_buffer_id()).second;
   DCHECK(inserted);
@@ skipping 148 matching lines @@
 
   state_ = kError;
 
   if (!pending_decode_cb_.is_null()) {
     base::ResetAndReturn(&pending_decode_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media