// Copyright 2013 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 MEDIA_VIDEO_GPU_VIDEO_ACCELERATOR_FACTORIES_H_ #define MEDIA_VIDEO_GPU_VIDEO_ACCELERATOR_FACTORIES_H_ #include #include #include #include #include "base/memory/ref_counted.h" #include "base/memory/unsafe_shared_memory_region.h" #include "base/unguessable_token.h" #include "gpu/command_buffer/client/gles2_interface.h" #include "gpu/command_buffer/common/mailbox.h" #include "gpu/ipc/common/gpu_channel.mojom.h" #include "media/base/media_export.h" #include "media/base/overlay_info.h" #include "media/base/supported_video_decoder_config.h" #include "media/base/video_decoder.h" #include "media/base/video_types.h" #include "media/video/video_encode_accelerator.h" #include "third_party/abseil-cpp/absl/types/optional.h" #include "ui/gfx/gpu_memory_buffer.h" namespace base { class SequencedTaskRunner; } // namespace base namespace gfx { class ColorSpace; class Size; } // namespace gfx namespace gpu { class GpuMemoryBufferManager; class SharedImageInterface; } // namespace gpu namespace viz { class RasterContextProvider; } // namespace viz namespace media { class MediaLog; // Helper interface for specifying factories needed to instantiate a hardware // video accelerator. // Threading model: // * The GpuVideoAcceleratorFactories may be constructed on any thread. // * The GpuVideoAcceleratorFactories has an associated task runner, which may // be retrieved as |GetTaskRunner()|. // * All calls to the Factories after construction must be made on its task // runnner, unless otherwise documented below. class MEDIA_EXPORT GpuVideoAcceleratorFactories { public: enum class OutputFormat { UNDEFINED = 0, // Unset state I420, // 3 x R8 GMBs NV12_SINGLE_GMB, // One NV12 GMB NV12_DUAL_GMB, // One R8, one RG88 GMB XR30, // 10:10:10:2 BGRX in one GMB (Usually Mac) XB30, // 10:10:10:2 RGBX in one GMB RGBA, // One 8:8:8:8 RGBA BGRA, // One 8:8:8:8 BGRA (Usually Mac) P010, // One P010 GMB. }; enum class Supported { kFalse = 0, kTrue, kUnknown, }; // Return whether GPU decoding is enabled. virtual bool IsGpuVideoDecodeAcceleratorEnabled() = 0; // Return whether GPU encoding is enabled. virtual bool IsGpuVideoEncodeAcceleratorEnabled() = 0; // Return the channel token, or an empty token if the channel is unusable. // |cb| could be called re-entrantly. This function is not thread safe. virtual void GetChannelToken( gpu::mojom::GpuChannel::GetChannelTokenCallback cb) = 0; // Returns the |route_id| of the command buffer, or 0 if there is none. virtual int32_t GetCommandBufferRouteId() = 0; // Returns Supported::kTrue if |config| is supported by a decoder created with // CreateVideoDecoder() using |implementation|. Returns Supported::kMaybe if // it's not known at this time whether |config| is supported or not. Returns // Supported::kFalse if |config| is not supported. // // May be called on any thread. // // TODO(sandersd): Switch to bool if/when all clients check // IsDecoderSupportKnown(). virtual Supported IsDecoderConfigSupported( const VideoDecoderConfig& config) = 0; // Returns VideoDecoderType::kUnknown in cases where IsDecoderSupportKnown() // is false. Otherwise, it returns the type of decoder that provided the // configs for the config support check. virtual VideoDecoderType GetDecoderType() = 0; // Callers must verify IsDecoderSupportKnown() prior to using this, or they // will immediately receive a kUnknown. // // May be called on any thread. Supported IsDecoderConfigSupportedOrUnknown(const VideoDecoderConfig& config); // Returns true if IsDecoderConfigSupported() is ready to answer queries. // Once decoder support is known, it remains known for the lifetime of |this|. // // May be called on any thread. virtual bool IsDecoderSupportKnown() = 0; // Registers a callback to be notified when IsDecoderConfigSupported() is // ready to answer queries. The callback will be invoked on the caller's // sequence. // // There is no way to unsubscribe a callback, it is recommended to use a // WeakPtr if you need this feature. // // May be called on any thread. virtual void NotifyDecoderSupportKnown(base::OnceClosure callback) = 0; virtual std::unique_ptr CreateVideoDecoder( MediaLog* media_log, RequestOverlayInfoCB request_overlay_info_cb) = 0; // Returns the supported codec profiles of video encode accelerator. // Returns nullopt if GpuVideoAcceleratorFactories don't know the VEA // supported profiles. // // May be called on any thread. // // TODO(sandersd): Remove Optional if/when all clients check // IsEncoderSupportKnown(). virtual absl::optional GetVideoEncodeAcceleratorSupportedProfiles() = 0; // Returns true if GetVideoEncodeAcceleratorSupportedProfiles() is populated. // Once encoder support is known, it remains known for the lifetime of |this|. // // May be called on any thread. virtual bool IsEncoderSupportKnown() = 0; // Registers a callback to be notified when // GetVideoEncodeAcceleratorSupportedProfiles() has been populated. The // callback will be invoked on the caller's sequence. // // There is no way to unsubscribe a callback, it is recommended to use a // WeakPtr if you need this feature. // // May be called on any thread. virtual void NotifyEncoderSupportKnown(base::OnceClosure callback) = 0; // Caller owns returned pointer, but should call Destroy() on it (instead of // directly deleting) for proper destruction, as per the // VideoEncodeAccelerator interface. virtual std::unique_ptr CreateVideoEncodeAccelerator() = 0; virtual std::unique_ptr CreateGpuMemoryBuffer( const gfx::Size& size, gfx::BufferFormat format, gfx::BufferUsage usage) = 0; // |for_media_stream| specifies webrtc use case of media streams. virtual bool ShouldUseGpuMemoryBuffersForVideoFrames( bool for_media_stream) const = 0; // The GLContextLock must be taken when calling this. virtual unsigned ImageTextureTarget(gfx::BufferFormat format) = 0; // Pixel format of the hardware video frames created when GpuMemoryBuffers // video frames are enabled. virtual OutputFormat VideoFrameOutputFormat( VideoPixelFormat pixel_format) = 0; // Returns a SharedImageInterface that can be used (on any thread) to allocate // and update shared images. // nullptr will be returned in cases where a context couldn't be created or // the context was lost. virtual gpu::SharedImageInterface* SharedImageInterface() = 0; // Returns the GpuMemoryBufferManager that is used to allocate // GpuMemoryBuffers. May return null if // ShouldUseGpuMemoryBuffersForVideoFrames return false. virtual gpu::GpuMemoryBufferManager* GpuMemoryBufferManager() = 0; // Allocate & return an unsafe shared memory region virtual base::UnsafeSharedMemoryRegion CreateSharedMemoryRegion( size_t size) = 0; // Returns the task runner the video accelerator runs on. virtual scoped_refptr GetTaskRunner() = 0; virtual viz::RasterContextProvider* GetMediaContextProvider() = 0; // Sets or gets the current pipeline rendering color space. virtual void SetRenderingColorSpace(const gfx::ColorSpace& color_space) = 0; virtual const gfx::ColorSpace& GetRenderingColorSpace() const = 0; virtual ~GpuVideoAcceleratorFactories() = default; }; } // namespace media #endif // MEDIA_VIDEO_GPU_VIDEO_ACCELERATOR_FACTORIES_H_