Make RendererGpuVideoDecoderFactories live on arbitrary threads.

content/renderer/media/rtc_video_decoder.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/renderer/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 50 matching lines @@
       timestamp(timestamp),
       width(width),
       height(height),
       size(size) {}
 
 RTCVideoDecoder::BufferData::BufferData() {}
 
 RTCVideoDecoder::BufferData::~BufferData() {}
 
 RTCVideoDecoder::RTCVideoDecoder(
+    const scoped_refptr<base::MessageLoopProxy>& vda_loop_proxy,
     const scoped_refptr<media::GpuVideoDecoder::Factories>& factories)
     : weak_factory_(this),
       weak_this_(weak_factory_.GetWeakPtr()),
       factories_(factories),
-      vda_loop_proxy_(factories_->GetMessageLoop()),
-      create_shm_thread_("CreateSHMThread"),
+      vda_loop_proxy_(vda_loop_proxy),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       state_(UNINITIALIZED),
       decode_complete_callback_(NULL),
       num_shm_buffers_(0),
       next_bitstream_buffer_id_(0),
       reset_bitstream_buffer_id_(ID_INVALID) {
-  create_shm_thread_.Start();
-  // Initialize directly if |vda_loop_proxy_| is the renderer thread.
-  base::WaitableEvent compositor_loop_async_waiter(false, false);
-  if (vda_loop_proxy_->BelongsToCurrentThread()) {
-    Initialize(&compositor_loop_async_waiter);
-    return;
-  }
-  // Post the task if |vda_loop_proxy_| is the compositor thread. Waiting here
-  // is safe because the compositor thread will not be stopped until the
-  // renderer thread shuts down.
+  DCHECK(!vda_loop_proxy_->BelongsToCurrentThread());
+  DCHECK_EQ(vda_loop_proxy.get(), factories->GetMessageLoop().get());
+  base::WaitableEvent message_loop_async_waiter(false, false);
+  // Waiting here is safe. The media thread is stopped in the child thread and
+  // the child thread is blocked when VideoDecoderFactory::CreateVideoDecoder
+  // runs.
   vda_loop_proxy_->PostTask(FROM_HERE,
                             base::Bind(&RTCVideoDecoder::Initialize,
                                        base::Unretained(this),
-                                       &compositor_loop_async_waiter));
-  compositor_loop_async_waiter.Wait();
+                                       &message_loop_async_waiter));
+  message_loop_async_waiter.Wait();
 }
 
 RTCVideoDecoder::~RTCVideoDecoder() {
   DVLOG(2) << "~RTCVideoDecoder";
-  factories_->Abort();
-  create_shm_thread_.Stop();
-  // Delete vda and remove |this| from the observer if vda thread is alive.
-  if (vda_loop_proxy_->BelongsToCurrentThread()) {
+  // Remove |this| from the observer if vda thread is alive.
+  if (vda_loop_proxy_->BelongsToCurrentThread())
     base::MessageLoop::current()->RemoveDestructionObserver(this);
-    DestroyVDA();
-  } else {
-    // VDA should have been destroyed in WillDestroyCurrentMessageLoop.
-    DCHECK(!vda_);
-  }
+  // VDA should have been destroyed.
+  DCHECK(!vda_);
 
   // Delete all shared memories.
   STLDeleteElements(&available_shm_segments_);
   STLDeleteValues(&bitstream_buffers_in_decoder_);
   STLDeleteContainerPairFirstPointers(decode_buffers_.begin(),
                                       decode_buffers_.end());
   decode_buffers_.clear();
 
   // Delete WebRTC input buffers.
   for (std::deque<std::pair<webrtc::EncodedImage, BufferData> >::iterator it =
            pending_buffers_.begin();
        it != pending_buffers_.end();
        ++it) {
     delete[] it->first._buffer;
   }
 }
 
 scoped_ptr<RTCVideoDecoder> RTCVideoDecoder::Create(
+    webrtc::VideoCodecType type,
+    const scoped_refptr<base::MessageLoopProxy> vda_loop_proxy,
     const scoped_refptr<media::GpuVideoDecoder::Factories>& factories) {
-  scoped_ptr<RTCVideoDecoder> decoder(new RTCVideoDecoder(factories));
-  decoder->vda_.reset(factories->CreateVideoDecodeAccelerator(
-      media::VP8PROFILE_MAIN, decoder.get()));
+  scoped_ptr<RTCVideoDecoder> decoder;
+  // Convert WebRTC codec type to media codec profile.
+  media::VideoCodecProfile profile;
+  switch (type) {
+    case webrtc::kVideoCodecVP8:
+      profile = media::VP8PROFILE_MAIN;
+      break;
+    default:
+      DVLOG(2) << "Video codec not supported:" << type;
+      return decoder.Pass();
+  }
+
+  decoder.reset(new RTCVideoDecoder(vda_loop_proxy, factories));
+  decoder->vda_
+      .reset(factories->CreateVideoDecodeAccelerator(profile, decoder.get()));
   // vda can be NULL if VP8 is not supported.
   if (decoder->vda_ != NULL) {
     decoder->state_ = INITIALIZED;
   } else {
-    factories->GetMessageLoop()->DeleteSoon(FROM_HERE, decoder.release());
+    vda_loop_proxy->DeleteSoon(FROM_HERE, decoder.release());
   }
   return decoder.Pass();
 }
 
 int32_t RTCVideoDecoder::InitDecode(const webrtc::VideoCodec* codecSettings,
                                     int32_t /*numberOfCores*/) {
   DVLOG(2) << "InitDecode";
   DCHECK_EQ(codecSettings->codecType, webrtc::kVideoCodecVP8);
   if (codecSettings->codecSpecific.VP8.feedbackModeOn) {
     LOG(ERROR) << "Feedback mode not supported";
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   base::AutoLock auto_lock(lock_);
   if (state_ == UNINITIALIZED || state_ == DECODE_ERROR) {
     LOG(ERROR) << "VDA is not initialized. state=" << state_;
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   // Create some shared memory if the queue is empty.
   if (available_shm_segments_.size() == 0) {
-    // Unretained is safe because the destructor will wait until
-    // |create_shm_thread_| stops.
-    create_shm_thread_.message_loop_proxy()
-        ->PostTask(FROM_HERE,
-                   base::Bind(&RTCVideoDecoder::CreateSHM,
-                              base::Unretained(this),
-                              kMaxInFlightDecodes,
-                              kSharedMemorySegmentBytes));
+    vda_loop_proxy_->PostTask(FROM_HERE,
+                              base::Bind(&RTCVideoDecoder::CreateSHM,
+                                         weak_this_,
+                                         kMaxInFlightDecodes,
+                                         kSharedMemorySegmentBytes));
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoder::Decode(
     const webrtc::EncodedImage& inputImage,
     bool missingFrames,
     const webrtc::RTPFragmentationHeader* /*fragmentation*/,
     const webrtc::CodecSpecificInfo* /*codecSpecificInfo*/,
     int64_t /*renderTimeMs*/) {
@@ skipping 46 matching lines @@
 int32_t RTCVideoDecoder::RegisterDecodeCompleteCallback(
     webrtc::DecodedImageCallback* callback) {
   DVLOG(2) << "RegisterDecodeCompleteCallback";
   base::AutoLock auto_lock(lock_);
   decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoder::Release() {
   DVLOG(2) << "Release";
-  // Do not destroy VDA because the decoder will be recycled by
-  // RTCVideoDecoderFactory. Just reset VDA.
-  return Reset();
+  base::AutoLock auto_lock(lock_);
+  if (state_ == UNINITIALIZED) {
+    LOG(ERROR) << "Decoder not initialized.";
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
+  if (next_bitstream_buffer_id_ != 0)
+    reset_bitstream_buffer_id_ = next_bitstream_buffer_id_ - 1;
+  else
+    reset_bitstream_buffer_id_ = ID_LAST;
+  factories_->Abort();
+  vda_loop_proxy_->PostTask(
+      FROM_HERE, base::Bind(&RTCVideoDecoder::ReleaseInternal, weak_this_));
+  return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoder::Reset() {
   DVLOG(2) << "Reset";
   base::AutoLock auto_lock(lock_);
   if (state_ == UNINITIALIZED) {
     LOG(ERROR) << "Decoder not initialized.";
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (next_bitstream_buffer_id_ != 0)
@@ skipping 340 matching lines @@
   }
 }
 
 void RTCVideoDecoder::ResetInternal() {
   DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
   DVLOG(2) << "ResetInternal";
   if (vda_)
     vda_->Reset();
 }
 
+void RTCVideoDecoder::ReleaseInternal() {
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
+  DVLOG(2) << "ReleaseInternal";
+  DestroyVDA();
+}
+
 void RTCVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id,
                                          uint32 sync_point) {
   DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
   DVLOG(3) << "ReusePictureBuffer. id=" << picture_buffer_id;
 
   if (!vda_)
     return;
 
   CHECK(!picture_buffers_at_display_.empty());
 
@@ skipping 46 matching lines @@
 
 scoped_ptr<RTCVideoDecoder::SHMBuffer> RTCVideoDecoder::GetSHM_Locked(
     size_t min_size) {
   // Reuse a SHM if possible.
   SHMBuffer* ret = NULL;
   if (!available_shm_segments_.empty() &&
       available_shm_segments_.back()->size >= min_size) {
     ret = available_shm_segments_.back();
     available_shm_segments_.pop_back();
   }
-  // Post to the child thread to create shared memory if SHM cannot be reused
-  // or the queue is almost empty.
+  // Post to vda thread to create shared memory if SHM cannot be reused or the
+  // queue is almost empty.
   if (num_shm_buffers_ < kMaxNumSharedMemorySegments &&
       (ret == NULL || available_shm_segments_.size() <= 1)) {
-    create_shm_thread_.message_loop_proxy()->PostTask(
+    vda_loop_proxy_->PostTask(
         FROM_HERE,
-        // Unretained is safe because the destructor will wait until
-        // |create_shm_thread_| stops.
-        base::Bind(
-            &RTCVideoDecoder::CreateSHM, base::Unretained(this), 1, min_size));
+        base::Bind(&RTCVideoDecoder::CreateSHM, weak_this_, 1, min_size));
   }
   return scoped_ptr<SHMBuffer>(ret);
 }
 
 void RTCVideoDecoder::PutSHM_Locked(scoped_ptr<SHMBuffer> shm_buffer) {
   available_shm_segments_.push_back(shm_buffer.release());
 }
 
 void RTCVideoDecoder::CreateSHM(int number, size_t min_size) {
-  DCHECK(create_shm_thread_.message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
   DVLOG(2) << "CreateSHM. size=" << min_size;
   int number_to_allocate;
   {
     base::AutoLock auto_lock(lock_);
     number_to_allocate =
         std::min(kMaxNumSharedMemorySegments - num_shm_buffers_, number);
   }
   size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
   for (int i = 0; i < number_to_allocate; i++) {
     base::SharedMemory* shm = factories_->CreateSharedMemory(size_to_allocate);
     if (shm != NULL) {
       base::AutoLock auto_lock(lock_);
       num_shm_buffers_++;
       PutSHM_Locked(
           scoped_ptr<SHMBuffer>(new SHMBuffer(shm, size_to_allocate)));
-      // Kick off the decoding.
-      vda_loop_proxy_->PostTask(
-          FROM_HERE,
-          base::Bind(&RTCVideoDecoder::RequestBufferDecode, weak_this_));
     }
   }
+  // Kick off the decoding.
+  RequestBufferDecode();
 }
 
 void RTCVideoDecoder::RecordBufferData(const BufferData& buffer_data) {
   input_buffer_data_.push_front(buffer_data);
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
   // that's too small for some pathological B-frame test videos.  The cost of
   // using too-high a value is low (192 bits per extra slot).
   static const size_t kMaxInputBufferDataSize = 128;
   // Pop from the back of the list, because that's the oldest and least likely
   // to be useful in the future data.
@@ skipping 13 matching lines @@
       continue;
     *timestamp = it->timestamp;
     *width = it->width;
     *height = it->height;
     return;
   }
   NOTREACHED() << "Missing bitstream buffer id: " << bitstream_buffer_id;
 }
 
 }  // namespace content