video_encode_accelerator.mojom-blink.cc

// media/mojo/mojom/video_encode_accelerator.mojom-blink.cc is auto generated by mojom_bindings_generator.py, do not edit

// 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.

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "media/mojo/mojom/video_encode_accelerator.mojom-blink.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/features.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "media/mojo/mojom/video_encode_accelerator.mojom-params-data.h"
#include "media/mojo/mojom/video_encode_accelerator.mojom-shared-message-ids.h"

#include "media/mojo/mojom/video_encode_accelerator.mojom-blink-import-headers.h"
#include "media/mojo/mojom/video_encode_accelerator.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


namespace media::mojom::blink {
VideoEncodeAcceleratorSupportedProfile::VideoEncodeAcceleratorSupportedProfile()
    : … { … }

VideoEncodeAcceleratorSupportedProfile::VideoEncodeAcceleratorSupportedProfile(
    ::media::mojom::blink::VideoCodecProfile profile_in,
    const ::gfx::Size& min_resolution_in,
    const ::gfx::Size& max_resolution_in,
    uint32_t max_framerate_numerator_in,
    uint32_t max_framerate_denominator_in,
    WTF::Vector<VideoEncodeAcceleratorSupportedRateControlMode> rate_control_modes_in,
    WTF::Vector<::media::mojom::blink::SVCScalabilityMode> scalability_modes_in,
    bool is_software_codec_in,
    WTF::Vector<::media::mojom::blink::VideoPixelFormat> gpu_supported_pixel_formats_in)
    : … { … }

VideoEncodeAcceleratorSupportedProfile::~VideoEncodeAcceleratorSupportedProfile() = default;

void VideoEncodeAcceleratorSupportedProfile::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool VideoEncodeAcceleratorSupportedProfile::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
VariableBitratePeak::VariableBitratePeak()
    : … { … }

VariableBitratePeak::VariableBitratePeak(
    uint32_t bps_in)
    : … { … }

VariableBitratePeak::~VariableBitratePeak() = default;
size_t VariableBitratePeak::Hash(size_t seed) const { … }

void VariableBitratePeak::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool VariableBitratePeak::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
VideoBitrateAllocation::VideoBitrateAllocation()
    : … { … }

VideoBitrateAllocation::VideoBitrateAllocation(
    WTF::Vector<uint32_t> bitrates_in,
    VariableBitratePeakPtr variable_bitrate_peak_in)
    : … { … }

VideoBitrateAllocation::~VideoBitrateAllocation() = default;

void VideoBitrateAllocation::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool VideoBitrateAllocation::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
SpatialLayer::SpatialLayer()
    : … { … }

SpatialLayer::SpatialLayer(
    int32_t width_in,
    int32_t height_in,
    uint32_t bitrate_bps_in,
    uint32_t framerate_in,
    uint8_t max_qp_in,
    uint8_t num_of_temporal_layers_in)
    : … { … }

SpatialLayer::~SpatialLayer() = default;
size_t SpatialLayer::Hash(size_t seed) const { … }

void SpatialLayer::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool SpatialLayer::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ConstantBitrate::ConstantBitrate()
    : … { … }

ConstantBitrate::ConstantBitrate(
    uint32_t target_bps_in)
    : … { … }

ConstantBitrate::~ConstantBitrate() = default;
size_t ConstantBitrate::Hash(size_t seed) const { … }

void ConstantBitrate::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ConstantBitrate::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
VariableBitrate::VariableBitrate()
    : … { … }

VariableBitrate::VariableBitrate(
    uint32_t target_bps_in,
    uint32_t peak_bps_in)
    : … { … }

VariableBitrate::~VariableBitrate() = default;
size_t VariableBitrate::Hash(size_t seed) const { … }

void VariableBitrate::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool VariableBitrate::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ExternalBitrate::ExternalBitrate() { … }

ExternalBitrate::~ExternalBitrate() = default;
size_t ExternalBitrate::Hash(size_t seed) const { … }

void ExternalBitrate::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ExternalBitrate::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
VideoEncodeAcceleratorConfig::VideoEncodeAcceleratorConfig()
    : … { … }

VideoEncodeAcceleratorConfig::VideoEncodeAcceleratorConfig(
    ::media::mojom::blink::VideoPixelFormat input_format_in,
    const ::gfx::Size& input_visible_size_in,
    ::media::mojom::blink::VideoCodecProfile output_profile_in,
    BitratePtr bitrate_in,
    uint32_t framerate_in,
    VideoEncodeAcceleratorConfig::StorageType storage_type_in,
    VideoEncodeAcceleratorConfig::ContentType content_type_in,
    uint32_t gop_length_in,
    bool has_gop_length_in,
    uint8_t h264_output_level_in,
    bool has_h264_output_level_in,
    bool is_constrained_h264_in,
    uint8_t drop_frame_thresh_percentage_in,
    WTF::Vector<SpatialLayerPtr> spatial_layers_in,
    ::media::mojom::blink::SVCInterLayerPredMode inter_layer_pred_in,
    bool require_low_delay_in,
    VideoEncodeAcceleratorConfig::EncoderType required_encoder_type_in)
    : … { … }

VideoEncodeAcceleratorConfig::~VideoEncodeAcceleratorConfig() = default;

void VideoEncodeAcceleratorConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool VideoEncodeAcceleratorConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
VideoEncodeOptions::VideoEncodeOptions()
    : … { … }

VideoEncodeOptions::VideoEncodeOptions(
    bool force_keyframe_in,
    int32_t quantizer_in)
    : … { … }

VideoEncodeOptions::~VideoEncodeOptions() = default;
size_t VideoEncodeOptions::Hash(size_t seed) const { … }

void VideoEncodeOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool VideoEncodeOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
DropFrameMetadata::DropFrameMetadata()
    : … { … }

DropFrameMetadata::DropFrameMetadata(
    uint8_t spatial_idx_in,
    bool end_of_picture_in)
    : … { … }

DropFrameMetadata::~DropFrameMetadata() = default;
size_t DropFrameMetadata::Hash(size_t seed) const { … }

void DropFrameMetadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool DropFrameMetadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
H264Metadata::H264Metadata()
    : … { … }

H264Metadata::H264Metadata(
    uint8_t temporal_idx_in,
    bool layer_sync_in)
    : … { … }

H264Metadata::~H264Metadata() = default;
size_t H264Metadata::Hash(size_t seed) const { … }

void H264Metadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool H264Metadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
H265Metadata::H265Metadata()
    : … { … }

H265Metadata::H265Metadata(
    uint8_t temporal_idx_in)
    : … { … }

H265Metadata::~H265Metadata() = default;
size_t H265Metadata::Hash(size_t seed) const { … }

void H265Metadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool H265Metadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Vp8Metadata::Vp8Metadata()
    : … { … }

Vp8Metadata::Vp8Metadata(
    bool non_reference_in,
    uint8_t temporal_idx_in,
    bool layer_sync_in)
    : … { … }

Vp8Metadata::~Vp8Metadata() = default;
size_t Vp8Metadata::Hash(size_t seed) const { … }

void Vp8Metadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Vp8Metadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Vp9Metadata::Vp9Metadata()
    : … { … }

Vp9Metadata::Vp9Metadata(
    bool inter_pic_predicted_in,
    bool temporal_up_switch_in,
    bool referenced_by_upper_spatial_layers_in,
    bool reference_lower_spatial_layers_in,
    bool end_of_picture_in,
    uint8_t temporal_idx_in,
    uint8_t spatial_idx_in,
    WTF::Vector<::gfx::Size> spatial_layer_resolutions_in,
    uint8_t begin_active_spatial_layer_index_in,
    uint8_t end_active_spatial_layer_index_in,
    WTF::Vector<uint8_t> p_diffs_in)
    : … { … }

Vp9Metadata::~Vp9Metadata() = default;

void Vp9Metadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Vp9Metadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Av1Metadata::Av1Metadata()
    : … { … }

Av1Metadata::Av1Metadata(
    uint8_t temporal_idx_in)
    : … { … }

Av1Metadata::~Av1Metadata() = default;
size_t Av1Metadata::Hash(size_t seed) const { … }

void Av1Metadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Av1Metadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
BitstreamBufferMetadata::BitstreamBufferMetadata()
    : … { … }

BitstreamBufferMetadata::BitstreamBufferMetadata(
    uint32_t payload_size_bytes_in,
    bool key_frame_in,
    ::base::TimeDelta timestamp_in,
    int32_t qp_in,
    OptionalMetadataPtr optional_metadata_in,
    const std::optional<::gfx::Size>& encoded_size_in,
    const std::optional<::gfx::ColorSpace>& encoded_color_space_in)
    : … { … }

BitstreamBufferMetadata::~BitstreamBufferMetadata() = default;

void BitstreamBufferMetadata::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool BitstreamBufferMetadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Bitrate::Bitrate() : … { … }

Bitrate::~Bitrate() { … }


void Bitrate::set_constant(
    ConstantBitratePtr constant) { … }
void Bitrate::set_variable(
    VariableBitratePtr variable) { … }
void Bitrate::set_external(
    ExternalBitratePtr external) { … }

void Bitrate::DestroyActive() { … }
size_t Bitrate::Hash(size_t seed) const { … }

bool Bitrate::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
OptionalMetadata::OptionalMetadata() : … { … }

OptionalMetadata::~OptionalMetadata() { … }


void OptionalMetadata::set_drop(
    DropFrameMetadataPtr drop) { … }
void OptionalMetadata::set_h264(
    H264MetadataPtr h264) { … }
void OptionalMetadata::set_h265(
    H265MetadataPtr h265) { … }
void OptionalMetadata::set_vp8(
    Vp8MetadataPtr vp8) { … }
void OptionalMetadata::set_vp9(
    Vp9MetadataPtr vp9) { … }
void OptionalMetadata::set_av1(
    Av1MetadataPtr av1) { … }

void OptionalMetadata::DestroyActive() { … }

bool OptionalMetadata::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char VideoEncodeAcceleratorProvider::Name_[] = …;

VideoEncodeAcceleratorProvider::IPCStableHashFunction VideoEncodeAcceleratorProvider::MessageToMethodInfo_(mojo::Message& message) { … }


const char* VideoEncodeAcceleratorProvider::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VideoEncodeAcceleratorProvider::CreateVideoEncodeAccelerator_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAcceleratorProvider::GetVideoEncodeAcceleratorSupportedProfiles_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class VideoEncodeAcceleratorProvider_GetVideoEncodeAcceleratorSupportedProfiles_ForwardToCallback
    : public mojo::MessageReceiver { … };

VideoEncodeAcceleratorProviderProxy::VideoEncodeAcceleratorProviderProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void VideoEncodeAcceleratorProviderProxy::CreateVideoEncodeAccelerator(
    ::mojo::PendingReceiver<VideoEncodeAccelerator> in_receiver) { … }

void VideoEncodeAcceleratorProviderProxy::GetVideoEncodeAcceleratorSupportedProfiles(
    GetVideoEncodeAcceleratorSupportedProfilesCallback callback) { … }
class VideoEncodeAcceleratorProvider_GetVideoEncodeAcceleratorSupportedProfiles_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool VideoEncodeAcceleratorProvider_GetVideoEncodeAcceleratorSupportedProfiles_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void VideoEncodeAcceleratorProvider_GetVideoEncodeAcceleratorSupportedProfiles_ProxyToResponder::Run(
    WTF::Vector<VideoEncodeAcceleratorSupportedProfilePtr> in_profiles) { … }

// static
bool VideoEncodeAcceleratorProviderStubDispatch::Accept(
    VideoEncodeAcceleratorProvider* impl,
    mojo::Message* message) { … }

// static
bool VideoEncodeAcceleratorProviderStubDispatch::AcceptWithResponder(
    VideoEncodeAcceleratorProvider* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kVideoEncodeAcceleratorProviderValidationInfo[] = …;

bool VideoEncodeAcceleratorProviderRequestValidator::Accept(mojo::Message* message) { … }

bool VideoEncodeAcceleratorProviderResponseValidator::Accept(mojo::Message* message) { … }
const char VideoEncodeAcceleratorProviderFactory::Name_[] = …;

VideoEncodeAcceleratorProviderFactory::IPCStableHashFunction VideoEncodeAcceleratorProviderFactory::MessageToMethodInfo_(mojo::Message& message) { … }


const char* VideoEncodeAcceleratorProviderFactory::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VideoEncodeAcceleratorProviderFactory::CreateVideoEncodeAcceleratorProvider_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

VideoEncodeAcceleratorProviderFactoryProxy::VideoEncodeAcceleratorProviderFactoryProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void VideoEncodeAcceleratorProviderFactoryProxy::CreateVideoEncodeAcceleratorProvider(
    ::mojo::PendingReceiver<VideoEncodeAcceleratorProvider> in_receiver) { … }

// static
bool VideoEncodeAcceleratorProviderFactoryStubDispatch::Accept(
    VideoEncodeAcceleratorProviderFactory* impl,
    mojo::Message* message) { … }

// static
bool VideoEncodeAcceleratorProviderFactoryStubDispatch::AcceptWithResponder(
    VideoEncodeAcceleratorProviderFactory* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kVideoEncodeAcceleratorProviderFactoryValidationInfo[] = …;

bool VideoEncodeAcceleratorProviderFactoryRequestValidator::Accept(mojo::Message* message) { … }

const char VideoEncodeAccelerator::Name_[] = …;

VideoEncodeAccelerator::IPCStableHashFunction VideoEncodeAccelerator::MessageToMethodInfo_(mojo::Message& message) { … }


const char* VideoEncodeAccelerator::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VideoEncodeAccelerator::Initialize_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAccelerator::Encode_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAccelerator::UseOutputBitstreamBuffer_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAccelerator::RequestEncodingParametersChangeWithLayers_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAccelerator::RequestEncodingParametersChangeWithBitrate_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAccelerator::IsFlushSupported_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAccelerator::Flush_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool VideoEncodeAccelerator::Initialize(VideoEncodeAcceleratorConfigPtr config, ::mojo::PendingAssociatedRemote<VideoEncodeAcceleratorClient> client, ::mojo::PendingRemote<::media::mojom::blink::MediaLog> media_log, bool* out_result) { … }
bool VideoEncodeAccelerator::IsFlushSupported(bool* out_result) { … }
class VideoEncodeAccelerator_Initialize_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class VideoEncodeAccelerator_Initialize_ForwardToCallback
    : public mojo::MessageReceiver { … };

class VideoEncodeAccelerator_Encode_ForwardToCallback
    : public mojo::MessageReceiver { … };
class VideoEncodeAccelerator_IsFlushSupported_HandleSyncResponse
    : public mojo::MessageReceiver { … };

class VideoEncodeAccelerator_IsFlushSupported_ForwardToCallback
    : public mojo::MessageReceiver { … };

class VideoEncodeAccelerator_Flush_ForwardToCallback
    : public mojo::MessageReceiver { … };

VideoEncodeAcceleratorProxy::VideoEncodeAcceleratorProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }
bool VideoEncodeAcceleratorProxy::Initialize(
    VideoEncodeAcceleratorConfigPtr param_config, ::mojo::PendingAssociatedRemote<VideoEncodeAcceleratorClient> param_client, ::mojo::PendingRemote<::media::mojom::blink::MediaLog> param_media_log, bool* out_param_result) { … }

void VideoEncodeAcceleratorProxy::Initialize(
    VideoEncodeAcceleratorConfigPtr in_config, ::mojo::PendingAssociatedRemote<VideoEncodeAcceleratorClient> in_client, ::mojo::PendingRemote<::media::mojom::blink::MediaLog> in_media_log, InitializeCallback callback) { … }

void VideoEncodeAcceleratorProxy::Encode(
    ::media::mojom::blink::VideoFramePtr in_frame, VideoEncodeOptionsPtr in_options, EncodeCallback callback) { … }

void VideoEncodeAcceleratorProxy::UseOutputBitstreamBuffer(
    int32_t in_bitstream_buffer_id, ::base::UnsafeSharedMemoryRegion in_region) { … }

void VideoEncodeAcceleratorProxy::RequestEncodingParametersChangeWithLayers(
    VideoBitrateAllocationPtr in_bitrate_allocation, uint32_t in_framerate, const std::optional<::gfx::Size>& in_size) { … }

void VideoEncodeAcceleratorProxy::RequestEncodingParametersChangeWithBitrate(
    BitratePtr in_bitrate, uint32_t in_framerate, const std::optional<::gfx::Size>& in_size) { … }
bool VideoEncodeAcceleratorProxy::IsFlushSupported(
    bool* out_param_result) { … }

void VideoEncodeAcceleratorProxy::IsFlushSupported(
    IsFlushSupportedCallback callback) { … }

void VideoEncodeAcceleratorProxy::Flush(
    FlushCallback callback) { … }
class VideoEncodeAccelerator_Initialize_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool VideoEncodeAccelerator_Initialize_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void VideoEncodeAccelerator_Initialize_ProxyToResponder::Run(
    bool in_result) { … }
bool VideoEncodeAccelerator_Initialize_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class VideoEncodeAccelerator_Encode_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool VideoEncodeAccelerator_Encode_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void VideoEncodeAccelerator_Encode_ProxyToResponder::Run(
    ) { … }
class VideoEncodeAccelerator_IsFlushSupported_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool VideoEncodeAccelerator_IsFlushSupported_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void VideoEncodeAccelerator_IsFlushSupported_ProxyToResponder::Run(
    bool in_result) { … }
bool VideoEncodeAccelerator_IsFlushSupported_HandleSyncResponse::Accept(
    mojo::Message* message) { … }
class VideoEncodeAccelerator_Flush_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool VideoEncodeAccelerator_Flush_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void VideoEncodeAccelerator_Flush_ProxyToResponder::Run(
    bool in_result) { … }

// static
bool VideoEncodeAcceleratorStubDispatch::Accept(
    VideoEncodeAccelerator* impl,
    mojo::Message* message) { … }

// static
bool VideoEncodeAcceleratorStubDispatch::AcceptWithResponder(
    VideoEncodeAccelerator* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kVideoEncodeAcceleratorValidationInfo[] = …;

bool VideoEncodeAcceleratorRequestValidator::Accept(mojo::Message* message) { … }

bool VideoEncodeAcceleratorResponseValidator::Accept(mojo::Message* message) { … }
const char VideoEncodeAcceleratorClient::Name_[] = …;

VideoEncodeAcceleratorClient::IPCStableHashFunction VideoEncodeAcceleratorClient::MessageToMethodInfo_(mojo::Message& message) { … }


const char* VideoEncodeAcceleratorClient::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VideoEncodeAcceleratorClient::RequireBitstreamBuffers_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAcceleratorClient::BitstreamBufferReady_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAcceleratorClient::NotifyErrorStatus_Sym::IPCStableHash() { … }
uint32_t VideoEncodeAcceleratorClient::NotifyEncoderInfoChange_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

VideoEncodeAcceleratorClientProxy::VideoEncodeAcceleratorClientProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void VideoEncodeAcceleratorClientProxy::RequireBitstreamBuffers(
    uint32_t in_input_count, const ::gfx::Size& in_input_coded_size, uint32_t in_output_buffer_size) { … }

void VideoEncodeAcceleratorClientProxy::BitstreamBufferReady(
    int32_t in_bitstream_buffer_id, BitstreamBufferMetadataPtr in_metadata) { … }

void VideoEncodeAcceleratorClientProxy::NotifyErrorStatus(
    ::media::mojom::blink::EncoderStatusPtr in_status) { … }

void VideoEncodeAcceleratorClientProxy::NotifyEncoderInfoChange(
    ::media::mojom::blink::VideoEncoderInfoPtr in_info) { … }

// static
bool VideoEncodeAcceleratorClientStubDispatch::Accept(
    VideoEncodeAcceleratorClient* impl,
    mojo::Message* message) { … }

// static
bool VideoEncodeAcceleratorClientStubDispatch::AcceptWithResponder(
    VideoEncodeAcceleratorClient* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kVideoEncodeAcceleratorClientValidationInfo[] = …;

bool VideoEncodeAcceleratorClientRequestValidator::Accept(mojo::Message* message) { … }



}  // media::mojom::blink


namespace mojo {


// static
bool StructTraits<::media::mojom::blink::VideoEncodeAcceleratorSupportedProfile::DataView, ::media::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr>::Read(
    ::media::mojom::blink::VideoEncodeAcceleratorSupportedProfile::DataView input,
    ::media::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::VariableBitratePeak::DataView, ::media::mojom::blink::VariableBitratePeakPtr>::Read(
    ::media::mojom::blink::VariableBitratePeak::DataView input,
    ::media::mojom::blink::VariableBitratePeakPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::VideoBitrateAllocation::DataView, ::media::mojom::blink::VideoBitrateAllocationPtr>::Read(
    ::media::mojom::blink::VideoBitrateAllocation::DataView input,
    ::media::mojom::blink::VideoBitrateAllocationPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::SpatialLayer::DataView, ::media::mojom::blink::SpatialLayerPtr>::Read(
    ::media::mojom::blink::SpatialLayer::DataView input,
    ::media::mojom::blink::SpatialLayerPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::ConstantBitrate::DataView, ::media::mojom::blink::ConstantBitratePtr>::Read(
    ::media::mojom::blink::ConstantBitrate::DataView input,
    ::media::mojom::blink::ConstantBitratePtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::VariableBitrate::DataView, ::media::mojom::blink::VariableBitratePtr>::Read(
    ::media::mojom::blink::VariableBitrate::DataView input,
    ::media::mojom::blink::VariableBitratePtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::ExternalBitrate::DataView, ::media::mojom::blink::ExternalBitratePtr>::Read(
    ::media::mojom::blink::ExternalBitrate::DataView input,
    ::media::mojom::blink::ExternalBitratePtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::VideoEncodeAcceleratorConfig::DataView, ::media::mojom::blink::VideoEncodeAcceleratorConfigPtr>::Read(
    ::media::mojom::blink::VideoEncodeAcceleratorConfig::DataView input,
    ::media::mojom::blink::VideoEncodeAcceleratorConfigPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::VideoEncodeOptions::DataView, ::media::mojom::blink::VideoEncodeOptionsPtr>::Read(
    ::media::mojom::blink::VideoEncodeOptions::DataView input,
    ::media::mojom::blink::VideoEncodeOptionsPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::DropFrameMetadata::DataView, ::media::mojom::blink::DropFrameMetadataPtr>::Read(
    ::media::mojom::blink::DropFrameMetadata::DataView input,
    ::media::mojom::blink::DropFrameMetadataPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::H264Metadata::DataView, ::media::mojom::blink::H264MetadataPtr>::Read(
    ::media::mojom::blink::H264Metadata::DataView input,
    ::media::mojom::blink::H264MetadataPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::H265Metadata::DataView, ::media::mojom::blink::H265MetadataPtr>::Read(
    ::media::mojom::blink::H265Metadata::DataView input,
    ::media::mojom::blink::H265MetadataPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::Vp8Metadata::DataView, ::media::mojom::blink::Vp8MetadataPtr>::Read(
    ::media::mojom::blink::Vp8Metadata::DataView input,
    ::media::mojom::blink::Vp8MetadataPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::Vp9Metadata::DataView, ::media::mojom::blink::Vp9MetadataPtr>::Read(
    ::media::mojom::blink::Vp9Metadata::DataView input,
    ::media::mojom::blink::Vp9MetadataPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::Av1Metadata::DataView, ::media::mojom::blink::Av1MetadataPtr>::Read(
    ::media::mojom::blink::Av1Metadata::DataView input,
    ::media::mojom::blink::Av1MetadataPtr* output) { … }


// static
bool StructTraits<::media::mojom::blink::BitstreamBufferMetadata::DataView, ::media::mojom::blink::BitstreamBufferMetadataPtr>::Read(
    ::media::mojom::blink::BitstreamBufferMetadata::DataView input,
    ::media::mojom::blink::BitstreamBufferMetadataPtr* output) { … }

// static
bool UnionTraits<::media::mojom::blink::Bitrate::DataView, ::media::mojom::blink::BitratePtr>::Read(
    ::media::mojom::blink::Bitrate::DataView input,
    ::media::mojom::blink::BitratePtr* output) { … }

// static
bool UnionTraits<::media::mojom::blink::OptionalMetadata::DataView, ::media::mojom::blink::OptionalMetadataPtr>::Read(
    ::media::mojom::blink::OptionalMetadata::DataView input,
    ::media::mojom::blink::OptionalMetadataPtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace media::mojom::blink {


void VideoEncodeAcceleratorProviderInterceptorForTesting::CreateVideoEncodeAccelerator(::mojo::PendingReceiver<VideoEncodeAccelerator> receiver) { … }
void VideoEncodeAcceleratorProviderInterceptorForTesting::GetVideoEncodeAcceleratorSupportedProfiles(GetVideoEncodeAcceleratorSupportedProfilesCallback callback) { … }
VideoEncodeAcceleratorProviderAsyncWaiter::VideoEncodeAcceleratorProviderAsyncWaiter(
    VideoEncodeAcceleratorProvider* proxy) : … { … }

VideoEncodeAcceleratorProviderAsyncWaiter::~VideoEncodeAcceleratorProviderAsyncWaiter() = default;

void VideoEncodeAcceleratorProviderAsyncWaiter::GetVideoEncodeAcceleratorSupportedProfiles(
    WTF::Vector<VideoEncodeAcceleratorSupportedProfilePtr>* out_profiles) { … }

WTF::Vector<VideoEncodeAcceleratorSupportedProfilePtr> VideoEncodeAcceleratorProviderAsyncWaiter::GetVideoEncodeAcceleratorSupportedProfiles(
    ) { … }




void VideoEncodeAcceleratorProviderFactoryInterceptorForTesting::CreateVideoEncodeAcceleratorProvider(::mojo::PendingReceiver<VideoEncodeAcceleratorProvider> receiver) { … }
VideoEncodeAcceleratorProviderFactoryAsyncWaiter::VideoEncodeAcceleratorProviderFactoryAsyncWaiter(
    VideoEncodeAcceleratorProviderFactory* proxy) : … { … }

VideoEncodeAcceleratorProviderFactoryAsyncWaiter::~VideoEncodeAcceleratorProviderFactoryAsyncWaiter() = default;




void VideoEncodeAcceleratorInterceptorForTesting::Initialize(VideoEncodeAcceleratorConfigPtr config, ::mojo::PendingAssociatedRemote<VideoEncodeAcceleratorClient> client, ::mojo::PendingRemote<::media::mojom::blink::MediaLog> media_log, InitializeCallback callback) { … }
void VideoEncodeAcceleratorInterceptorForTesting::Encode(::media::mojom::blink::VideoFramePtr frame, VideoEncodeOptionsPtr options, EncodeCallback callback) { … }
void VideoEncodeAcceleratorInterceptorForTesting::UseOutputBitstreamBuffer(int32_t bitstream_buffer_id, ::base::UnsafeSharedMemoryRegion region) { … }
void VideoEncodeAcceleratorInterceptorForTesting::RequestEncodingParametersChangeWithLayers(VideoBitrateAllocationPtr bitrate_allocation, uint32_t framerate, const std::optional<::gfx::Size>& size) { … }
void VideoEncodeAcceleratorInterceptorForTesting::RequestEncodingParametersChangeWithBitrate(BitratePtr bitrate, uint32_t framerate, const std::optional<::gfx::Size>& size) { … }
void VideoEncodeAcceleratorInterceptorForTesting::IsFlushSupported(IsFlushSupportedCallback callback) { … }
void VideoEncodeAcceleratorInterceptorForTesting::Flush(FlushCallback callback) { … }
VideoEncodeAcceleratorAsyncWaiter::VideoEncodeAcceleratorAsyncWaiter(
    VideoEncodeAccelerator* proxy) : … { … }

VideoEncodeAcceleratorAsyncWaiter::~VideoEncodeAcceleratorAsyncWaiter() = default;

void VideoEncodeAcceleratorAsyncWaiter::Initialize(
    VideoEncodeAcceleratorConfigPtr config, ::mojo::PendingAssociatedRemote<VideoEncodeAcceleratorClient> client, ::mojo::PendingRemote<::media::mojom::blink::MediaLog> media_log, bool* out_result) { … }

bool VideoEncodeAcceleratorAsyncWaiter::Initialize(
    VideoEncodeAcceleratorConfigPtr config, ::mojo::PendingAssociatedRemote<VideoEncodeAcceleratorClient> client, ::mojo::PendingRemote<::media::mojom::blink::MediaLog> media_log) { … }

void VideoEncodeAcceleratorAsyncWaiter::Encode(
    ::media::mojom::blink::VideoFramePtr frame, VideoEncodeOptionsPtr options) { … }



void VideoEncodeAcceleratorAsyncWaiter::IsFlushSupported(
    bool* out_result) { … }

bool VideoEncodeAcceleratorAsyncWaiter::IsFlushSupported(
    ) { … }

void VideoEncodeAcceleratorAsyncWaiter::Flush(
    bool* out_result) { … }

bool VideoEncodeAcceleratorAsyncWaiter::Flush(
    ) { … }




void VideoEncodeAcceleratorClientInterceptorForTesting::RequireBitstreamBuffers(uint32_t input_count, const ::gfx::Size& input_coded_size, uint32_t output_buffer_size) { … }
void VideoEncodeAcceleratorClientInterceptorForTesting::BitstreamBufferReady(int32_t bitstream_buffer_id, BitstreamBufferMetadataPtr metadata) { … }
void VideoEncodeAcceleratorClientInterceptorForTesting::NotifyErrorStatus(::media::mojom::blink::EncoderStatusPtr status) { … }
void VideoEncodeAcceleratorClientInterceptorForTesting::NotifyEncoderInfoChange(::media::mojom::blink::VideoEncoderInfoPtr info) { … }
VideoEncodeAcceleratorClientAsyncWaiter::VideoEncodeAcceleratorClientAsyncWaiter(
    VideoEncodeAcceleratorClient* proxy) : … { … }

VideoEncodeAcceleratorClientAsyncWaiter::~VideoEncodeAcceleratorClientAsyncWaiter() = default;






}  // media::mojom::blink


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/media/mojo/mojom/video_encode_accelerator.mojom-blink.cc
