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

// This file was automatically generated with:
// ../../ui/gfx/x/gen_xproto.py \
//    ../../third_party/xcbproto/src \
//    gen/ui/gfx/x \
//    bigreq \
//    composite \
//    damage \
//    dpms \
//    dri2 \
//    dri3 \
//    ge \
//    glx \
//    present \
//    randr \
//    record \
//    render \
//    res \
//    screensaver \
//    shape \
//    shm \
//    sync \
//    xc_misc \
//    xevie \
//    xf86dri \
//    xf86vidmode \
//    xfixes \
//    xinerama \
//    xinput \
//    xkb \
//    xprint \
//    xproto \
//    xselinux \
//    xtest \
//    xv \
//    xvmc

#ifndef UI_GFX_X_GENERATED_PROTOS_XV_H_
#define UI_GFX_X_GENERATED_PROTOS_XV_H_

#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <vector>

#include "base/component_export.h"
#include "base/files/scoped_file.h"
#include "base/memory/ref_counted_memory.h"
#include "base/memory/scoped_refptr.h"
#include "shm.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "ui/gfx/x/error.h"
#include "ui/gfx/x/ref_counted_fd.h"
#include "xproto.h"

namespace x11 {

class Connection;

template <typename Reply>
struct Response;

template <typename Reply>
class Future;

class COMPONENT_EXPORT(X11) Xv {
 public:
  static constexpr unsigned major_version = 2;
  static constexpr unsigned minor_version = 2;

  Xv(Connection* connection, const x11::QueryExtensionReply& info);

  uint8_t present() const { return info_.present; }
  uint8_t major_opcode() const { return info_.major_opcode; }
  uint8_t first_event() const { return info_.first_event; }
  uint8_t first_error() const { return info_.first_error; }

  Connection* connection() const { return connection_; }

  enum class Port : uint32_t {};

  enum class Encoding : uint32_t {};

  enum class Type : int {
    InputMask = 1 << 0,
    OutputMask = 1 << 1,
    VideoMask = 1 << 2,
    StillMask = 1 << 3,
    ImageMask = 1 << 4,
  };

  enum class ImageFormatInfoType : int {
    RGB = 0,
    YUV = 1,
  };

  enum class ImageFormatInfoFormat : int {
    Packed = 0,
    Planar = 1,
  };

  enum class AttributeFlag : int {
    Gettable = 1 << 0,
    Settable = 1 << 1,
  };

  enum class VideoNotifyReason : int {
    Started = 0,
    Stopped = 1,
    Busy = 2,
    Preempted = 3,
    HardError = 4,
  };

  enum class ScanlineOrder : int {
    TopToBottom = 0,
    BottomToTop = 1,
  };

  enum class GrabPortStatus : int {
    Success = 0,
    BadExtension = 1,
    AlreadyGrabbed = 2,
    InvalidTime = 3,
    BadReply = 4,
    BadAlloc = 5,
  };

  struct Rational {
    int32_t numerator{};
    int32_t denominator{};
  };

  struct Format {
    VisualId visual{};
    uint8_t depth{};
  };

  struct AdaptorInfo {
    Port base_id{};
    uint16_t num_ports{};
    Type type{};
    std::string name{};
    std::vector<Format> formats{};
  };

  struct EncodingInfo {
    Encoding encoding{};
    uint16_t width{};
    uint16_t height{};
    Rational rate{};
    std::string name{};
  };

  struct Image {
    uint32_t id{};
    uint16_t width{};
    uint16_t height{};
    std::vector<uint32_t> pitches{};
    std::vector<uint32_t> offsets{};
    std::vector<uint8_t> data{};
  };

  struct AttributeInfo {
    AttributeFlag flags{};
    int32_t min{};
    int32_t max{};
    std::string name{};
  };

