Make VEA client of command buffer; move sync. IPC to VDA/VEA::Initialize()

content/common/gpu/media/dxva_video_decode_accelerator.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 "content/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 412 matching lines @@
 }
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     const base::Callback<bool(void)>& make_context_current)
     : client_(NULL),
       dev_manager_reset_token_(0),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
       inputs_before_decode_(0),
-      make_context_current_(make_context_current) {
+      make_context_current_(make_context_current),
+      weak_this_factory_(this) {
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
 }
 
 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() {
   client_ = NULL;
 }
 
 bool DXVAVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
                                             Client* client) {
@@ skipping 47 matching lines @@
       SendMFTMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0),
       "Send MFT_MESSAGE_NOTIFY_BEGIN_STREAMING notification failed",
       PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(
       SendMFTMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0),
       "Send MFT_MESSAGE_NOTIFY_START_OF_STREAM notification failed",
       PLATFORM_FAILURE, false);
 
   state_ = kNormal;
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &DXVAVideoDecodeAccelerator::NotifyInitializeDone,
-      base::AsWeakPtr(this)));
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(CalledOnValidThread());
 
   RETURN_AND_NOTIFY_ON_FAILURE((state_ == kNormal || state_ == kStopped ||
                                 state_ == kFlushing),
       "Invalid state: " << state_, ILLEGAL_STATE,);
@@ skipping 89 matching lines @@
 
   state_ = kResetting;
 
   pending_output_samples_.clear();
 
   NotifyInputBuffersDropped();
 
   RETURN_AND_NOTIFY_ON_FAILURE(SendMFTMessage(MFT_MESSAGE_COMMAND_FLUSH, 0),
       "Reset: Failed to send message.", PLATFORM_FAILURE,);
 
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &DXVAVideoDecodeAccelerator::NotifyResetDone, base::AsWeakPtr(this)));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&DXVAVideoDecodeAccelerator::NotifyResetDone,
+                 weak_this_factory_.GetWeakPtr()));
 
   state_ = DXVAVideoDecodeAccelerator::kNormal;
 }
 
 void DXVAVideoDecodeAccelerator::Destroy() {
   DCHECK(CalledOnValidThread());
   Invalidate();
   delete this;
 }
 
@@ skipping 252 matching lines @@
   }
 
   // We only read the surface description, which contains its width/height when
   // we need the picture buffers from the client. Once we have those, then they
   // are reused.
   D3DSURFACE_DESC surface_desc;
   hr = surface->GetDesc(&surface_desc);
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
 
   // Go ahead and request picture buffers.
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &DXVAVideoDecodeAccelerator::RequestPictureBuffers,
-      base::AsWeakPtr(this), surface_desc.Width, surface_desc.Height));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
+                 weak_this_factory_.GetWeakPtr(),
+                 surface_desc.Width,
+                 surface_desc.Height));
 
   pictures_requested_ = true;
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::ProcessPendingSamples() {
   RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
       "Failed to make context current", PLATFORM_FAILURE,);
 
   OutputBuffers::iterator index;
@@ skipping 31 matching lines @@
         return;
       }
 
       RETURN_AND_NOTIFY_ON_FAILURE(
           index->second->CopyOutputSampleDataToPictureBuffer(*this, surface),
           "Failed to copy output sample",
           PLATFORM_FAILURE, );
 
       media::Picture output_picture(index->second->id(),
                                     sample_info.input_buffer_id);
-      base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-          &DXVAVideoDecodeAccelerator::NotifyPictureReady,
-          base::AsWeakPtr(this), output_picture));
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&DXVAVideoDecodeAccelerator::NotifyPictureReady,
+                     weak_this_factory_.GetWeakPtr(),
+                     output_picture));
 
       index->second->set_available(false);
       pending_output_samples_.pop_front();
     }
   }
 
   if (!pending_input_buffers_.empty() && pending_output_samples_.empty()) {
-    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
-        base::AsWeakPtr(this)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
+                   weak_this_factory_.GetWeakPtr()));
   }
 }
 
 void DXVAVideoDecodeAccelerator::StopOnError(
   media::VideoDecodeAccelerator::Error error) {
   DCHECK(CalledOnValidThread());
 
   if (client_)
     client_->NotifyError(error);
   client_ = NULL;
 
   if (state_ != kUninitialized) {
     Invalidate();
   }
 }
 
 void DXVAVideoDecodeAccelerator::Invalidate() {
   if (state_ == kUninitialized)
     return;
+  weak_this_factory_.InvalidateWeakPtrs();
   output_picture_buffers_.clear();
   pending_output_samples_.clear();
   pending_input_buffers_.clear();
   decoder_.Release();
   MFShutdown();
   state_ = kUninitialized;
 }
 
