// media/mojo/mojom/video_encode_accelerator.mojom-shared-internal.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_SHARED_INTERNAL_H_
#define MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_SHARED_INTERNAL_H_
#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/message_fragment.h"
#include "mojo/public/c/system/macros.h"
#include "media/mojo/mojom/media_log.mojom-shared-internal.h"
#include "media/mojo/mojom/media_types.mojom-shared-internal.h"
#include "media/mojo/mojom/video_encoder_info.mojom-shared-internal.h"
#include "mojo/public/mojom/base/shared_memory.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared-internal.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-shared-internal.h"
#include "sandbox/policy/mojom/sandbox.mojom-shared-internal.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-shared-internal.h"
#include "ui/gfx/mojom/color_space.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/native_enum_data.h"
#include "mojo/public/interfaces/bindings/native_struct.mojom-shared-internal.h"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace media::mojom {
namespace internal {
class VideoEncodeAcceleratorSupportedProfile_Data;
class EncodeCommandBufferId_Data;
class VariableBitratePeak_Data;
class VideoBitrateAllocation_Data;
class SpatialLayer_Data;
class ConstantBitrate_Data;
class VariableBitrate_Data;
class ExternalBitrate_Data;
class VideoEncodeAcceleratorConfig_Data;
class VideoEncodeOptions_Data;
class DropFrameMetadata_Data;
class H264Metadata_Data;
class Vp8Metadata_Data;
class Vp9Metadata_Data;
class SVCGenericMetadata_Data;
class YuvPsnr_Data;
class BitstreamBufferMetadata_Data;
class Bitrate_Data;
class OptionalMetadata_Data;

struct VideoEncodeAcceleratorSupportedRateControlMode_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct VideoEncodeAcceleratorConfig_ContentType_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct VideoEncodeAcceleratorConfig_StorageType_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct VideoEncodeAcceleratorConfig_EncoderType_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

#pragma pack(push, 1)


class  Bitrate_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  Bitrate_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~Bitrate_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<Bitrate_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class Bitrate_Tag : uint32_t {

    
    kConstant,
    
    kVariable,
    
    kExternal,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::ConstantBitrate_Data> f_constant;
    mojo::internal::Pointer<internal::VariableBitrate_Data> f_variable;
    mojo::internal::Pointer<internal::ExternalBitrate_Data> f_external;
    uint64_t unknown;
  };

  uint32_t size;
  Bitrate_Tag tag;
  Union_ data;
};
static_assert(sizeof(Bitrate_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(Bitrate_Data)");


class  OptionalMetadata_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  OptionalMetadata_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~OptionalMetadata_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<OptionalMetadata_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class OptionalMetadata_Tag : uint32_t {

    
    kDrop,
    
    kH264,
    
    kVp8,
    
    kVp9,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::DropFrameMetadata_Data> f_drop;
    mojo::internal::Pointer<internal::H264Metadata_Data> f_h264;
    mojo::internal::Pointer<internal::Vp8Metadata_Data> f_vp8;
    mojo::internal::Pointer<internal::Vp9Metadata_Data> f_vp9;
    uint64_t unknown;
  };

  uint32_t size;
  OptionalMetadata_Tag tag;
  Union_ data;
};
static_assert(sizeof(OptionalMetadata_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(OptionalMetadata_Data)");
class  VideoEncodeAcceleratorSupportedProfile_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t profile;
  uint32_t max_framerate_numerator;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> min_resolution;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> max_resolution;
  uint32_t max_framerate_denominator;
  uint8_t is_software_codec : 1;
  uint8_t supports_gpu_shared_images : 1;
  uint8_t chroma_sampling_$flag : 1;
  uint8_t bit_depth_$flag : 1;
  uint8_t bit_depth_$value;
  uint8_t pad9_[2];
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> rate_control_modes;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> scalability_modes;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> gpu_supported_pixel_formats;
  int32_t chroma_sampling_$value;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<VideoEncodeAcceleratorSupportedProfile_Data>;

  VideoEncodeAcceleratorSupportedProfile_Data();
  ~VideoEncodeAcceleratorSupportedProfile_Data() = delete;
};
static_assert(sizeof(VideoEncodeAcceleratorSupportedProfile_Data) == 72,
              "Bad sizeof(VideoEncodeAcceleratorSupportedProfile_Data)");
// Used by VideoEncodeAcceleratorSupportedProfile::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VideoEncodeAcceleratorSupportedProfile_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VideoEncodeAcceleratorSupportedProfile_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VideoEncodeAcceleratorSupportedProfile_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VideoEncodeAcceleratorSupportedProfile_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VideoEncodeAcceleratorSupportedProfile_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  EncodeCommandBufferId_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::UnguessableToken_Data> channel_token;
  int32_t route_id;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<EncodeCommandBufferId_Data>;

  EncodeCommandBufferId_Data();
  ~EncodeCommandBufferId_Data() = delete;
};
static_assert(sizeof(EncodeCommandBufferId_Data) == 24,
              "Bad sizeof(EncodeCommandBufferId_Data)");
// Used by EncodeCommandBufferId::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct EncodeCommandBufferId_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  EncodeCommandBufferId_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~EncodeCommandBufferId_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<EncodeCommandBufferId_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    EncodeCommandBufferId_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  VariableBitratePeak_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t bps;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<VariableBitratePeak_Data>;

  VariableBitratePeak_Data();
  ~VariableBitratePeak_Data() = delete;
};
static_assert(sizeof(VariableBitratePeak_Data) == 16,
              "Bad sizeof(VariableBitratePeak_Data)");