  struct ImageFormatInfo {
    uint32_t id{};
    ImageFormatInfoType type{};
    ImageOrder byte_order{};
    std::array<uint8_t, 16> guid{};
    uint8_t bpp{};
    uint8_t num_planes{};
    uint8_t depth{};
    uint32_t red_mask{};
    uint32_t green_mask{};
    uint32_t blue_mask{};
    ImageFormatInfoFormat format{};
    uint32_t y_sample_bits{};
    uint32_t u_sample_bits{};
    uint32_t v_sample_bits{};
    uint32_t vhorz_y_period{};
    uint32_t vhorz_u_period{};
    uint32_t vhorz_v_period{};
    uint32_t vvert_y_period{};
    uint32_t vvert_u_period{};
    uint32_t vvert_v_period{};
    std::array<uint8_t, 32> vcomp_order{};
    ScanlineOrder vscanline_order{};
  };

  struct BadPortError : public x11::Error {
    uint16_t sequence{};

    std::string ToString() const override;
  };

  struct BadEncodingError : public x11::Error {
    uint16_t sequence{};

    std::string ToString() const override;
  };

  struct BadControlError : public x11::Error {
    uint16_t sequence{};

    std::string ToString() const override;
  };

  struct VideoNotifyEvent {
    static constexpr int type_id = 81;
    static constexpr uint8_t opcode = 0;
    bool send_event{};
    VideoNotifyReason reason{};
    uint16_t sequence{};
    Time time{};
    Drawable drawable{};
    Port port{};

    x11::Window* GetWindow() {
      return reinterpret_cast<x11::Window*>(&drawable);
    }
  };

  struct PortNotifyEvent {
    static constexpr int type_id = 82;
    static constexpr uint8_t opcode = 1;
    bool send_event{};
    uint16_t sequence{};
    Time time{};
    Port port{};
    Atom attribute{};
    int32_t value{};

    x11::Window* GetWindow() { return nullptr; }
  };

  struct QueryExtensionRequest {};

  struct QueryExtensionReply {
    uint16_t sequence{};
    uint16_t major{};
    uint16_t minor{};
  };

  using QueryExtensionResponse = Response<QueryExtensionReply>;

  Future<QueryExtensionReply> QueryExtension(
      const QueryExtensionRequest& request);

  Future<QueryExtensionReply> QueryExtension();

  struct QueryAdaptorsRequest {
    Window window{};
  };

  struct QueryAdaptorsReply {
    uint16_t sequence{};
    std::vector<AdaptorInfo> info{};
  };

  using QueryAdaptorsResponse = Response<QueryAdaptorsReply>;

  Future<QueryAdaptorsReply> QueryAdaptors(const QueryAdaptorsRequest& request);

  Future<QueryAdaptorsReply> QueryAdaptors(const Window& window = {});

  struct QueryEncodingsRequest {
    Port port{};
  };

  struct QueryEncodingsReply {
    uint16_t sequence{};
    std::vector<EncodingInfo> info{};
  };

  using QueryEncodingsResponse = Response<QueryEncodingsReply>;

  Future<QueryEncodingsReply> QueryEncodings(
      const QueryEncodingsRequest& request);

  Future<QueryEncodingsReply> QueryEncodings(const Port& port = {});

  struct GrabPortRequest {
    Port port{};
    Time time{};
  };

  struct GrabPortReply {
    GrabPortStatus result{};
    uint16_t sequence{};
  };

  using GrabPortResponse = Response<GrabPortReply>;

  Future<GrabPortReply> GrabPort(const GrabPortRequest& request);

  Future<GrabPortReply> GrabPort(const Port& port = {}, const Time& time = {});

  struct UngrabPortRequest {
    Port port{};
    Time time{};
  };

  using UngrabPortResponse = Response<void>;

  Future<void> UngrabPort(const UngrabPortRequest& request);

  Future<void> UngrabPort(const Port& port = {}, const Time& time = {});

  struct PutVideoRequest {
    Port port{};
    Drawable drawable{};
    GraphicsContext gc{};
    int16_t vid_x{};
    int16_t vid_y{};
    uint16_t vid_w{};
    uint16_t vid_h{};
    int16_t drw_x{};
    int16_t drw_y{};
    uint16_t drw_w{};
    uint16_t drw_h{};
  };

