vaapi plumbing to allow hardware video overlays

content/common/gpu/media/vaapi_video_decode_accelerator.h

 // 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.
 //
 // This file contains an implementation of VideoDecoderAccelerator
 // that utilizes hardware video decoder present on Intel CPUs.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
 
@@ skipping 10 matching lines @@
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/media/vaapi_h264_decoder.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/video/picture.h"
 #include "media/video/video_decode_accelerator.h"
 
+namespace gpu {
+namespace gles2 {
+class TextureManager;
+}
+}
+
 namespace content {
 
 class VaapiPicture;
 
 // Class to provide video decode acceleration for Intel systems with hardware
 // support for it, and on which libva is available.
 // Decoding tasks are performed in a separate decoding thread.
 //
 // Threading/life-cycle: this object is created & destroyed on the GPU
 // ChildThread.  A few methods on it are called on the decoder thread which is
 // stopped during |this->Destroy()|, so any tasks posted to the decoder thread
 // can assume |*this| is still alive.  See |weak_this_| below for more details.
 class CONTENT_EXPORT VaapiVideoDecodeAccelerator
     : public media::VideoDecodeAccelerator {
  public:
   VaapiVideoDecodeAccelerator(
-      const base::Callback<bool(void)>& make_context_current);
+      const base::Callback<bool(void)>& make_context_current,
+      gpu::gles2::TextureManager* texture_manager);
   virtual ~VaapiVideoDecodeAccelerator();
 
   // media::VideoDecodeAccelerator implementation.
   virtual bool Initialize(media::VideoCodecProfile profile,
                           Client* client) override;
   virtual void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
   virtual void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) override;
   virtual void ReusePictureBuffer(int32 picture_buffer_id) override;
   virtual void Flush() override;
@@ skipping 199 matching lines @@
   bool finish_flush_pending_;
 
   // Decoder requested a new surface set and we are waiting for all the surfaces
   // to be returned before we can free them.
   bool awaiting_va_surfaces_recycle_;
 
   // Last requested number/resolution of output picture buffers.
   size_t requested_num_pics_;
   gfx::Size requested_pic_size_;
 
+  gpu::gles2::TextureManager* texture_manager_;

[alexst (slow to review), 2015/01/19 19:02:17]

Is it safe to cache this here from a lifetime perspective?

[achaulk, 2015/01/19 19:05:49]

It should be. This object is owned by the GpuVideoDecodeAccelerator which in
turn has its lifetime bounded by GpuCommandBufferStub, so when the command
buffer is destroyed this object should also be torn down

+
   // The WeakPtrFactory for |weak_this_|.
   base::WeakPtrFactory<VaapiVideoDecodeAccelerator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiVideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_