HW video decode support for --enable-threaded-compositing

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 "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "media/base/demuxer_stream.h"
@@ skipping 24 matching lines @@
 
 GpuVideoDecoder::BufferTimeData::BufferTimeData(
     int32 bbid, base::TimeDelta ts, base::TimeDelta dur)
     : bitstream_buffer_id(bbid), timestamp(ts), duration(dur) {
 }
 
 GpuVideoDecoder::BufferTimeData::~BufferTimeData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     MessageLoop* message_loop,
+    MessageLoop* vda_loop,
     const scoped_refptr<Factories>& factories)
     : gvd_loop_proxy_(message_loop->message_loop_proxy()),
-      render_loop_proxy_(base::MessageLoopProxy::current()),
+      vda_loop_proxy_(vda_loop->message_loop_proxy()),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       shutting_down_(false) {
   DCHECK(gvd_loop_proxy_ && factories_);
 }
 
@@ skipping 16 matching lines @@
 void GpuVideoDecoder::Stop(const base::Closure& callback) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Stop, this, callback));
     return;
   }
   if (!vda_) {
     callback.Run();
     return;
   }
-  render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Destroy, vda_));
   vda_ = NULL;
   callback.Run();
 }
 
 void GpuVideoDecoder::Seek(base::TimeDelta time, const FilterStatusCB& cb) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Seek, this, time, cb));
     return;
@@ skipping 34 matching lines @@
     // us, so we fulfill such a read here.
     if (!pending_read_cb_.is_null())
       EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
     // Immediate fire the callback instead of waiting for the reset to complete
     // (which will happen after PipelineImpl::Stop() completes).
     callback.Run();
   } else {
     pending_reset_cb_ = callback;
   }
 
-  render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Reset, vda_));
 }
 
 void GpuVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
                                  const PipelineStatusCB& callback,
                                  const StatisticsCallback& stats_callback) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Initialize, this,
         make_scoped_refptr(demuxer_stream), callback, stats_callback));
@@ skipping 87 matching lines @@
   }
 
   if (!vda_) {
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
     return;
   }
 
   if (buffer->IsEndOfStream()) {
     if (state_ == kNormal) {
       state_ = kDrainingDecoder;
-      render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+      vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
           &VideoDecodeAccelerator::Flush, vda_));
     }
     return;
   }
 
   size_t size = buffer->GetDataSize();
   SHMBuffer* shm_buffer = GetSHM(size);
   memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_++, shm_buffer->shm->handle(), size);
   bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
   RecordBufferTimeData(bitstream_buffer, *buffer);
 
-  render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Decode, vda_, bitstream_buffer));
 }
 
 void GpuVideoDecoder::RecordBufferTimeData(
     const BitstreamBuffer& bitstream_buffer, const Buffer& buffer) {
   base::TimeDelta duration = buffer.GetDuration();
   if (duration == base::TimeDelta())
     duration = config_frame_duration_;
   input_buffer_time_data_.push_front(BufferTimeData(
       bitstream_buffer.id(), buffer.GetTimestamp(), duration));
@@ skipping 64 matching lines @@
     return;
 
   std::vector<PictureBuffer> picture_buffers;
   for (size_t i = 0; i < texture_ids.size(); ++i) {
     picture_buffers.push_back(PictureBuffer(
         next_picture_buffer_id_++, size, texture_ids[i]));
     bool inserted = picture_buffers_in_decoder_.insert(std::make_pair(
         picture_buffers.back().id(), picture_buffers.back())).second;
     DCHECK(inserted);
   }
-  render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::AssignPictureBuffers, vda_, picture_buffers));
 }
 
 void GpuVideoDecoder::DismissPictureBuffer(int32 id) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::DismissPictureBuffer, this, id));
     return;
   }
   std::map<int32, PictureBuffer>::iterator it =
@@ skipping 60 matching lines @@
 }
 
 void GpuVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::ReusePictureBuffer, this, picture_buffer_id));
     return;
   }
   if (!vda_)
     return;
-  render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::ReusePictureBuffer, vda_, picture_buffer_id));
 }
 
 GpuVideoDecoder::SHMBuffer* GpuVideoDecoder::GetSHM(size_t min_size) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (available_shm_segments_.empty() ||
       available_shm_segments_.back()->size < min_size) {
     size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
     base::SharedMemory* shm = factories_->CreateSharedMemory(size_to_allocate);
     DCHECK(shm);
@@ skipping 83 matching lines @@
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 }
 
 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::NotifyError, this, error));
     return;
   }
+  if (!vda_)
+    return;
   vda_ = NULL;
   DLOG(ERROR) << "VDA Error: " << error;
   if (host())
     host()->SetError(PIPELINE_ERROR_DECODE);
 }
 
 }  // namespace media