  using PutVideoResponse = Response<void>;

  Future<void> PutVideo(const PutVideoRequest& request);

  Future<void> PutVideo(const Port& port = {},
                        const Drawable& drawable = {},
                        const GraphicsContext& gc = {},
                        const int16_t& vid_x = {},
                        const int16_t& vid_y = {},
                        const uint16_t& vid_w = {},
                        const uint16_t& vid_h = {},
                        const int16_t& drw_x = {},
                        const int16_t& drw_y = {},
                        const uint16_t& drw_w = {},
                        const uint16_t& drw_h = {});

  struct PutStillRequest {
    Port port{};
    Drawable drawable{};
    GraphicsContext gc{};
    int16_t vid_x{};
    int16_t vid_y{};
    uint16_t vid_w{};
    uint16_t vid_h{};
    int16_t drw_x{};
    int16_t drw_y{};
    uint16_t drw_w{};
    uint16_t drw_h{};
  };

  using PutStillResponse = Response<void>;

  Future<void> PutStill(const PutStillRequest& request);

  Future<void> PutStill(const Port& port = {},
                        const Drawable& drawable = {},
                        const GraphicsContext& gc = {},
                        const int16_t& vid_x = {},
                        const int16_t& vid_y = {},
                        const uint16_t& vid_w = {},
                        const uint16_t& vid_h = {},
                        const int16_t& drw_x = {},
                        const int16_t& drw_y = {},
                        const uint16_t& drw_w = {},
                        const uint16_t& drw_h = {});

  struct GetVideoRequest {
    Port port{};
    Drawable drawable{};
    GraphicsContext gc{};
    int16_t vid_x{};
    int16_t vid_y{};
    uint16_t vid_w{};
    uint16_t vid_h{};
    int16_t drw_x{};
    int16_t drw_y{};
    uint16_t drw_w{};
    uint16_t drw_h{};
  };

  using GetVideoResponse = Response<void>;

  Future<void> GetVideo(const GetVideoRequest& request);

  Future<void> GetVideo(const Port& port = {},
                        const Drawable& drawable = {},
                        const GraphicsContext& gc = {},
                        const int16_t& vid_x = {},
                        const int16_t& vid_y = {},
                        const uint16_t& vid_w = {},
                        const uint16_t& vid_h = {},
                        const int16_t& drw_x = {},
                        const int16_t& drw_y = {},
                        const uint16_t& drw_w = {},
                        const uint16_t& drw_h = {});

  struct GetStillRequest {
    Port port{};
    Drawable drawable{};
    GraphicsContext gc{};
    int16_t vid_x{};
    int16_t vid_y{};
    uint16_t vid_w{};
    uint16_t vid_h{};
    int16_t drw_x{};
    int16_t drw_y{};
    uint16_t drw_w{};
    uint16_t drw_h{};
  };

  using GetStillResponse = Response<void>;

  Future<void> GetStill(const GetStillRequest& request);

  Future<void> GetStill(const Port& port = {},
                        const Drawable& drawable = {},
                        const GraphicsContext& gc = {},
                        const int16_t& vid_x = {},
                        const int16_t& vid_y = {},
                        const uint16_t& vid_w = {},
                        const uint16_t& vid_h = {},
                        const int16_t& drw_x = {},
                        const int16_t& drw_y = {},
                        const uint16_t& drw_w = {},
                        const uint16_t& drw_h = {});

  struct StopVideoRequest {
    Port port{};
    Drawable drawable{};
  };

  using StopVideoResponse = Response<void>;

  Future<void> StopVideo(const StopVideoRequest& request);

  Future<void> StopVideo(const Port& port = {}, const Drawable& drawable = {});

  struct SelectVideoNotifyRequest {
    Drawable drawable{};
    uint8_t onoff{};
  };