// Used by VariableBitratePeak::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VariableBitratePeak_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VariableBitratePeak_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VariableBitratePeak_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VariableBitratePeak_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VariableBitratePeak_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  VideoBitrateAllocation_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint32_t>> bitrates;
  mojo::internal::Pointer<internal::VariableBitratePeak_Data> variable_bitrate_peak;

 private:
  friend class mojo::internal::MessageFragment<VideoBitrateAllocation_Data>;

  VideoBitrateAllocation_Data();
  ~VideoBitrateAllocation_Data() = delete;
};
static_assert(sizeof(VideoBitrateAllocation_Data) == 24,
              "Bad sizeof(VideoBitrateAllocation_Data)");
// Used by VideoBitrateAllocation::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VideoBitrateAllocation_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VideoBitrateAllocation_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VideoBitrateAllocation_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VideoBitrateAllocation_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VideoBitrateAllocation_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SpatialLayer_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t width;
  int32_t height;
  uint32_t bitrate_bps;
  uint32_t framerate;
  uint8_t max_qp;
  uint8_t num_of_temporal_layers;
  uint8_t padfinal_[6];

 private:
  friend class mojo::internal::MessageFragment<SpatialLayer_Data>;

  SpatialLayer_Data();
  ~SpatialLayer_Data() = delete;
};
static_assert(sizeof(SpatialLayer_Data) == 32,
              "Bad sizeof(SpatialLayer_Data)");
// Used by SpatialLayer::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SpatialLayer_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SpatialLayer_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SpatialLayer_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SpatialLayer_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SpatialLayer_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ConstantBitrate_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t target_bps;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<ConstantBitrate_Data>;

  ConstantBitrate_Data();
  ~ConstantBitrate_Data() = delete;
};
static_assert(sizeof(ConstantBitrate_Data) == 16,
              "Bad sizeof(ConstantBitrate_Data)");
// Used by ConstantBitrate::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ConstantBitrate_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ConstantBitrate_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ConstantBitrate_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ConstantBitrate_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ConstantBitrate_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  VariableBitrate_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t target_bps;
  uint32_t peak_bps;

 private:
  friend class mojo::internal::MessageFragment<VariableBitrate_Data>;

  VariableBitrate_Data();
  ~VariableBitrate_Data() = delete;
};
static_assert(sizeof(VariableBitrate_Data) == 16,
              "Bad sizeof(VariableBitrate_Data)");
