chromium/media/video/video_encode_accelerator.cc

// Copyright 2013 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/video/video_encode_accelerator.h"

#include <inttypes.h>

#include "base/functional/callback.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "media/base/video_frame.h"

namespace media {

Vp9Metadata::Vp9Metadata() = default;
Vp9Metadata::~Vp9Metadata() = default;
Vp9Metadata::Vp9Metadata(const Vp9Metadata&) = default;

Av1Metadata::Av1Metadata() = default;
Av1Metadata::~Av1Metadata() = default;
Av1Metadata::Av1Metadata(const Av1Metadata&) = default;

BitstreamBufferMetadata::BitstreamBufferMetadata()
    : … { … }
BitstreamBufferMetadata::BitstreamBufferMetadata(
    const BitstreamBufferMetadata& other) = default;
BitstreamBufferMetadata& BitstreamBufferMetadata::operator=(
    const BitstreamBufferMetadata& other) = default;
BitstreamBufferMetadata::BitstreamBufferMetadata(
    BitstreamBufferMetadata&& other) = default;
BitstreamBufferMetadata::BitstreamBufferMetadata(size_t payload_size_bytes,
                                                 bool key_frame,
                                                 base::TimeDelta timestamp)
    : … { … }
BitstreamBufferMetadata::~BitstreamBufferMetadata() = default;

// static
BitstreamBufferMetadata BitstreamBufferMetadata::CreateForDropFrame(
    base::TimeDelta ts,
    uint8_t sid,
    bool end_of_picture) { … }

bool BitstreamBufferMetadata::end_of_picture() const { … }
bool BitstreamBufferMetadata::dropped_frame() const { … }

std::optional<uint8_t> BitstreamBufferMetadata::spatial_idx() const { … }

VideoEncodeAccelerator::Config::Config()
    : … { … }

VideoEncodeAccelerator::Config::Config(const Config& config) = default;

VideoEncodeAccelerator::Config::Config(VideoPixelFormat input_format,
                                       const gfx::Size& input_visible_size,
                                       VideoCodecProfile output_profile,
                                       const Bitrate& bitrate,
                                       uint32_t framerate,
                                       StorageType storage_type,
                                       ContentType content_type)
    : … { … }

VideoEncodeAccelerator::Config::~Config() = default;

std::string VideoEncodeAccelerator::Config::AsHumanReadableString() const { … }

bool VideoEncodeAccelerator::Config::HasTemporalLayer() const { … }

bool VideoEncodeAccelerator::Config::HasSpatialLayer() const { … }

void VideoEncodeAccelerator::Client::NotifyEncoderInfoChange(
    const VideoEncoderInfo& info) { … }

VideoEncodeAccelerator::~VideoEncodeAccelerator() = default;

VideoEncodeAccelerator::SupportedProfile::SupportedProfile()
    : … { … }

VideoEncodeAccelerator::SupportedProfile::SupportedProfile(
    VideoCodecProfile profile,
    const gfx::Size& max_resolution,
    uint32_t max_framerate_numerator,
    uint32_t max_framerate_denominator,
    SupportedRateControlMode rc_modes,
    const std::vector<SVCScalabilityMode>& scalability_modes,
    const std::vector<VideoPixelFormat>& gpu_supported_pixel_formats)
    : … { … }

VideoEncodeAccelerator::SupportedProfile::SupportedProfile(
    const SupportedProfile& other) = default;

VideoEncodeAccelerator::SupportedProfile::~SupportedProfile() = default;

void VideoEncodeAccelerator::Encode(
    scoped_refptr<VideoFrame> frame,
    const VideoEncoder::EncodeOptions& options) { … }

void VideoEncodeAccelerator::Flush(FlushCallback flush_callback) { … }

bool VideoEncodeAccelerator::IsFlushSupported() { … }

bool VideoEncodeAccelerator::IsGpuFrameResizeSupported() { … }

void VideoEncodeAccelerator::RequestEncodingParametersChange(
    const VideoBitrateAllocation& bitrate_allocation,
    uint32_t framerate,
    const std::optional<gfx::Size>& size) { … }

bool operator==(const VideoEncodeAccelerator::SupportedProfile& l,
                const VideoEncodeAccelerator::SupportedProfile& r) { … }

bool operator==(const H264Metadata& l, const H264Metadata& r) { … }

bool operator==(const H265Metadata& l, const H265Metadata& r) { … }

bool operator==(const Vp8Metadata& l, const Vp8Metadata& r) { … }

bool operator==(const Vp9Metadata& l, const Vp9Metadata& r) { … }

bool operator==(const Av1Metadata& l, const Av1Metadata& r) { … }

bool operator==(const BitstreamBufferMetadata& l,
                const BitstreamBufferMetadata& r) { … }

bool operator==(const VideoEncodeAccelerator::Config::SpatialLayer& l,
                const VideoEncodeAccelerator::Config::SpatialLayer& r) { … }

bool operator==(const VideoEncodeAccelerator::Config& l,
                const VideoEncodeAccelerator::Config& r) { … }
}  // namespace media

namespace std {

void default_delete<media::VideoEncodeAccelerator>::operator()(
    media::VideoEncodeAccelerator* vea) const { … }

}  // namespace std