  using SelectVideoNotifyResponse = Response<void>;

  Future<void> SelectVideoNotify(const SelectVideoNotifyRequest& request);

  Future<void> SelectVideoNotify(const Drawable& drawable = {},
                                 const uint8_t& onoff = {});

  struct SelectPortNotifyRequest {
    Port port{};
    uint8_t onoff{};
  };

  using SelectPortNotifyResponse = Response<void>;

  Future<void> SelectPortNotify(const SelectPortNotifyRequest& request);

  Future<void> SelectPortNotify(const Port& port = {},
                                const uint8_t& onoff = {});

  struct QueryBestSizeRequest {
    Port port{};
    uint16_t vid_w{};
    uint16_t vid_h{};
    uint16_t drw_w{};
    uint16_t drw_h{};
    uint8_t motion{};
  };

  struct QueryBestSizeReply {
    uint16_t sequence{};
    uint16_t actual_width{};
    uint16_t actual_height{};
  };

  using QueryBestSizeResponse = Response<QueryBestSizeReply>;

  Future<QueryBestSizeReply> QueryBestSize(const QueryBestSizeRequest& request);

  Future<QueryBestSizeReply> QueryBestSize(const Port& port = {},
                                           const uint16_t& vid_w = {},
                                           const uint16_t& vid_h = {},
                                           const uint16_t& drw_w = {},
                                           const uint16_t& drw_h = {},
                                           const uint8_t& motion = {});

  struct SetPortAttributeRequest {
    Port port{};
    Atom attribute{};
    int32_t value{};
  };

  using SetPortAttributeResponse = Response<void>;

  Future<void> SetPortAttribute(const SetPortAttributeRequest& request);

  Future<void> SetPortAttribute(const Port& port = {},
                                const Atom& attribute = {},
                                const int32_t& value = {});

  struct GetPortAttributeRequest {
    Port port{};
    Atom attribute{};
  };

  struct GetPortAttributeReply {
    uint16_t sequence{};
    int32_t value{};
  };

  using GetPortAttributeResponse = Response<GetPortAttributeReply>;

  Future<GetPortAttributeReply> GetPortAttribute(
      const GetPortAttributeRequest& request);

  Future<GetPortAttributeReply> GetPortAttribute(const Port& port = {},
                                                 const Atom& attribute = {});

  struct QueryPortAttributesRequest {
    Port port{};
  };

  struct QueryPortAttributesReply {
    uint16_t sequence{};
    uint32_t text_size{};
    std::vector<AttributeInfo> attributes{};
  };

  using QueryPortAttributesResponse = Response<QueryPortAttributesReply>;

  Future<QueryPortAttributesReply> QueryPortAttributes(
      const QueryPortAttributesRequest& request);

  Future<QueryPortAttributesReply> QueryPortAttributes(const Port& port = {});

  struct ListImageFormatsRequest {
    Port port{};
  };

  struct ListImageFormatsReply {
    uint16_t sequence{};
    std::vector<ImageFormatInfo> format{};
  };

  using ListImageFormatsResponse = Response<ListImageFormatsReply>;

  Future<ListImageFormatsReply> ListImageFormats(
      const ListImageFormatsRequest& request);

  Future<ListImageFormatsReply> ListImageFormats(const Port& port = {});

  struct QueryImageAttributesRequest {
    Port port{};
    uint32_t id{};
    uint16_t width{};
    uint16_t height{};
  };

  struct QueryImageAttributesReply {
    uint16_t sequence{};
    uint32_t data_size{};
    uint16_t width{};
    uint16_t height{};
    std::vector<uint32_t> pitches{};
    std::vector<uint32_t> offsets{};
  };

  using QueryImageAttributesResponse = Response<QueryImageAttributesReply>;

  Future<QueryImageAttributesReply> QueryImageAttributes(
      const QueryImageAttributesRequest& request);

