[Ozone] Extends the lifetime of VaapiWrapper

content/common/gpu/media/vaapi_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/vaapi_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
@@ skipping 711 matching lines @@
       vaapi_wrapper_->CreateSurfaces(VA_RT_FORMAT_YUV420, requested_pic_size_,
                                      buffers.size(), &va_surface_ids),
       "Failed creating VA Surfaces", PLATFORM_FAILURE, );
   DCHECK_EQ(va_surface_ids.size(), buffers.size());
 
   for (size_t i = 0; i < buffers.size(); ++i) {
     DVLOG(2) << "Assigning picture id: " << buffers[i].id()
              << " to texture id: " << buffers[i].texture_id()
              << " VASurfaceID: " << va_surface_ids[i];
 
-    linked_ptr<VaapiPicture> picture(VaapiPicture::CreatePicture(
-        vaapi_wrapper_.get(), make_context_current_, buffers[i].id(),
+    scoped_refptr<VaapiPicture> picture(VaapiPicture::CreatePicture(
+        vaapi_wrapper_, make_context_current_, buffers[i].id(),
         buffers[i].texture_id(), requested_pic_size_));
 
     scoped_refptr<gl::GLImage> image = picture->GetImageToBind();
     if (image) {
       bind_image_.Run(buffers[i].internal_texture_id(),
                       VaapiPicture::GetGLTextureTarget(), image);
     }
 
     RETURN_AND_NOTIFY_ON_FAILURE(
         picture.get(), "Failed assigning picture buffer to a texture.",
@@ skipping 179 matching lines @@
 
   base::AutoLock auto_lock(lock_);
   if (state_ == kUninitialized || state_ == kDestroying)
     return;
 
   DVLOG(1) << "Destroying VAVDA";
   state_ = kDestroying;
 
   client_ptr_factory_.reset();
   weak_this_factory_.InvalidateWeakPtrs();
+  pictures_.clear();

[kalyank, 2015/11/14 10:42:06]

I have played around with this a bit and issue is that DrmPicture holds on to
the refs of GLImage(As you mentioned) and pixmap_. We should release them when
VaapiVideoDecodeAccelerator decides to clear the pictures. We could have
ClearResources call in VaapiPicture which would be called by
VaapiDecodeAccelerator before it clears the pictures cache. In SurfaceOzone, we
would still have a ref to any in use GLImage(which has a ref to NativePixmap).
So, the image and native pixmap will not be destroyed till SurfaceOzone is using
them.

In VaapiDrmPicture::ClearResources, we should do what ever we are doing
currently in the destructor along with releasing references to gl_image_ and
pixmap_. However, bit confusing thing is that we need to hold onto
processed_pixmap_ here as VaapiDecodeAccelerator doesn't really manage it but
GbmPixmap and GLImage doesn't have a ref to it. 

[Pawel Osciak, 2015/11/16 04:24:35]

If there are any references to VaapiDrmPicture being held by ScalingCallback, we
shouldn't be releasing them at this point. But we should be ok already,
~VaapiDrmPicture will free them when all references to it are dropped.
I'm confused why we'd need this. If I understand this CL correctly, this extends
the lifetime of VaapiDrmPicture for it to stay alive while it's waiting for the
ScalingCallback to execute. After that, the last reference to VaapiDrmPicture
will be dropped and GLImage and Pixmap should be released in the destructor of
VaapiDrmPicture.

VaapiVideoDecodeAccelerator will not be holding any references to
VaapiDrmPicture since we released them here and only VaapiDrmPicture holds
references to GLImage and Pixmap, so VaapiDrmPicture should be responsible for
releasing them (and it does so in ~VaapiDrmPicture).

[william.xie1, 2015/11/16 08:07:26]

Done.

[william.xie1, 2015/11/16 08:07:26]

Done.

[kalyank, 2015/11/18 00:21:43]

We want to ensure VaapiDrmPicture is alive while any scaling callbacks are in 
use. For that, we changed callback to hold a ref of VaapiDrmPicture. Now:
1) VaapiVideoDecodeAccelerator and Callback has a reference to VaapiDrmPicture.
2)VaapiDrmPicture holds a reference to the GLImage and Native pixmap it creates.
  GLSurfaceOzone holds a reference to the same GLImage (In case its queued to be
  displayed). GLImage internally holds a reference to the Native Pixmap its 
  initialized with.
3)GLSurfaceOzone will not hold any reference to GLImage, once it's done using 
  it. However, GLImage is not destroyed as VaapiDrmPicture still holds a 
  reference to it.
4)As GLImage is not destroyed, we don't release the NativePixmap it's 
  initialized with. This results in keeping the Callback alive. 

Thus, GLImage, Native Pixmap and VaapiDrmPicture will never be destroyed.

Releasing the resources in use by VaapiDrmPicture here, ensures that we clear
all the resources once SurfaceOzone is done using the GLImage.

I am not sure how easy is to separate the scaling pixmap logic out of DrmPicture
and see if we can ensure only VaapiWrapper is alive (As it manages the VPP
context).

+  vaapi_wrapper_ = nullptr;
 
   // Signal all potential waiters on the decoder_thread_, let them early-exit,
   // as we've just moved to the kDestroying state, and wait for all tasks
   // to finish.
   input_ready_.Signal();
   surfaces_available_.Signal();
   {
     base::AutoUnlock auto_unlock(lock_);
     decoder_thread_.Stop();
   }
 
   state_ = kUninitialized;
 }
 
 void VaapiVideoDecodeAccelerator::Destroy() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   Cleanup();
   delete this;
+  LOG(WARNING) << "!!!!!!!!!!!!!!!qxie2:" << __FUNCTION__;
 }
 
 bool VaapiVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 bool VaapiVideoDecodeAccelerator::DecodeSurface(
     const scoped_refptr<VaapiDecodeSurface>& dec_surface) {
   if (!vaapi_wrapper_->ExecuteAndDestroyPendingBuffers(
           dec_surface->va_surface()->id())) {
@@ skipping 771 matching lines @@
   return vaapi_pic->dec_surface();
 }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 VaapiVideoDecodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedDecodeProfiles();
 }
 
 }  // namespace content