// Copyright 2012 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifdef UNSAFE_BUFFERS_BUILD // TODO(crbug.com/40285824): Remove this and convert code to safer constructs. #pragma allow_unsafe_buffers #endif #include "media/renderers/paint_canvas_video_renderer.h" #include <GLES3/gl3.h> #include <array> #include <limits> #include <numeric> #include "base/barrier_closure.h" #include "base/compiler_specific.h" #include "base/feature_list.h" #include "base/functional/bind.h" #include "base/functional/callback_helpers.h" #include "base/logging.h" #include "base/memory/ptr_util.h" #include "base/memory/raw_ptr.h" #include "base/numerics/checked_math.h" #include "base/sequence_checker.h" #include "base/synchronization/waitable_event.h" #include "base/system/sys_info.h" #include "base/task/thread_pool.h" #include "base/threading/thread_restrictions.h" #include "build/build_config.h" #include "cc/paint/paint_canvas.h" #include "cc/paint/paint_flags.h" #include "cc/paint/paint_image_builder.h" #include "components/viz/common/gpu/raster_context_provider.h" #include "components/viz/common/resources/shared_image_format.h" #include "gpu/GLES2/gl2extchromium.h" #include "gpu/command_buffer/client/client_shared_image.h" #include "gpu/command_buffer/client/context_support.h" #include "gpu/command_buffer/client/gles2_interface.h" #include "gpu/command_buffer/client/raster_interface.h" #include "gpu/command_buffer/client/shared_image_interface.h" #include "gpu/command_buffer/common/capabilities.h" #include "gpu/command_buffer/common/mailbox_holder.h" #include "gpu/command_buffer/common/shared_image_usage.h" #include "media/base/data_buffer.h" #include "media/base/video_frame.h" #include "media/base/wait_and_replace_sync_token_client.h" #include "media/renderers/video_frame_yuv_mailboxes_holder.h" #include "third_party/libyuv/include/libyuv.h" #include "third_party/skia/include/core/SkColorSpace.h" #include "third_party/skia/include/core/SkImage.h" #include "third_party/skia/include/core/SkImageGenerator.h" #include "third_party/skia/include/core/SkImageInfo.h" #include "third_party/skia/include/gpu/GrBackendSurface.h" #include "third_party/skia/include/gpu/GrDirectContext.h" #include "third_party/skia/include/gpu/ganesh/SkImageGanesh.h" #include "third_party/skia/include/gpu/ganesh/gl/GrGLBackendSurface.h" #include "third_party/skia/include/gpu/gl/GrGLTypes.h" #include "ui/gfx/geometry/rect_f.h" #include "ui/gfx/geometry/skia_conversions.h" // Skia internal format depends on a platform. On Android it is ABGR, on others // it's ARGB. YUV_MATRIX(), YUV_ORDER() conditionally remap YUV to YVU for ABGR. #if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \ SK_A32_SHIFT == 24 #define OUTPUT_ARGB … #define LIBYUV_ABGR_TO_ARGB … #define YUV_MATRIX(matrix) … #define YUV_ORDER(y, y_stride, u, u_stride, v, v_stride) … #define GBR_TO_RGB_ORDER(y, y_stride, u, u_stride, v, v_stride) … #define LIBYUV_NV12_TO_ARGB_MATRIX … #define SHARED_IMAGE_FORMAT … #elif SK_R32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_B32_SHIFT == 16 && \ SK_A32_SHIFT == 24 #define OUTPUT_ARGB … #define LIBYUV_ABGR_TO_ARGB … #define YUV_MATRIX … #define YUV_ORDER … #define GBR_TO_RGB_ORDER … #define LIBYUV_NV12_TO_ARGB_MATRIX … #define SHARED_IMAGE_FORMAT … #else #error Unexpected Skia ARGB_8888 layout! #endif namespace media { namespace { // This class keeps the last image drawn. // We delete the temporary resource if it is not used for 3 seconds. const int kTemporaryResourceDeletionDelay = …; // Seconds; // Helper class that begins/ends access to a mailbox within a scope. The mailbox // must have been imported into |texture|. class ScopedSharedImageAccess { … }; const gpu::MailboxHolder& GetVideoFrameMailboxHolder(VideoFrame* video_frame) { … } // Wraps a GL RGBA texture into a SkImage. sk_sp<SkImage> WrapGLTexture( GLenum target, GLuint texture_id, const gfx::Size& size, viz::RasterContextProvider* raster_context_provider, bool texture_origin_is_top_left) { … } void BindAndTexImage2D(gpu::gles2::GLES2Interface* gl, unsigned int target, unsigned int texture, unsigned int internal_format, unsigned int format, unsigned int type, int level, const gfx::Size& size) { … } void CopyMailboxToTexture(gpu::gles2::GLES2Interface* gl, const gfx::Size& coded_size, const gfx::Rect& visible_rect, const gpu::Mailbox& source_mailbox, const gpu::SyncToken& source_sync_token, unsigned int target, unsigned int texture, unsigned int internal_format, unsigned int format, unsigned int type, int level, bool premultiply_alpha, bool flip_y) { … } // Update |video_frame|'s release sync token to reflect the work done in |ri|, // and ensure that |video_frame| be kept remain alive until |ri|'s commands have // been completed. This is implemented for both gpu::gles2::GLES2Interface and // gpu::raster::RasterInterface. This function is critical to ensure that // |video_frame|'s resources not be returned until they are no longer in use. // https://crbug.com/819914 (software video decode frame corruption) // https://crbug.com/1237100 (camera capture reuse corruption) void SynchronizeVideoFrameRead(scoped_refptr<VideoFrame> video_frame, gpu::raster::RasterInterface* ri, gpu::ContextSupport* context_support) { … } void SynchronizeVideoFrameRead(scoped_refptr<VideoFrame> video_frame, gpu::gles2::GLES2Interface* gl, gpu::ContextSupport* context_support) { … } const libyuv::YuvConstants* GetYuvContantsForColorSpace(SkYUVColorSpace cs) { … } libyuv::FilterMode ToLibyuvFilterMode( PaintCanvasVideoRenderer::FilterMode filter) { … } size_t NumConvertVideoFrameToRGBPixelsTasks(const VideoFrame* video_frame) { … } void ConvertVideoFrameToRGBPixelsTask(const VideoFrame* video_frame, void* rgb_pixels, size_t row_bytes, bool premultiply_alpha, libyuv::FilterMode filter, size_t task_index, size_t n_tasks, base::RepeatingClosure* done) { … } #if !BUILDFLAG(IS_ANDROID) // Valid gl texture internal format that can try to use direct uploading path. bool ValidFormatForDirectUploading( viz::RasterContextProvider* raster_context_provider, GrGLenum format, unsigned int type) { … } #endif std::tuple<SkYUVAInfo::PlaneConfig, SkYUVAInfo::Subsampling> VideoPixelFormatAsSkYUVAInfoValues(VideoPixelFormat format) { … } #if !BUILDFLAG(IS_ANDROID) // Controls whether the one-copy path when copying a VideoFrame to a GL texture // is enabled or disabled. The one-copy path being enabled is the default // production state, with this Feature being used to be able to disable this // path for performance testing. BASE_FEATURE(…); #endif // !BUILDFLAG(IS_ANDROID) } // anonymous namespace // Generates an RGB image from a VideoFrame. Convert YUV to RGB plain on GPU. class VideoImageGenerator : public cc::PaintImageGenerator { … }; class VideoTextureBacking : public cc::TextureBacking { … }; PaintCanvasVideoRenderer::PaintCanvasVideoRenderer() : … { … } PaintCanvasVideoRenderer::~PaintCanvasVideoRenderer() = default; void PaintCanvasVideoRenderer::Paint( scoped_refptr<VideoFrame> video_frame, cc::PaintCanvas* canvas, const gfx::RectF& dest_rect, cc::PaintFlags& flags, VideoTransformation video_transformation, viz::RasterContextProvider* raster_context_provider) { … } void PaintCanvasVideoRenderer::Copy( scoped_refptr<VideoFrame> video_frame, cc::PaintCanvas* canvas, viz::RasterContextProvider* raster_context_provider) { … } namespace { // libyuv doesn't support all 9-, 10- nor 12-bit pixel formats yet. This // function creates a regular 8-bit video frame which we can give to libyuv. scoped_refptr<VideoFrame> DownShiftHighbitVideoFrame( const VideoFrame* video_frame) { … } // Converts 16-bit data to |out| buffer of specified GL |type|. // When the |format| is RGBA, the converted value is fed as luminance. void FlipAndConvertY16(const VideoFrame* video_frame, uint8_t* out, unsigned format, unsigned type, bool flip_y, size_t output_row_bytes) { … } // Common functionality of PaintCanvasVideoRenderer's TexImage2D and // TexSubImage2D. Allocates a buffer required for conversion and converts // |frame| content to desired |format|. Returns true if calling glTex(Sub)Image // is supported for provided |frame| format and parameters. bool TexImageHelper(VideoFrame* frame, unsigned format, unsigned type, bool flip_y, scoped_refptr<DataBuffer>* temp_buffer) { … } // Upload the |frame| data to temporary texture of |temp_format|, // |temp_internalformat| and |temp_type| and then copy intermediate texture // subimage to destination |texture|. The destination |texture| is bound to the // |target| before the call. void TextureSubImageUsingIntermediate(unsigned target, unsigned texture, gpu::gles2::GLES2Interface* gl, VideoFrame* frame, int temp_internalformat, unsigned temp_format, unsigned temp_type, int level, int xoffset, int yoffset, bool flip_y, bool premultiply_alpha) { … } } // anonymous namespace // static void PaintCanvasVideoRenderer::ConvertVideoFrameToRGBPixels( const VideoFrame* video_frame, void* rgb_pixels, size_t row_bytes, bool premultiply_alpha, FilterMode filter, bool disable_threading) { … } // static viz::SharedImageFormat PaintCanvasVideoRenderer::GetRGBPixelsOutputFormat() { … } bool PaintCanvasVideoRenderer::CopyVideoFrameTexturesToGLTexture( viz::RasterContextProvider* raster_context_provider, gpu::gles2::GLES2Interface* destination_gl, const gpu::Capabilities& destination_gl_capabilities, scoped_refptr<VideoFrame> video_frame, unsigned int target, unsigned int texture, unsigned int internal_format, unsigned int format, unsigned int type, int level, bool premultiply_alpha, bool flip_y) { … } #if !BUILDFLAG(IS_ANDROID) bool PaintCanvasVideoRenderer::UploadVideoFrameToGLTexture( viz::RasterContextProvider* raster_context_provider, gpu::gles2::GLES2Interface* destination_gl, const gpu::Capabilities& destination_gl_capabilities, scoped_refptr<VideoFrame> video_frame, unsigned int target, unsigned int texture, unsigned int internal_format, unsigned int format, unsigned int type, bool flip_y) { … } #endif // !BUILDFLAG(IS_ANDROID) bool PaintCanvasVideoRenderer::CopyVideoFrameYUVDataToGLTexture( viz::RasterContextProvider* raster_context_provider, gpu::gles2::GLES2Interface* destination_gl, const gpu::Capabilities& destination_gl_capabilities, scoped_refptr<VideoFrame> video_frame, unsigned int target, unsigned int texture, unsigned int internal_format, unsigned int format, unsigned int type, int level, bool premultiply_alpha, bool flip_y) { … } bool PaintCanvasVideoRenderer::TexImage2D( unsigned target, unsigned texture, gpu::gles2::GLES2Interface* gl, const gpu::Capabilities& gpu_capabilities, VideoFrame* frame, int level, int internalformat, unsigned format, unsigned type, bool flip_y, bool premultiply_alpha) { … } bool PaintCanvasVideoRenderer::TexSubImage2D(unsigned target, gpu::gles2::GLES2Interface* gl, VideoFrame* frame, int level, unsigned format, unsigned type, int xoffset, int yoffset, bool flip_y, bool premultiply_alpha) { … } void PaintCanvasVideoRenderer::ResetCache() { … } PaintCanvasVideoRenderer::Cache::Cache(VideoFrame::ID frame_id) : … { … } PaintCanvasVideoRenderer::Cache::~Cache() = default; bool PaintCanvasVideoRenderer::Cache::Recycle() { … } bool PaintCanvasVideoRenderer::UpdateLastImage( scoped_refptr<VideoFrame> video_frame, viz::RasterContextProvider* raster_context_provider, bool allow_wrap_texture) { … } bool PaintCanvasVideoRenderer::CanUseCopyVideoFrameToSharedImage( const VideoFrame& video_frame) { … } gpu::SyncToken PaintCanvasVideoRenderer::CopyVideoFrameToSharedImage( viz::RasterContextProvider* raster_context_provider, scoped_refptr<VideoFrame> video_frame, const gpu::MailboxHolder& destination, bool use_visible_rect) { … } PaintCanvasVideoRenderer::YUVTextureCache::YUVTextureCache() = default; PaintCanvasVideoRenderer::YUVTextureCache::~YUVTextureCache() { … } void PaintCanvasVideoRenderer::YUVTextureCache::Reset() { … } gfx::Size PaintCanvasVideoRenderer::LastImageDimensionsForTesting() { … } bool PaintCanvasVideoRenderer::CacheBackingWrapsTexture() const { … } } // namespace media
Codebase Browser
chromium