  Future<QueryImageAttributesReply> QueryImageAttributes(
      const Port& port = {},
      const uint32_t& id = {},
      const uint16_t& width = {},
      const uint16_t& height = {});

  struct PutImageRequest {
    Port port{};
    Drawable drawable{};
    GraphicsContext gc{};
    uint32_t id{};
    int16_t src_x{};
    int16_t src_y{};
    uint16_t src_w{};
    uint16_t src_h{};
    int16_t drw_x{};
    int16_t drw_y{};
    uint16_t drw_w{};
    uint16_t drw_h{};
    uint16_t width{};
    uint16_t height{};
    std::vector<uint8_t> data{};
  };

  using PutImageResponse = Response<void>;

  Future<void> PutImage(const PutImageRequest& request);

  Future<void> PutImage(const Port& port = {},
                        const Drawable& drawable = {},
                        const GraphicsContext& gc = {},
                        const uint32_t& id = {},
                        const int16_t& src_x = {},
                        const int16_t& src_y = {},
                        const uint16_t& src_w = {},
                        const uint16_t& src_h = {},
                        const int16_t& drw_x = {},
                        const int16_t& drw_y = {},
                        const uint16_t& drw_w = {},
                        const uint16_t& drw_h = {},
                        const uint16_t& width = {},
                        const uint16_t& height = {},
                        const std::vector<uint8_t>& data = {});

  struct ShmPutImageRequest {
    Port port{};
    Drawable drawable{};
    GraphicsContext gc{};
    Shm::Seg shmseg{};
    uint32_t id{};
    uint32_t offset{};
    int16_t src_x{};
    int16_t src_y{};
    uint16_t src_w{};
    uint16_t src_h{};
    int16_t drw_x{};
    int16_t drw_y{};
    uint16_t drw_w{};
    uint16_t drw_h{};
    uint16_t width{};
    uint16_t height{};
    uint8_t send_event{};
  };

  using ShmPutImageResponse = Response<void>;

  Future<void> ShmPutImage(const ShmPutImageRequest& request);

  Future<void> ShmPutImage(const Port& port = {},
                           const Drawable& drawable = {},
                           const GraphicsContext& gc = {},
                           const Shm::Seg& shmseg = {},
                           const uint32_t& id = {},
                           const uint32_t& offset = {},
                           const int16_t& src_x = {},
                           const int16_t& src_y = {},
                           const uint16_t& src_w = {},
                           const uint16_t& src_h = {},
                           const int16_t& drw_x = {},
                           const int16_t& drw_y = {},
                           const uint16_t& drw_w = {},
                           const uint16_t& drw_h = {},
                           const uint16_t& width = {},
                           const uint16_t& height = {},
                           const uint8_t& send_event = {});

 private:
  Connection* const connection_;
  x11::QueryExtensionReply info_{};
};

}  // namespace x11

inline constexpr x11::Xv::Type operator|(x11::Xv::Type l, x11::Xv::Type r) {
  using T = std::underlying_type_t<x11::Xv::Type>;
  return static_cast<x11::Xv::Type>(static_cast<T>(l) | static_cast<T>(r));
}

inline constexpr x11::Xv::Type operator&(x11::Xv::Type l, x11::Xv::Type r) {
  using T = std::underlying_type_t<x11::Xv::Type>;
  return static_cast<x11::Xv::Type>(static_cast<T>(l) & static_cast<T>(r));
}

inline constexpr x11::Xv::ImageFormatInfoType operator|(
    x11::Xv::ImageFormatInfoType l,
    x11::Xv::ImageFormatInfoType r) {
  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoType>;
  return static_cast<x11::Xv::ImageFormatInfoType>(static_cast<T>(l) |
                                                   static_cast<T>(r));
}

inline constexpr x11::Xv::ImageFormatInfoType operator&(
    x11::Xv::ImageFormatInfoType l,
    x11::Xv::ImageFormatInfoType r) {
  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoType>;
  return static_cast<x11::Xv::ImageFormatInfoType>(static_cast<T>(l) &
                                                   static_cast<T>(r));
}

