Pass Client pointer in Initialize() for VDA/VEA

content/common/gpu/media/android_video_encode_accelerator.cc

 // Copyright 2013 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/common/gpu/media/android_video_encode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 15 matching lines @@
 
 namespace content {
 
 enum {
   // Subset of MediaCodecInfo.CodecCapabilities.
   COLOR_FORMAT_YUV420_SEMIPLANAR = 21,
 };
 
 // Helper macros for dealing with failure.  If |result| evaluates false, emit
 // |log| to DLOG(ERROR), register |error| with the client, and return.
-#define RETURN_ON_FAILURE(result, log, error)                 \
-  do {                                                        \
-    if (!(result)) {                                          \
-      DLOG(ERROR) << log;                                     \
-      if (client_ptr_factory_.GetWeakPtr()) {                 \
-        client_ptr_factory_.GetWeakPtr()->NotifyError(error); \
-        client_ptr_factory_.InvalidateWeakPtrs();             \
-      }                                                       \
-      return;                                                 \
-    }                                                         \
+#define RETURN_ON_FAILURE(result, log, error)                  \
+  do {                                                         \
+    if (!(result)) {                                           \
+      DLOG(ERROR) << log;                                      \
+      if (client_ptr_factory_->GetWeakPtr()) {                 \
+        client_ptr_factory_->GetWeakPtr()->NotifyError(error); \
+        client_ptr_factory_.reset();                           \
+      }                                                        \
+      return;                                                  \
+    }                                                          \
   } while (0)
 
 // Because MediaCodec is thread-hostile (must be poked on a single thread) and
 // has no callback mechanism (b/11990118), we must drive it by polling for
 // complete frames (and available input buffers, when the codec is fully
 // saturated).  This function defines the polling delay.  The value used is an
 // arbitrary choice that trades off CPU utilization (spinning) against latency.
 // Mirrors android_video_decode_accelerator.cc::DecodePollDelay().
 static inline const base::TimeDelta EncodePollDelay() {
   // An alternative to this polling scheme could be to dedicate a new thread
   // (instead of using the ChildThread) to run the MediaCodec, and make that
   // thread use the timeout-based flavor of MediaCodec's dequeue methods when it
   // believes the codec should complete "soon" (e.g. waiting for an input
   // buffer, or waiting for a picture when it knows enough complete input
   // pictures have been fed to saturate any internal buffering).  This is
   // speculative and it's unclear that this would be a win (nor that there's a
   // reasonably device-agnostic way to fill in the "believes" above).
   return base::TimeDelta::FromMilliseconds(10);
 }
 
 static inline const base::TimeDelta NoWaitTimeOut() {
   return base::TimeDelta::FromMicroseconds(0);
 }
 
-AndroidVideoEncodeAccelerator::AndroidVideoEncodeAccelerator(
-    media::VideoEncodeAccelerator::Client* client)
-    : client_ptr_factory_(client),
-      num_buffers_at_codec_(0),
+AndroidVideoEncodeAccelerator::AndroidVideoEncodeAccelerator()
+    : num_buffers_at_codec_(0),
       num_output_buffers_(-1),
       output_buffers_capacity_(0),
       last_set_bitrate_(0) {}
 
 AndroidVideoEncodeAccelerator::~AndroidVideoEncodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 // static
 std::vector<media::VideoEncodeAccelerator::SupportedProfile>
@@ skipping 27 matching lines @@
     profile.max_framerate.denominator = 1;
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 void AndroidVideoEncodeAccelerator::Initialize(
     VideoFrame::Format format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
-    uint32 initial_bitrate) {
+    uint32 initial_bitrate,
+    Client* client) {
   DVLOG(3) << __PRETTY_FUNCTION__ << " format: " << format
            << ", input_visible_size: " << input_visible_size.ToString()
            << ", output_profile: " << output_profile
            << ", initial_bitrate: " << initial_bitrate;
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
+
   RETURN_ON_FAILURE(media::MediaCodecBridge::IsAvailable() &&
                         media::MediaCodecBridge::SupportsSetParameters() &&
                         format == VideoFrame::I420 &&
                         output_profile == media::VP8PROFILE_MAIN,
                     "Unexpected combo: " << format << ", " << output_profile,
                     kInvalidArgumentError);
 
   last_set_bitrate_ = initial_bitrate;
 
   // Only consider using MediaCodec if it's likely backed by hardware.
@@ skipping 15 matching lines @@
                                              COLOR_FORMAT_YUV420_SEMIPLANAR));
 
   RETURN_ON_FAILURE(
       media_codec_,
       "Failed to create/start the codec: " << input_visible_size.ToString(),
       kPlatformFailureError);
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::NotifyInitializeDone,
-                 client_ptr_factory_.GetWeakPtr()));
+                 client_ptr_factory_->GetWeakPtr()));
 
   num_output_buffers_ = media_codec_->GetOutputBuffersCount();
   output_buffers_capacity_ = media_codec_->GetOutputBuffersCapacity();
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::RequireBitstreamBuffers,
-                 client_ptr_factory_.GetWeakPtr(),
+                 client_ptr_factory_->GetWeakPtr(),
                  num_output_buffers_,
                  input_visible_size,
                  output_buffers_capacity_));
 }
 
 void AndroidVideoEncodeAccelerator::MaybeStartIOTimer() {
   if (!io_timer_.IsRunning() &&
       (num_buffers_at_codec_ > 0 || !pending_frames_.empty())) {
     io_timer_.Start(FROM_HERE,
                     EncodePollDelay(),
@@ skipping 57 matching lines @@
   }
   // Note: Android's MediaCodec doesn't allow mid-stream adjustments to
   // framerate, so we ignore that here.  This is OK because Android only uses
   // the framerate value from MediaFormat during configure() as a proxy for
   // bitrate, and we set that explicitly.
 }
 
 void AndroidVideoEncodeAccelerator::Destroy() {
   DVLOG(3) << __PRETTY_FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
-  client_ptr_factory_.InvalidateWeakPtrs();
+  client_ptr_factory_.reset();
   if (media_codec_) {
     if (io_timer_.IsRunning())
       io_timer_.Stop();
     media_codec_->Stop();
   }
   delete this;
 }
 
 void AndroidVideoEncodeAccelerator::DoIOTask() {
   QueueInput();
   DequeueOutput();
   MaybeStartIOTimer();
   MaybeStopIOTimer();
 }
 
 void AndroidVideoEncodeAccelerator::QueueInput() {
-  if (!client_ptr_factory_.GetWeakPtr() || pending_frames_.empty())
+  if (!client_ptr_factory_->GetWeakPtr() || pending_frames_.empty())
     return;
 
   int input_buf_index = 0;
   media::MediaCodecStatus status =
       media_codec_->DequeueInputBuffer(NoWaitTimeOut(), &input_buf_index);
   if (status != media::MEDIA_CODEC_OK) {
     DCHECK(status == media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER ||
            status == media::MEDIA_CODEC_ERROR);
     RETURN_ON_FAILURE(status != media::MEDIA_CODEC_ERROR,
                       "MediaCodec error",
@@ skipping 63 matching lines @@
   bool ret = media_codec_->GetOutputBuffers() && count <= num_output_buffers_ &&
              capacity <= output_buffers_capacity_;
   LOG_IF(ERROR, !ret) << "Need more/bigger buffers; before: "
                       << num_output_buffers_ << "x" << output_buffers_capacity_
                       << ", now: " << count << "x" << capacity;
   UMA_HISTOGRAM_BOOLEAN("Media.AVEA.OutputBuffersSuffice", ret);
   return ret;
 }
 
 void AndroidVideoEncodeAccelerator::DequeueOutput() {
-  if (!client_ptr_factory_.GetWeakPtr() ||
+  if (!client_ptr_factory_->GetWeakPtr() ||
       available_bitstream_buffers_.empty() || num_buffers_at_codec_ == 0) {
     return;
   }
 
   int32 buf_index = 0;
   size_t offset = 0;
   size_t size = 0;
   bool key_frame = false;
   do {
     media::MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
@@ skipping 37 matching lines @@
                     kPlatformFailureError);
 
   media_codec_->CopyFromOutputBuffer(buf_index, offset, shm->memory(), size);
   media_codec_->ReleaseOutputBuffer(buf_index, false);
   --num_buffers_at_codec_;
 
   UMA_HISTOGRAM_COUNTS_10000("Media.AVEA.EncodedBufferSizeKB", size / 1024);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::BitstreamBufferReady,
-                 client_ptr_factory_.GetWeakPtr(),
+                 client_ptr_factory_->GetWeakPtr(),
                  bitstream_buffer.id(),
                  size,
                  key_frame));
 }
 
 }  // namespace content