chromium/media/gpu/chromeos/video_frame_resource.cc

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/gpu/chromeos/video_frame_resource.h"

#include "base/functional/callback_helpers.h"
#include "base/memory/scoped_refptr.h"
#include "media/gpu/chromeos/platform_video_frame_utils.h"

namespace media {

scoped_refptr<VideoFrameResource> VideoFrameResource::Create(
    scoped_refptr<VideoFrame> frame) { … }

scoped_refptr<const VideoFrameResource> VideoFrameResource::CreateConst(
    scoped_refptr<const VideoFrame> frame) { … }

VideoFrameResource::VideoFrameResource(scoped_refptr<const VideoFrame> frame)
    : … { … }

VideoFrameResource::~VideoFrameResource() = default;

VideoFrameResource* VideoFrameResource::AsVideoFrameResource() { … }

bool VideoFrameResource::IsMappable() const { … }

const uint8_t* VideoFrameResource::data(size_t plane) const { … }

uint8_t* VideoFrameResource::writable_data(size_t plane) { … }

const uint8_t* VideoFrameResource::visible_data(size_t plane) const { … }

uint8_t* VideoFrameResource::GetWritableVisibleData(size_t plane) { … }

size_t VideoFrameResource::NumDmabufFds() const { … }

int VideoFrameResource::GetDmabufFd(size_t i) const { … }

scoped_refptr<const gfx::NativePixmapDmaBuf>
VideoFrameResource::GetNativePixmapDmaBuf() const { … }

gfx::GpuMemoryBufferHandle VideoFrameResource::CreateGpuMemoryBufferHandle()
    const { … }

std::unique_ptr<VideoFrame::ScopedMapping>
VideoFrameResource::MapGMBOrSharedImage() const { … }

gfx::GenericSharedMemoryId VideoFrameResource::GetSharedMemoryId() const { … }

const VideoFrameLayout& VideoFrameResource::layout() const { … }

VideoPixelFormat VideoFrameResource::format() const { … }

int VideoFrameResource::stride(size_t plane) const { … }

VideoFrame::StorageType VideoFrameResource::storage_type() const { … }

int VideoFrameResource::row_bytes(size_t plane) const { … }

const gfx::Size& VideoFrameResource::coded_size() const { … }

const gfx::Rect& VideoFrameResource::visible_rect() const { … }

const gfx::Size& VideoFrameResource::natural_size() const { … }

gfx::ColorSpace VideoFrameResource::ColorSpace() const { … }

void VideoFrameResource::set_color_space(const gfx::ColorSpace& color_space) { … }

const std::optional<gfx::HDRMetadata>& VideoFrameResource::hdr_metadata()
    const { … }

void VideoFrameResource::set_hdr_metadata(
    const std::optional<gfx::HDRMetadata>& hdr_metadata) { … }

const VideoFrameMetadata& VideoFrameResource::metadata() const { … }

VideoFrameMetadata& VideoFrameResource::metadata() { … }

void VideoFrameResource::set_metadata(const VideoFrameMetadata& metadata) { … }

base::TimeDelta VideoFrameResource::timestamp() const { … }

void VideoFrameResource::set_timestamp(base::TimeDelta timestamp) { … }

void VideoFrameResource::AddDestructionObserver(base::OnceClosure callback) { … }

scoped_refptr<FrameResource> VideoFrameResource::CreateWrappingFrame(
    const gfx::Rect& visible_rect,
    const gfx::Size& natural_size) { … }

std::string VideoFrameResource::AsHumanReadableString() const { … }

gfx::GpuMemoryBufferHandle
VideoFrameResource::GetGpuMemoryBufferHandleForTesting() const { … }

scoped_refptr<VideoFrame> VideoFrameResource::GetMutableVideoFrame() { … }

scoped_refptr<const VideoFrame> VideoFrameResource::GetVideoFrame() const { … }

}  // namespace media