inline constexpr x11::Xv::ImageFormatInfoFormat operator|(
    x11::Xv::ImageFormatInfoFormat l,
    x11::Xv::ImageFormatInfoFormat r) {
  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoFormat>;
  return static_cast<x11::Xv::ImageFormatInfoFormat>(static_cast<T>(l) |
                                                     static_cast<T>(r));
}

inline constexpr x11::Xv::ImageFormatInfoFormat operator&(
    x11::Xv::ImageFormatInfoFormat l,
    x11::Xv::ImageFormatInfoFormat r) {
  using T = std::underlying_type_t<x11::Xv::ImageFormatInfoFormat>;
  return static_cast<x11::Xv::ImageFormatInfoFormat>(static_cast<T>(l) &
                                                     static_cast<T>(r));
}

inline constexpr x11::Xv::AttributeFlag operator|(x11::Xv::AttributeFlag l,
                                                  x11::Xv::AttributeFlag r) {
  using T = std::underlying_type_t<x11::Xv::AttributeFlag>;
  return static_cast<x11::Xv::AttributeFlag>(static_cast<T>(l) |
                                             static_cast<T>(r));
}

inline constexpr x11::Xv::AttributeFlag operator&(x11::Xv::AttributeFlag l,
                                                  x11::Xv::AttributeFlag r) {
  using T = std::underlying_type_t<x11::Xv::AttributeFlag>;
  return static_cast<x11::Xv::AttributeFlag>(static_cast<T>(l) &
                                             static_cast<T>(r));
}

inline constexpr x11::Xv::VideoNotifyReason operator|(
    x11::Xv::VideoNotifyReason l,
    x11::Xv::VideoNotifyReason r) {
  using T = std::underlying_type_t<x11::Xv::VideoNotifyReason>;
  return static_cast<x11::Xv::VideoNotifyReason>(static_cast<T>(l) |
                                                 static_cast<T>(r));
}

inline constexpr x11::Xv::VideoNotifyReason operator&(
    x11::Xv::VideoNotifyReason l,
    x11::Xv::VideoNotifyReason r) {
  using T = std::underlying_type_t<x11::Xv::VideoNotifyReason>;
  return static_cast<x11::Xv::VideoNotifyReason>(static_cast<T>(l) &
                                                 static_cast<T>(r));
}

inline constexpr x11::Xv::ScanlineOrder operator|(x11::Xv::ScanlineOrder l,
                                                  x11::Xv::ScanlineOrder r) {
  using T = std::underlying_type_t<x11::Xv::ScanlineOrder>;
  return static_cast<x11::Xv::ScanlineOrder>(static_cast<T>(l) |
                                             static_cast<T>(r));
}

inline constexpr x11::Xv::ScanlineOrder operator&(x11::Xv::ScanlineOrder l,
                                                  x11::Xv::ScanlineOrder r) {
  using T = std::underlying_type_t<x11::Xv::ScanlineOrder>;
  return static_cast<x11::Xv::ScanlineOrder>(static_cast<T>(l) &
                                             static_cast<T>(r));
}

inline constexpr x11::Xv::GrabPortStatus operator|(x11::Xv::GrabPortStatus l,
                                                   x11::Xv::GrabPortStatus r) {
  using T = std::underlying_type_t<x11::Xv::GrabPortStatus>;
  return static_cast<x11::Xv::GrabPortStatus>(static_cast<T>(l) |
                                              static_cast<T>(r));
}

inline constexpr x11::Xv::GrabPortStatus operator&(x11::Xv::GrabPortStatus l,
                                                   x11::Xv::GrabPortStatus r) {
  using T = std::underlying_type_t<x11::Xv::GrabPortStatus>;
  return static_cast<x11::Xv::GrabPortStatus>(static_cast<T>(l) &
                                              static_cast<T>(r));
}

#endif  // UI_GFX_X_GENERATED_PROTOS_XV_H_