VaapiVideoAccelerator: make Vaapi accelerator work with ozone

content/common/gpu/media/vaapi_picture_provider.h

Index: content/common/gpu/media/vaapi_picture_provider.h
diff --git a/content/common/gpu/media/vaapi_picture_provider.h b/content/common/gpu/media/vaapi_picture_provider.h
new file mode 100644
index 0000000000000000000000000000000000000000..d35b22ea9a66e9a0536577ae7ac83bb7380d63ad
--- /dev/null
+++ b/content/common/gpu/media/vaapi_picture_provider.h
@@ -0,0 +1,84 @@
+// Copyright 2014 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 picture allocation for
+// different window system (X11/Ozone) used by
+// VaapiVideoDecodeAccelerator to produce output pictures.
+
+#ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_PICTURE_PROVIDER_H_
+#define CONTENT_COMMON_GPU_MEDIA_VAAPI_PICTURE_PROVIDER_H_
+
+#include "base/callback.h"
+#include "base/memory/linked_ptr.h"
+#include "base/threading/non_thread_safe.h"
+#include "third_party/libva/va/va.h"
+#include "ui/gfx/size.h"
+
+namespace gfx {
+class GLContext;
+}  // namespace gfx
+
+namespace content {
+
+class VaapiWrapper;
+
+// VaapiPictureProvider is in charge of allocating pictures for the
+// window system and binding them to gl textures.
+class VaapiPictureProvider : public base::NonThreadSafe {
+ public:
+  // Picture is native pixmap abstraction (X11/Ozone)
+  class Picture : public base::NonThreadSafe {
+   public:
+    virtual ~Picture() {}
+
+    int32 picture_buffer_id() const { return picture_buffer_id_; }
+    uint32 texture_id() const { return texture_id_; }
+    const gfx::Size& size() const { return size_; }
+
+    virtual bool DownloadFromSurface(VASurfaceID va_surface_id,
+                                     const gfx::Size& surface_size) = 0;
+
+   protected:
+    Picture(int32 picture_buffer_id, uint32 texture_id, const gfx::Size& size)
+        : picture_buffer_id_(picture_buffer_id),
+          texture_id_(texture_id),
+          size_(size) {}
+
+   private:
+    int32 picture_buffer_id_;
+    uint32 texture_id_;
+    gfx::Size size_;
+
+    DISALLOW_COPY_AND_ASSIGN(Picture);
+  };
+
+  virtual ~VaapiPictureProvider();
+
+  // Create an RGBA picture of |size| and associate it to the given
+  // gl |texture_id| and |picture_buffer_id|.
+  virtual linked_ptr<Picture> CreatePicture(int32 picture_buffer_id,
+                                            uint32 texture_id,
+                                            const gfx::Size& size) = 0;
+
+  // Create a platform specific picture provider for the given
+  // |va_display|. |gl_context| and |make_context_current| will be

[Pawel Osciak, 2014/10/26 13:06:46]

Stale comment.

[llandwerlin-old, 2014/10/29 13:52:48]

Acknowledged.

+  // used to bind/unbind picture to gl textures.
+  static scoped_ptr<VaapiPictureProvider> Create(
+      scoped_refptr<VaapiWrapper> vaapi_wrapper,
+      gfx::GLContext* gl_context,
+      const base::Callback<bool(void)> make_context_current);
+
+ protected:
+  VaapiPictureProvider();
+
+ private:
+  // Initialize the picture provider.
+  virtual bool Initialize() = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(VaapiPictureProvider);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_PICTURE_PROVIDER_H_