// Used by VariableBitrate::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VariableBitrate_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VariableBitrate_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VariableBitrate_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VariableBitrate_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VariableBitrate_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ExternalBitrate_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

 private:
  friend class mojo::internal::MessageFragment<ExternalBitrate_Data>;

  ExternalBitrate_Data();
  ~ExternalBitrate_Data() = delete;
};
static_assert(sizeof(ExternalBitrate_Data) == 8,
              "Bad sizeof(ExternalBitrate_Data)");
// Used by ExternalBitrate::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ExternalBitrate_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ExternalBitrate_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ExternalBitrate_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ExternalBitrate_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ExternalBitrate_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  VideoEncodeAcceleratorConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t input_format;
  int32_t output_profile;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> input_visible_size;
  internal::Bitrate_Data bitrate;
  uint32_t framerate;
  int32_t storage_type;
  int32_t content_type;
  uint32_t gop_length;
  uint8_t has_gop_length : 1;
  uint8_t has_h264_output_level : 1;
  uint8_t is_constrained_h264 : 1;
  uint8_t require_low_delay : 1;
  uint8_t manual_reference_buffer_control : 1;
  uint8_t h264_output_level;
  uint8_t drop_frame_thresh_percentage;
  uint8_t pad14_[1];
  int32_t inter_layer_pred;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::SpatialLayer_Data>>> spatial_layers;
  int32_t required_encoder_type;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<VideoEncodeAcceleratorConfig_Data>;

  VideoEncodeAcceleratorConfig_Data();
  ~VideoEncodeAcceleratorConfig_Data() = delete;
};
static_assert(sizeof(VideoEncodeAcceleratorConfig_Data) == 80,
              "Bad sizeof(VideoEncodeAcceleratorConfig_Data)");
// Used by VideoEncodeAcceleratorConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VideoEncodeAcceleratorConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VideoEncodeAcceleratorConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VideoEncodeAcceleratorConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VideoEncodeAcceleratorConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VideoEncodeAcceleratorConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  VideoEncodeOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t force_keyframe : 1;
  uint8_t quantizer_$flag : 1;
  uint8_t update_buffer_$flag : 1;
  uint8_t update_buffer_$value;
  uint8_t pad3_[2];
  int32_t quantizer_$value;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> reference_buffers;

 private:
  friend class mojo::internal::MessageFragment<VideoEncodeOptions_Data>;

  VideoEncodeOptions_Data();
  ~VideoEncodeOptions_Data() = delete;
};
static_assert(sizeof(VideoEncodeOptions_Data) == 24,
              "Bad sizeof(VideoEncodeOptions_Data)");
// Used by VideoEncodeOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VideoEncodeOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VideoEncodeOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VideoEncodeOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VideoEncodeOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VideoEncodeOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  DropFrameMetadata_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t spatial_idx;
  uint8_t end_of_picture : 1;
  uint8_t padfinal_[6];

 private:
  friend class mojo::internal::MessageFragment<DropFrameMetadata_Data>;

  DropFrameMetadata_Data();
  ~DropFrameMetadata_Data() = delete;
};
static_assert(sizeof(DropFrameMetadata_Data) == 16,
              "Bad sizeof(DropFrameMetadata_Data)");
// Used by DropFrameMetadata::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct DropFrameMetadata_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  DropFrameMetadata_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~DropFrameMetadata_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<DropFrameMetadata_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    DropFrameMetadata_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  H264Metadata_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t temporal_idx;
  uint8_t layer_sync : 1;
  uint8_t padfinal_[6];

 private:
  friend class mojo::internal::MessageFragment<H264Metadata_Data>;

  H264Metadata_Data();
  ~H264Metadata_Data() = delete;
};
static_assert(sizeof(H264Metadata_Data) == 16,
              "Bad sizeof(H264Metadata_Data)");
// Used by H264Metadata::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct H264Metadata_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  H264Metadata_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~H264Metadata_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<H264Metadata_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    H264Metadata_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  Vp8Metadata_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t non_reference : 1;
  uint8_t layer_sync : 1;
  uint8_t temporal_idx;
  uint8_t padfinal_[6];

 private:
  friend class mojo::internal::MessageFragment<Vp8Metadata_Data>;

  Vp8Metadata_Data();
  ~Vp8Metadata_Data() = delete;
};
static_assert(sizeof(Vp8Metadata_Data) == 16,
              "Bad sizeof(Vp8Metadata_Data)");
