| // Copyright 2019 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. |
| |
| #ifndef GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_INTERFACE_IN_PROCESS_H_ |
| #define GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_INTERFACE_IN_PROCESS_H_ |
| |
| #include "base/callback.h" |
| #include "base/memory/raw_ptr.h" |
| #include "build/build_config.h" |
| #include "gpu/command_buffer/client/shared_image_interface.h" |
| #include "gpu/command_buffer/common/command_buffer_id.h" |
| #include "gpu/gpu_gles2_export.h" |
| #include "ui/gfx/gpu_memory_buffer.h" |
| |
| namespace base { |
| class WaitableEvent; |
| } |
| |
| namespace gpu { |
| class MailboxManager; |
| class SharedContextState; |
| class SharedImageFactory; |
| class SharedImageManager; |
| class SingleTaskSequence; |
| class SyncPointClientState; |
| class DisplayCompositorMemoryAndTaskControllerOnGpu; |
| class SyncPointManager; |
| struct GpuPreferences; |
| class GpuDriverBugWorkarounds; |
| struct GpuFeatureInfo; |
| class ImageFactory; |
| class MemoryTracker; |
| struct SyncToken; |
| |
| // This is an implementation of the SharedImageInterface to be used on the viz |
| // compositor thread. This class also implements the corresponding parts |
| // happening on gpu thread. |
| // TODO(weiliangc): Currently this is implemented as backed by |
| // InProcessCommandBuffer. Add constructor for using with SkiaRenderer. |
| class GPU_GLES2_EXPORT SharedImageInterfaceInProcess |
| : public SharedImageInterface { |
| public: |
| // This is only implemented by InProcessCommandBuffer. |
| class GPU_GLES2_EXPORT CommandBufferHelper { |
| public: |
| virtual void SetError() = 0; |
| virtual void WrapTaskWithGpuCheck(base::OnceClosure task) = 0; |
| }; |
| |
| // The callers must guarantee that the instances passed via pointers are kept |
| // alive for as long as the instance of this class is alive. This can be |
| // achieved by ensuring that the ownership of the created |
| // SharedImageInterfaceInProcess is the same as the ownership of the passed in |
| // pointers. |
| SharedImageInterfaceInProcess( |
| SingleTaskSequence* task_sequence, |
| DisplayCompositorMemoryAndTaskControllerOnGpu* display_controller, |
| raw_ptr<CommandBufferHelper> command_buffer_helper); |
| // The callers must guarantee that the instances passed via pointers are kept |
| // alive for as long as the instance of this class is alive. This can be |
| // achieved by ensuring that the ownership of the created |
| // SharedImageInterfaceInProcess is the same as the ownership of the passed in |
| // pointers. |
| SharedImageInterfaceInProcess( |
| SingleTaskSequence* task_sequence, |
| SyncPointManager* sync_point_manager, |
| const GpuPreferences& gpu_preferences, |
| const GpuDriverBugWorkarounds& gpu_workarounds, |
| const GpuFeatureInfo& gpu_feature_info, |
| gpu::SharedContextState* context_state, |
| MailboxManager* mailbox_manager, |
| SharedImageManager* shared_image_manager, |
| ImageFactory* image_factory, |
| MemoryTracker* tracker, |
| bool is_for_display_compositor = false, |
| raw_ptr<CommandBufferHelper> command_buffer_helper = nullptr); |
| |
| SharedImageInterfaceInProcess(const SharedImageInterfaceInProcess&) = delete; |
| SharedImageInterfaceInProcess& operator=( |
| const SharedImageInterfaceInProcess&) = delete; |
| |
| ~SharedImageInterfaceInProcess() override; |
| |
| // The |SharedImageInterface| keeps ownership of the image until |
| // |DestroySharedImage| is called or the interface itself is destroyed (e.g. |
| // the GPU channel is lost). |
| Mailbox CreateSharedImage(viz::ResourceFormat format, |
| const gfx::Size& size, |
| const gfx::ColorSpace& color_space, |
| GrSurfaceOrigin surface_origin, |
| SkAlphaType alpha_type, |
| uint32_t usage, |
| gpu::SurfaceHandle surface_handle) override; |
| |
| // Same behavior as the above, except that this version takes |pixel_data| |
| // which is used to populate the SharedImage. |pixel_data| should have the |
| // same format which would be passed to glTexImage2D to populate a similarly |
| // specified texture. |
| Mailbox CreateSharedImage(viz::ResourceFormat format, |
| const gfx::Size& size, |
| const gfx::ColorSpace& color_space, |
| GrSurfaceOrigin surface_origin, |
| SkAlphaType alpha_type, |
| uint32_t usage, |
| base::span<const uint8_t> pixel_data) override; |
| |
| // |usage| is a combination of |SharedImageUsage| bits that describes which |
| // API(s) the image will be used with. Format and size are derived from the |
| // GpuMemoryBuffer. |gpu_memory_buffer_manager| is the manager that created |
| // |gpu_memory_buffer|. If the |gpu_memory_buffer| was created on the client |
| // side (for NATIVE_PIXMAP or ANDROID_HARDWARE_BUFFER types only), without a |
| // GpuMemoryBufferManager, |gpu_memory_buffer_manager| can be nullptr. |
| // If valid, |color_space| will be applied to the shared |
| // image (possibly overwriting the one set on the GpuMemoryBuffer). |
| // The |SharedImageInterface| keeps ownership of the image until |
| // |DestroySharedImage| is called or the interface itself is destroyed (e.g. |
| // the GPU channel is lost). |
| Mailbox CreateSharedImage(gfx::GpuMemoryBuffer* gpu_memory_buffer, |
| GpuMemoryBufferManager* gpu_memory_buffer_manager, |
| gfx::BufferPlane plane, |
| const gfx::ColorSpace& color_space, |
| GrSurfaceOrigin surface_origin, |
| SkAlphaType alpha_type, |
| uint32_t usage) override; |
| |
| // Updates a shared image after its GpuMemoryBuffer (if any) was modified on |
| // the CPU or through external devices, after |sync_token| has been released. |
| void UpdateSharedImage(const SyncToken& sync_token, |
| const Mailbox& mailbox) override; |
| |
| // Updates a shared image after its GpuMemoryBuffer (if any) was modified on |
| // the CPU or through external devices, after |sync_token| has been released. |
| // If |acquire_fence| is not null, the fence is inserted in the GPU command |
| // stream and a server side wait is issued before any GPU command referring |
| // to this shared imaged is executed on the GPU. |
| void UpdateSharedImage(const SyncToken& sync_token, |
| std::unique_ptr<gfx::GpuFence> acquire_fence, |
| const Mailbox& mailbox) override; |
| |
| // Destroys the shared image, unregistering its mailbox, after |sync_token| |
| // has been released. After this call, the mailbox can't be used to reference |
| // the image any more, however if the image was imported into other APIs, |
| // those may keep a reference to the underlying data. |
| void DestroySharedImage(const SyncToken& sync_token, |
| const Mailbox& mailbox) override; |
| |
| // Creates a swap chain. Not reached in this implementation. |
| SwapChainMailboxes CreateSwapChain(viz::ResourceFormat format, |
| const gfx::Size& size, |
| const gfx::ColorSpace& color_space, |
| GrSurfaceOrigin surface_origin, |
| SkAlphaType alpha_type, |
| uint32_t usage) override; |
| |
| // Swaps front and back buffer of a swap chain. Not reached in this |
| // implementation. |
| void PresentSwapChain(const SyncToken& sync_token, |
| const Mailbox& mailbox) override; |
| |
| #if BUILDFLAG(IS_FUCHSIA) |
| // Registers a sysmem buffer collection. Not reached in this implementation. |
| void RegisterSysmemBufferCollection(gfx::SysmemBufferCollectionId id, |
| zx::channel token, |
| gfx::BufferFormat format, |
| gfx::BufferUsage usage, |
| bool register_with_image_pipe) override; |
| |
| // Not reached in this implementation. |
| void ReleaseSysmemBufferCollection(gfx::SysmemBufferCollectionId id) override; |
| #endif // BUILDFLAG(IS_FUCHSIA) |
| |
| // Generates an unverified SyncToken that is released after all previous |
| // commands on this interface have executed on the service side. |
| SyncToken GenUnverifiedSyncToken() override; |
| |
| // Generates a verified SyncToken that is released after all previous |
| // commands on this interface have executed on the service side. |
| SyncToken GenVerifiedSyncToken() override; |
| |
| void WaitSyncToken(const SyncToken& sync_token) override; |
| |
| // Flush the SharedImageInterface, issuing any deferred IPCs. |
| void Flush() override; |
| |
| scoped_refptr<gfx::NativePixmap> GetNativePixmap( |
| const gpu::Mailbox& mailbox) override; |
| |
| private: |
| // Parameters needed to be passed in to set up the class on the GPU. |
| // Needed since we cannot pass refcounted instances (e.g. |
| // gpu::SharedContextState) to base::BindOnce as raw pointers. |
| struct SetUpOnGpuParams; |
| |
| void SetUpOnGpu(std::unique_ptr<SetUpOnGpuParams> params); |
| void DestroyOnGpu(base::WaitableEvent* completion); |
| |
| SyncToken MakeSyncToken(uint64_t release_id) { |
| return SyncToken(CommandBufferNamespace::IN_PROCESS, command_buffer_id_, |
| release_id); |
| } |
| |
| void ScheduleGpuTask(base::OnceClosure task, |
| std::vector<SyncToken> sync_token_fences); |
| |
| // Only called on the gpu thread. |
| bool MakeContextCurrent(bool needs_gl = false); |
| bool LazyCreateSharedImageFactory(); |
| void CreateSharedImageOnGpuThread(const Mailbox& mailbox, |
| viz::ResourceFormat format, |
| gpu::SurfaceHandle surface_handle, |
| const gfx::Size& size, |
| const gfx::ColorSpace& color_space, |
| GrSurfaceOrigin surface_origin, |
| SkAlphaType alpha_type, |
| uint32_t usage, |
| const SyncToken& sync_token); |
| void CreateSharedImageWithDataOnGpuThread(const Mailbox& mailbox, |
| viz::ResourceFormat format, |
| const gfx::Size& size, |
| const gfx::ColorSpace& color_space, |
| GrSurfaceOrigin surface_origin, |
| SkAlphaType alpha_type, |
| uint32_t usage, |
| const SyncToken& sync_token, |
| std::vector<uint8_t> pixel_data); |
| |
| void CreateGMBSharedImageOnGpuThread(const Mailbox& mailbox, |
| gfx::GpuMemoryBufferHandle handle, |
| gfx::BufferFormat format, |
| gfx::BufferPlane plane, |
| const gfx::Size& size, |
| const gfx::ColorSpace& color_space, |
| GrSurfaceOrigin surface_origin, |
| SkAlphaType alpha_type, |
| uint32_t usage, |
| const SyncToken& sync_token); |
| void UpdateSharedImageOnGpuThread(const Mailbox& mailbox, |
| const SyncToken& sync_token); |
| void DestroySharedImageOnGpuThread(const Mailbox& mailbox); |
| void WaitSyncTokenOnGpuThread(const SyncToken& sync_token); |
| void WrapTaskWithGpuUrl(base::OnceClosure task); |
| |
| // Used to schedule work on the gpu thread. This is a raw pointer for now |
| // since the ownership of SingleTaskSequence would be the same as the |
| // SharedImageInterfaceInProcess. |
| raw_ptr<SingleTaskSequence> task_sequence_; |
| const CommandBufferId command_buffer_id_; |
| raw_ptr<CommandBufferHelper> command_buffer_helper_; |
| |
| base::OnceCallback<std::unique_ptr<SharedImageFactory>()> create_factory_; |
| |
| // Sequence checker for tasks that run on the gpu "thread". |
| SEQUENCE_CHECKER(gpu_sequence_checker_); |
| |
| // Accessed on any thread. release_id_lock_ protects access to |
| // next_fence_sync_release_. |
| base::Lock lock_; |
| uint64_t next_fence_sync_release_ = 1; |
| |
| // Accessed on compositor thread. |
| // This is used to get NativePixmap, and is only used when SharedImageManager |
| // is thread safe. |
| raw_ptr<SharedImageManager> shared_image_manager_; |
| |
| // Accessed on GPU thread. |
| scoped_refptr<SharedContextState> context_state_; |
| // This is a raw pointer for now since the ownership of SyncPointManager would |
| // be the same as the SharedImageInterfaceInProcess. |
| raw_ptr<SyncPointManager> sync_point_manager_; |
| scoped_refptr<SyncPointClientState> sync_point_client_state_; |
| std::unique_ptr<SharedImageFactory> shared_image_factory_; |
| }; |
| |
| } // namespace gpu |
| |
| #endif // GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_INTERFACE_IN_PROCESS_H_ |