-void DXVAVideoDecodeAccelerator::NotifyInitializeDone() {
-  if (client_)
-    client_->NotifyInitializeDone();
-}
-
 void DXVAVideoDecodeAccelerator::NotifyInputBufferRead(int input_buffer_id) {
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
 }
 
 void DXVAVideoDecodeAccelerator::NotifyFlushDone() {
   if (client_)
     client_->NotifyFlushDone();
 }
 
@@ skipping 54 matching lines @@
   // MF_E_TRANSFORM_NEED_MORE_INPUT.
   // The MFT decoder can buffer upto 30 frames worth of input before returning
   // an output frame. This loop here attempts to retrieve as many output frames
   // as possible from the buffered set.
   while (state_ != kStopped) {
     DoDecode();
     if (!pending_output_samples_.empty())
       return;
   }
 
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &DXVAVideoDecodeAccelerator::NotifyFlushDone, base::AsWeakPtr(this)));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&DXVAVideoDecodeAccelerator::NotifyFlushDone,
+                 weak_this_factory_.GetWeakPtr()));
 
   state_ = kNormal;
 }
 
 void DXVAVideoDecodeAccelerator::DecodeInternal(
     const base::win::ScopedComPtr<IMFSample>& sample) {
   DCHECK(CalledOnValidThread());
   
   if (state_ == kUninitialized)
     return;
@@ skipping 29 matching lines @@
     // 2. If we don't have any output samples we post the
     //    DecodePendingInputBuffers task to process the pending input samples.
     //    If we have an output sample then the above task is posted when the
     //    output samples are sent to the client.
     // This is because we only support 1 pending output sample at any
     // given time due to the limitation with the Microsoft media foundation
     // decoder where it recycles the output Decoder surfaces.
     if (hr == MF_E_NOTACCEPTING) {
       pending_input_buffers_.push_back(sample);
       if (pending_output_samples_.empty()) {
-        base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-            &DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
-            base::AsWeakPtr(this)));
+        base::MessageLoop::current()->PostTask(
+            FROM_HERE,
+            base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
+                       weak_this_factory_.GetWeakPtr()));
       }
       return;
     }
   }
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to process input sample",
       PLATFORM_FAILURE,);
 
   DoDecode();
 
   RETURN_AND_NOTIFY_ON_FAILURE((state_ == kStopped || state_ == kNormal),
       "Failed to process output. Unexpected decoder state: " << state_,
       ILLEGAL_STATE,);
 
   LONGLONG input_buffer_id = 0;
   RETURN_ON_HR_FAILURE(sample->GetSampleTime(&input_buffer_id),
                        "Failed to get input buffer id associated with sample",);
   // The Microsoft Media foundation decoder internally buffers up to 30 frames
   // before returning a decoded frame. We need to inform the client that this
   // input buffer is processed as it may stop sending us further input.
   // Note: This may break clients which expect every input buffer to be
   // associated with a decoded output buffer.
   // TODO(ananta)
   // Do some more investigation into whether it is possible to get the MFT
   // decoder to emit an output packet for every input packet.
   // http://code.google.com/p/chromium/issues/detail?id=108121
   // http://code.google.com/p/chromium/issues/detail?id=150925
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &DXVAVideoDecodeAccelerator::NotifyInputBufferRead,
-      base::AsWeakPtr(this), input_buffer_id));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&DXVAVideoDecodeAccelerator::NotifyInputBufferRead,
+                 weak_this_factory_.GetWeakPtr(),
+                 input_buffer_id));
 }
 
 void DXVAVideoDecodeAccelerator::HandleResolutionChanged(int width,
                                                          int height) {
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &DXVAVideoDecodeAccelerator::DismissStaleBuffers,
-      base::AsWeakPtr(this), output_picture_buffers_));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&DXVAVideoDecodeAccelerator::DismissStaleBuffers,
+                 weak_this_factory_.GetWeakPtr(),
+                 output_picture_buffers_));
 
-  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &DXVAVideoDecodeAccelerator::RequestPictureBuffers,
-      base::AsWeakPtr(this), width, height));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
+                 weak_this_factory_.GetWeakPtr(),
+                 width,
+                 height));
 
   output_picture_buffers_.clear();
 }
 
 void DXVAVideoDecodeAccelerator::DismissStaleBuffers(
     const OutputBuffers& picture_buffers) {
   OutputBuffers::const_iterator index;
 
   for (index = picture_buffers.begin();
        index != picture_buffers.end();
        ++index) {
     DVLOG(1) << "Dismissing picture id: " << index->second->id();
     client_->DismissPictureBuffer(index->second->id());
   }
 }
 
 }  // namespace content