// Used by Vp8Metadata::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct Vp8Metadata_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  Vp8Metadata_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~Vp8Metadata_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<Vp8Metadata_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Vp8Metadata_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  Vp9Metadata_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t inter_pic_predicted : 1;
  uint8_t temporal_up_switch : 1;
  uint8_t referenced_by_upper_spatial_layers : 1;
  uint8_t reference_lower_spatial_layers : 1;
  uint8_t end_of_picture : 1;
  uint8_t temporal_idx;
  uint8_t spatial_idx;
  uint8_t begin_active_spatial_layer_index;
  uint8_t end_active_spatial_layer_index;
  uint8_t pad8_[3];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<::gfx::mojom::internal::Size_Data>>> spatial_layer_resolutions;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> p_diffs;

 private:
  friend class mojo::internal::MessageFragment<Vp9Metadata_Data>;

  Vp9Metadata_Data();
  ~Vp9Metadata_Data() = delete;
};
static_assert(sizeof(Vp9Metadata_Data) == 32,
              "Bad sizeof(Vp9Metadata_Data)");
// Used by Vp9Metadata::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct Vp9Metadata_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  Vp9Metadata_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~Vp9Metadata_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<Vp9Metadata_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Vp9Metadata_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SVCGenericMetadata_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t follow_svc_spec : 1;
  uint8_t reference_flags_$flag : 1;
  uint8_t refresh_flags_$flag : 1;
  uint8_t temporal_idx;
  uint8_t spatial_idx;
  uint8_t pad4_[1];
  uint16_t reference_flags_$value;
  uint16_t refresh_flags_$value;

 private:
  friend class mojo::internal::MessageFragment<SVCGenericMetadata_Data>;

  SVCGenericMetadata_Data();
  ~SVCGenericMetadata_Data() = delete;
};
static_assert(sizeof(SVCGenericMetadata_Data) == 16,
              "Bad sizeof(SVCGenericMetadata_Data)");
// Used by SVCGenericMetadata::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SVCGenericMetadata_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SVCGenericMetadata_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SVCGenericMetadata_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SVCGenericMetadata_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SVCGenericMetadata_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  YuvPsnr_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  double y;
  double u;
  double v;

 private:
  friend class mojo::internal::MessageFragment<YuvPsnr_Data>;

  YuvPsnr_Data();
  ~YuvPsnr_Data() = delete;
};
static_assert(sizeof(YuvPsnr_Data) == 32,
              "Bad sizeof(YuvPsnr_Data)");
// Used by YuvPsnr::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct YuvPsnr_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  YuvPsnr_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~YuvPsnr_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<YuvPsnr_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    YuvPsnr_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  BitstreamBufferMetadata_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t payload_size_bytes;
  uint8_t key_frame : 1;
  uint8_t pad1_[3];
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> timestamp;
  int32_t qp;
  uint8_t pad3_[4];
  internal::OptionalMetadata_Data optional_metadata;
  mojo::internal::Pointer<internal::SVCGenericMetadata_Data> svc_generic;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> encoded_size;
  mojo::internal::Pointer<::gfx::mojom::internal::ColorSpace_Data> encoded_color_space;
  mojo::internal::Pointer<internal::YuvPsnr_Data> yuv_psnr;

 private:
  friend class mojo::internal::MessageFragment<BitstreamBufferMetadata_Data>;

  BitstreamBufferMetadata_Data();
  ~BitstreamBufferMetadata_Data() = delete;
};
static_assert(sizeof(BitstreamBufferMetadata_Data) == 80,
              "Bad sizeof(BitstreamBufferMetadata_Data)");
// Used by BitstreamBufferMetadata::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct BitstreamBufferMetadata_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  BitstreamBufferMetadata_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~BitstreamBufferMetadata_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<BitstreamBufferMetadata_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    BitstreamBufferMetadata_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};

#pragma pack(pop)

}  // namespace internal

}  // media::mojom

#endif  // MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_SHARED_INTERNAL_H_