haven/nexgb/xv/xv.go

// Package xv is the X client API for the XVideo extension.
package xv

// This file is automatically generated from xv.xml. Edit at your peril!

import (
	xgb "janouch.name/haven/nexgb"

	"janouch.name/haven/nexgb/shm"
	"janouch.name/haven/nexgb/xproto"
)

const (
	MajorVersion = 2
	MinorVersion = 2
)

// Init must be called before using the XVideo extension.
func Init(c *xgb.Conn) error {
	reply, err := xproto.QueryExtension(c, 6, "XVideo").Reply()
	switch {
	case err != nil:
		return err
	case !reply.Present:
		return xgb.Errorf("No extension named XVideo could be found on on the server.")
	}

	c.ExtLock.Lock()
	c.Extensions["XVideo"] = reply.MajorOpcode
	c.ExtLock.Unlock()
	for evNum, fun := range xgb.NewExtEventFuncs["XVideo"] {
		xgb.NewEventFuncs[int(reply.FirstEvent)+evNum] = fun
	}
	for errNum, fun := range xgb.NewExtErrorFuncs["XVideo"] {
		xgb.NewErrorFuncs[int(reply.FirstError)+errNum] = fun
	}
	return nil
}

func init() {
	xgb.NewExtEventFuncs["XVideo"] = make(map[int]xgb.NewEventFun)
	xgb.NewExtErrorFuncs["XVideo"] = make(map[int]xgb.NewErrorFun)
}

type AdaptorInfo struct {
	BaseId     Port
	NameSize   uint16
	NumPorts   uint16
	NumFormats uint16
	Type       byte
	// padding: 1 bytes
	Name string // size: xgb.Pad((int(NameSize) * 1))
	// alignment gap to multiple of 4
	Formats []Format // size: xgb.Pad((int(NumFormats) * 8))
}

// AdaptorInfoRead reads a byte slice into a AdaptorInfo value.
func AdaptorInfoRead(buf []byte, v *AdaptorInfo) int {
	b := 0

	v.BaseId = Port(xgb.Get32(buf[b:]))
	b += 4

	v.NameSize = xgb.Get16(buf[b:])
	b += 2

	v.NumPorts = xgb.Get16(buf[b:])
	b += 2

	v.NumFormats = xgb.Get16(buf[b:])
	b += 2

	v.Type = buf[b]
	b += 1

	b += 1 // padding

	{
		byteString := make([]byte, v.NameSize)
		copy(byteString[:v.NameSize], buf[b:])
		v.Name = string(byteString)
		b += int(v.NameSize)
	}

	b = (b + 3) & ^3 // alignment gap

	v.Formats = make([]Format, v.NumFormats)
	b += FormatReadList(buf[b:], v.Formats)

	return b
}

// AdaptorInfoReadList reads a byte slice into a list of AdaptorInfo values.
func AdaptorInfoReadList(buf []byte, dest []AdaptorInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = AdaptorInfo{}
		b += AdaptorInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Bytes writes a AdaptorInfo value to a byte slice.
func (v AdaptorInfo) Bytes() []byte {
	buf := make([]byte, (((12 + xgb.Pad((int(v.NameSize) * 1))) + 4) + xgb.Pad((int(v.NumFormats) * 8))))
	b := 0

	xgb.Put32(buf[b:], uint32(v.BaseId))
	b += 4

	xgb.Put16(buf[b:], v.NameSize)
	b += 2

	xgb.Put16(buf[b:], v.NumPorts)
	b += 2

	xgb.Put16(buf[b:], v.NumFormats)
	b += 2

	buf[b] = v.Type
	b += 1

	b += 1 // padding

	copy(buf[b:], v.Name[:v.NameSize])
	b += int(v.NameSize)

	b = (b + 3) & ^3 // alignment gap

	b += FormatListBytes(buf[b:], v.Formats)

	return buf[:b]
}

// AdaptorInfoListBytes writes a list of AdaptorInfo values to a byte slice.
func AdaptorInfoListBytes(buf []byte, list []AdaptorInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}
	return xgb.Pad(b)
}

// AdaptorInfoListSize computes the size (bytes) of a list of AdaptorInfo values.
func AdaptorInfoListSize(list []AdaptorInfo) int {
	size := 0
	for _, item := range list {
		size += (((12 + xgb.Pad((int(item.NameSize) * 1))) + 4) + xgb.Pad((int(item.NumFormats) * 8)))
	}
	return size
}

const (
	AttributeFlagGettable = 1
	AttributeFlagSettable = 2
)

type AttributeInfo struct {
	Flags uint32
	Min   int32
	Max   int32
	Size  uint32
	Name  string // size: xgb.Pad((int(Size) * 1))
	// alignment gap to multiple of 4
}

// AttributeInfoRead reads a byte slice into a AttributeInfo value.
func AttributeInfoRead(buf []byte, v *AttributeInfo) int {
	b := 0

	v.Flags = xgb.Get32(buf[b:])
	b += 4

	v.Min = int32(xgb.Get32(buf[b:]))
	b += 4

	v.Max = int32(xgb.Get32(buf[b:]))
	b += 4

	v.Size = xgb.Get32(buf[b:])
	b += 4

	{
		byteString := make([]byte, v.Size)
		copy(byteString[:v.Size], buf[b:])
		v.Name = string(byteString)
		b += int(v.Size)
	}

	b = (b + 3) & ^3 // alignment gap

	return b
}

// AttributeInfoReadList reads a byte slice into a list of AttributeInfo values.
func AttributeInfoReadList(buf []byte, dest []AttributeInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = AttributeInfo{}
		b += AttributeInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Bytes writes a AttributeInfo value to a byte slice.
func (v AttributeInfo) Bytes() []byte {
	buf := make([]byte, ((16 + xgb.Pad((int(v.Size) * 1))) + 4))
	b := 0

	xgb.Put32(buf[b:], v.Flags)
	b += 4

	xgb.Put32(buf[b:], uint32(v.Min))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Max))
	b += 4

	xgb.Put32(buf[b:], v.Size)
	b += 4

	copy(buf[b:], v.Name[:v.Size])
	b += int(v.Size)

	b = (b + 3) & ^3 // alignment gap

	return buf[:b]
}

// AttributeInfoListBytes writes a list of AttributeInfo values to a byte slice.
func AttributeInfoListBytes(buf []byte, list []AttributeInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}
	return xgb.Pad(b)
}

// AttributeInfoListSize computes the size (bytes) of a list of AttributeInfo values.
func AttributeInfoListSize(list []AttributeInfo) int {
	size := 0
	for _, item := range list {
		size += ((16 + xgb.Pad((int(item.Size) * 1))) + 4)
	}
	return size
}

// BadBadControl is the error number for a BadBadControl.
const BadBadControl = 2

type BadControlError struct {
	Sequence uint16
	NiceName string
}

// BadControlErrorNew constructs a BadControlError value that implements xgb.Error from a byte slice.
func BadControlErrorNew(buf []byte) xgb.Error {
	v := BadControlError{}
	v.NiceName = "BadControl"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

// SequenceId returns the sequence id attached to the BadBadControl error.
// This is mostly used internally.
func (err BadControlError) SequenceId() uint16 {
	return err.Sequence
}

// BadId returns the 'BadValue' number if one exists for the BadBadControl error. If no bad value exists, 0 is returned.
func (err BadControlError) BadId() uint32 {
	return 0
}

// Error returns a rudimentary string representation of the BadBadControl error.

func (err BadControlError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadBadControl {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XVideo"][2] = BadControlErrorNew
}

// BadBadEncoding is the error number for a BadBadEncoding.
const BadBadEncoding = 1

type BadEncodingError struct {
	Sequence uint16
	NiceName string
}

// BadEncodingErrorNew constructs a BadEncodingError value that implements xgb.Error from a byte slice.
func BadEncodingErrorNew(buf []byte) xgb.Error {
	v := BadEncodingError{}
	v.NiceName = "BadEncoding"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

// SequenceId returns the sequence id attached to the BadBadEncoding error.
// This is mostly used internally.
func (err BadEncodingError) SequenceId() uint16 {
	return err.Sequence
}

// BadId returns the 'BadValue' number if one exists for the BadBadEncoding error. If no bad value exists, 0 is returned.
func (err BadEncodingError) BadId() uint32 {
	return 0
}

// Error returns a rudimentary string representation of the BadBadEncoding error.

func (err BadEncodingError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadBadEncoding {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XVideo"][1] = BadEncodingErrorNew
}

// BadBadPort is the error number for a BadBadPort.
const BadBadPort = 0

type BadPortError struct {
	Sequence uint16
	NiceName string
}

// BadPortErrorNew constructs a BadPortError value that implements xgb.Error from a byte slice.
func BadPortErrorNew(buf []byte) xgb.Error {
	v := BadPortError{}
	v.NiceName = "BadPort"

	b := 1 // skip error determinant
	b += 1 // don't read error number

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	return v
}

// SequenceId returns the sequence id attached to the BadBadPort error.
// This is mostly used internally.
func (err BadPortError) SequenceId() uint16 {
	return err.Sequence
}

// BadId returns the 'BadValue' number if one exists for the BadBadPort error. If no bad value exists, 0 is returned.
func (err BadPortError) BadId() uint32 {
	return 0
}

// Error returns a rudimentary string representation of the BadBadPort error.

func (err BadPortError) Error() string {
	fieldVals := make([]string, 0, 0)
	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
	return "BadBadPort {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtErrorFuncs["XVideo"][0] = BadPortErrorNew
}

type Encoding uint32

func NewEncodingId(c *xgb.Conn) (Encoding, error) {
	id, err := c.NewId()
	if err != nil {
		return 0, err
	}
	return Encoding(id), nil
}

type EncodingInfo struct {
	Encoding Encoding
	NameSize uint16
	Width    uint16
	Height   uint16
	// padding: 2 bytes
	Rate Rational
	Name string // size: xgb.Pad((int(NameSize) * 1))
	// alignment gap to multiple of 4
}

// EncodingInfoRead reads a byte slice into a EncodingInfo value.
func EncodingInfoRead(buf []byte, v *EncodingInfo) int {
	b := 0

	v.Encoding = Encoding(xgb.Get32(buf[b:]))
	b += 4

	v.NameSize = xgb.Get16(buf[b:])
	b += 2

	v.Width = xgb.Get16(buf[b:])
	b += 2

	v.Height = xgb.Get16(buf[b:])
	b += 2

	b += 2 // padding

	v.Rate = Rational{}
	b += RationalRead(buf[b:], &v.Rate)

	{
		byteString := make([]byte, v.NameSize)
		copy(byteString[:v.NameSize], buf[b:])
		v.Name = string(byteString)
		b += int(v.NameSize)
	}

	b = (b + 3) & ^3 // alignment gap

	return b
}

// EncodingInfoReadList reads a byte slice into a list of EncodingInfo values.
func EncodingInfoReadList(buf []byte, dest []EncodingInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = EncodingInfo{}
		b += EncodingInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Bytes writes a EncodingInfo value to a byte slice.
func (v EncodingInfo) Bytes() []byte {
	buf := make([]byte, ((20 + xgb.Pad((int(v.NameSize) * 1))) + 4))
	b := 0

	xgb.Put32(buf[b:], uint32(v.Encoding))
	b += 4

	xgb.Put16(buf[b:], v.NameSize)
	b += 2

	xgb.Put16(buf[b:], v.Width)
	b += 2

	xgb.Put16(buf[b:], v.Height)
	b += 2

	b += 2 // padding

	{
		structBytes := v.Rate.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}

	copy(buf[b:], v.Name[:v.NameSize])
	b += int(v.NameSize)

	b = (b + 3) & ^3 // alignment gap

	return buf[:b]
}

// EncodingInfoListBytes writes a list of EncodingInfo values to a byte slice.
func EncodingInfoListBytes(buf []byte, list []EncodingInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}
	return xgb.Pad(b)
}

// EncodingInfoListSize computes the size (bytes) of a list of EncodingInfo values.
func EncodingInfoListSize(list []EncodingInfo) int {
	size := 0
	for _, item := range list {
		size += ((20 + xgb.Pad((int(item.NameSize) * 1))) + 4)
	}
	return size
}

type Format struct {
	Visual xproto.Visualid
	Depth  byte
	// padding: 3 bytes
}

// FormatRead reads a byte slice into a Format value.
func FormatRead(buf []byte, v *Format) int {
	b := 0

	v.Visual = xproto.Visualid(xgb.Get32(buf[b:]))
	b += 4

	v.Depth = buf[b]
	b += 1

	b += 3 // padding

	return b
}

// FormatReadList reads a byte slice into a list of Format values.
func FormatReadList(buf []byte, dest []Format) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = Format{}
		b += FormatRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Bytes writes a Format value to a byte slice.
func (v Format) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	xgb.Put32(buf[b:], uint32(v.Visual))
	b += 4

	buf[b] = v.Depth
	b += 1

	b += 3 // padding

	return buf[:b]
}

// FormatListBytes writes a list of Format values to a byte slice.
func FormatListBytes(buf []byte, list []Format) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}
	return xgb.Pad(b)
}

const (
	GrabPortStatusSuccess        = 0
	GrabPortStatusBadExtension   = 1
	GrabPortStatusAlreadyGrabbed = 2
	GrabPortStatusInvalidTime    = 3
	GrabPortStatusBadReply       = 4
	GrabPortStatusBadAlloc       = 5
)

type Image struct {
	Id        uint32
	Width     uint16
	Height    uint16
	DataSize  uint32
	NumPlanes uint32
	Pitches   []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
	Offsets   []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
	Data      []byte   // size: xgb.Pad((int(DataSize) * 1))
}

// ImageRead reads a byte slice into a Image value.
func ImageRead(buf []byte, v *Image) int {
	b := 0

	v.Id = xgb.Get32(buf[b:])
	b += 4

	v.Width = xgb.Get16(buf[b:])
	b += 2

	v.Height = xgb.Get16(buf[b:])
	b += 2

	v.DataSize = xgb.Get32(buf[b:])
	b += 4

	v.NumPlanes = xgb.Get32(buf[b:])
	b += 4

	v.Pitches = make([]uint32, v.NumPlanes)
	for i := 0; i < int(v.NumPlanes); i++ {
		v.Pitches[i] = xgb.Get32(buf[b:])
		b += 4
	}

	v.Offsets = make([]uint32, v.NumPlanes)
	for i := 0; i < int(v.NumPlanes); i++ {
		v.Offsets[i] = xgb.Get32(buf[b:])
		b += 4
	}

	v.Data = make([]byte, v.DataSize)
	copy(v.Data[:v.DataSize], buf[b:])
	b += int(v.DataSize)

	return b
}

// ImageReadList reads a byte slice into a list of Image values.
func ImageReadList(buf []byte, dest []Image) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = Image{}
		b += ImageRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Bytes writes a Image value to a byte slice.
func (v Image) Bytes() []byte {
	buf := make([]byte, (((16 + xgb.Pad((int(v.NumPlanes) * 4))) + xgb.Pad((int(v.NumPlanes) * 4))) + xgb.Pad((int(v.DataSize) * 1))))
	b := 0

	xgb.Put32(buf[b:], v.Id)
	b += 4

	xgb.Put16(buf[b:], v.Width)
	b += 2

	xgb.Put16(buf[b:], v.Height)
	b += 2

	xgb.Put32(buf[b:], v.DataSize)
	b += 4

	xgb.Put32(buf[b:], v.NumPlanes)
	b += 4

	for i := 0; i < int(v.NumPlanes); i++ {
		xgb.Put32(buf[b:], v.Pitches[i])
		b += 4
	}

	for i := 0; i < int(v.NumPlanes); i++ {
		xgb.Put32(buf[b:], v.Offsets[i])
		b += 4
	}

	copy(buf[b:], v.Data[:v.DataSize])
	b += int(v.DataSize)

	return buf[:b]
}

// ImageListBytes writes a list of Image values to a byte slice.
func ImageListBytes(buf []byte, list []Image) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}
	return xgb.Pad(b)
}

// ImageListSize computes the size (bytes) of a list of Image values.
func ImageListSize(list []Image) int {
	size := 0
	for _, item := range list {
		size += (((16 + xgb.Pad((int(item.NumPlanes) * 4))) + xgb.Pad((int(item.NumPlanes) * 4))) + xgb.Pad((int(item.DataSize) * 1)))
	}
	return size
}

type ImageFormatInfo struct {
	Id        uint32
	Type      byte
	ByteOrder byte
	// padding: 2 bytes
	Guid      []byte // size: 16
	Bpp       byte
	NumPlanes byte
	// padding: 2 bytes
	Depth byte
	// padding: 3 bytes
	RedMask   uint32
	GreenMask uint32
	BlueMask  uint32
	Format    byte
	// padding: 3 bytes
	YSampleBits    uint32
	USampleBits    uint32
	VSampleBits    uint32
	VhorzYPeriod   uint32
	VhorzUPeriod   uint32
	VhorzVPeriod   uint32
	VvertYPeriod   uint32
	VvertUPeriod   uint32
	VvertVPeriod   uint32
	VcompOrder     []byte // size: 32
	VscanlineOrder byte
	// padding: 11 bytes
}

// ImageFormatInfoRead reads a byte slice into a ImageFormatInfo value.
func ImageFormatInfoRead(buf []byte, v *ImageFormatInfo) int {
	b := 0

	v.Id = xgb.Get32(buf[b:])
	b += 4

	v.Type = buf[b]
	b += 1

	v.ByteOrder = buf[b]
	b += 1

	b += 2 // padding

	v.Guid = make([]byte, 16)
	copy(v.Guid[:16], buf[b:])
	b += int(16)

	v.Bpp = buf[b]
	b += 1

	v.NumPlanes = buf[b]
	b += 1

	b += 2 // padding

	v.Depth = buf[b]
	b += 1

	b += 3 // padding

	v.RedMask = xgb.Get32(buf[b:])
	b += 4

	v.GreenMask = xgb.Get32(buf[b:])
	b += 4

	v.BlueMask = xgb.Get32(buf[b:])
	b += 4

	v.Format = buf[b]
	b += 1

	b += 3 // padding

	v.YSampleBits = xgb.Get32(buf[b:])
	b += 4

	v.USampleBits = xgb.Get32(buf[b:])
	b += 4

	v.VSampleBits = xgb.Get32(buf[b:])
	b += 4

	v.VhorzYPeriod = xgb.Get32(buf[b:])
	b += 4

	v.VhorzUPeriod = xgb.Get32(buf[b:])
	b += 4

	v.VhorzVPeriod = xgb.Get32(buf[b:])
	b += 4

	v.VvertYPeriod = xgb.Get32(buf[b:])
	b += 4

	v.VvertUPeriod = xgb.Get32(buf[b:])
	b += 4

	v.VvertVPeriod = xgb.Get32(buf[b:])
	b += 4

	v.VcompOrder = make([]byte, 32)
	copy(v.VcompOrder[:32], buf[b:])
	b += int(32)

	v.VscanlineOrder = buf[b]
	b += 1

	b += 11 // padding

	return b
}

// ImageFormatInfoReadList reads a byte slice into a list of ImageFormatInfo values.
func ImageFormatInfoReadList(buf []byte, dest []ImageFormatInfo) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = ImageFormatInfo{}
		b += ImageFormatInfoRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Bytes writes a ImageFormatInfo value to a byte slice.
func (v ImageFormatInfo) Bytes() []byte {
	buf := make([]byte, 128)
	b := 0

	xgb.Put32(buf[b:], v.Id)
	b += 4

	buf[b] = v.Type
	b += 1

	buf[b] = v.ByteOrder
	b += 1

	b += 2 // padding

	copy(buf[b:], v.Guid[:16])
	b += int(16)

	buf[b] = v.Bpp
	b += 1

	buf[b] = v.NumPlanes
	b += 1

	b += 2 // padding

	buf[b] = v.Depth
	b += 1

	b += 3 // padding

	xgb.Put32(buf[b:], v.RedMask)
	b += 4

	xgb.Put32(buf[b:], v.GreenMask)
	b += 4

	xgb.Put32(buf[b:], v.BlueMask)
	b += 4

	buf[b] = v.Format
	b += 1

	b += 3 // padding

	xgb.Put32(buf[b:], v.YSampleBits)
	b += 4

	xgb.Put32(buf[b:], v.USampleBits)
	b += 4

	xgb.Put32(buf[b:], v.VSampleBits)
	b += 4

	xgb.Put32(buf[b:], v.VhorzYPeriod)
	b += 4

	xgb.Put32(buf[b:], v.VhorzUPeriod)
	b += 4

	xgb.Put32(buf[b:], v.VhorzVPeriod)
	b += 4

	xgb.Put32(buf[b:], v.VvertYPeriod)
	b += 4

	xgb.Put32(buf[b:], v.VvertUPeriod)
	b += 4

	xgb.Put32(buf[b:], v.VvertVPeriod)
	b += 4

	copy(buf[b:], v.VcompOrder[:32])
	b += int(32)

	buf[b] = v.VscanlineOrder
	b += 1

	b += 11 // padding

	return buf[:b]
}

// ImageFormatInfoListBytes writes a list of ImageFormatInfo values to a byte slice.
func ImageFormatInfoListBytes(buf []byte, list []ImageFormatInfo) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}
	return xgb.Pad(b)
}

// ImageFormatInfoListSize computes the size (bytes) of a list of ImageFormatInfo values.
func ImageFormatInfoListSize(list []ImageFormatInfo) int {
	size := 0
	for _ = range list {
		size += 128
	}
	return size
}

const (
	ImageFormatInfoFormatPacked = 0
	ImageFormatInfoFormatPlanar = 1
)

const (
	ImageFormatInfoTypeRgb = 0
	ImageFormatInfoTypeYuv = 1
)

type Port uint32

func NewPortId(c *xgb.Conn) (Port, error) {
	id, err := c.NewId()
	if err != nil {
		return 0, err
	}
	return Port(id), nil
}

// PortNotify is the event number for a PortNotifyEvent.
const PortNotify = 1

type PortNotifyEvent struct {
	Sequence uint16
	// padding: 1 bytes
	Time      xproto.Timestamp
	Port      Port
	Attribute xproto.Atom
	Value     int32
}

// PortNotifyEventNew constructs a PortNotifyEvent value that implements xgb.Event from a byte slice.
func PortNotifyEventNew(buf []byte) xgb.Event {
	v := PortNotifyEvent{}
	b := 1 // don't read event number

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	v.Port = Port(xgb.Get32(buf[b:]))
	b += 4

	v.Attribute = xproto.Atom(xgb.Get32(buf[b:]))
	b += 4

	v.Value = int32(xgb.Get32(buf[b:]))
	b += 4

	return v
}

// Bytes writes a PortNotifyEvent value to a byte slice.
func (v PortNotifyEvent) Bytes() []byte {
	buf := make([]byte, 32)
	b := 0

	// write event number
	buf[b] = 1
	b += 1

	b += 1 // padding

	b += 2 // skip sequence number

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Port))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Attribute))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Value))
	b += 4

	return buf
}

// SequenceId returns the sequence id attached to the PortNotify event.
// Events without a sequence number (KeymapNotify) return 0.
// This is mostly used internally.
func (v PortNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

// String is a rudimentary string representation of PortNotifyEvent.
func (v PortNotifyEvent) String() string {
	fieldVals := make([]string, 0, 5)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Port: %d", v.Port))
	fieldVals = append(fieldVals, xgb.Sprintf("Attribute: %d", v.Attribute))
	fieldVals = append(fieldVals, xgb.Sprintf("Value: %d", v.Value))
	return "PortNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XVideo"][1] = PortNotifyEventNew
}

type Rational struct {
	Numerator   int32
	Denominator int32
}

// RationalRead reads a byte slice into a Rational value.
func RationalRead(buf []byte, v *Rational) int {
	b := 0

	v.Numerator = int32(xgb.Get32(buf[b:]))
	b += 4

	v.Denominator = int32(xgb.Get32(buf[b:]))
	b += 4

	return b
}

// RationalReadList reads a byte slice into a list of Rational values.
func RationalReadList(buf []byte, dest []Rational) int {
	b := 0
	for i := 0; i < len(dest); i++ {
		dest[i] = Rational{}
		b += RationalRead(buf[b:], &dest[i])
	}
	return xgb.Pad(b)
}

// Bytes writes a Rational value to a byte slice.
func (v Rational) Bytes() []byte {
	buf := make([]byte, 8)
	b := 0

	xgb.Put32(buf[b:], uint32(v.Numerator))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Denominator))
	b += 4

	return buf[:b]
}

// RationalListBytes writes a list of Rational values to a byte slice.
func RationalListBytes(buf []byte, list []Rational) int {
	b := 0
	var structBytes []byte
	for _, item := range list {
		structBytes = item.Bytes()
		copy(buf[b:], structBytes)
		b += len(structBytes)
	}
	return xgb.Pad(b)
}

const (
	ScanlineOrderTopToBottom = 0
	ScanlineOrderBottomToTop = 1
)

const (
	TypeInputMask  = 1
	TypeOutputMask = 2
	TypeVideoMask  = 4
	TypeStillMask  = 8
	TypeImageMask  = 16
)

// VideoNotify is the event number for a VideoNotifyEvent.
const VideoNotify = 0

type VideoNotifyEvent struct {
	Sequence uint16
	Reason   byte
	Time     xproto.Timestamp
	Drawable xproto.Drawable
	Port     Port
}

// VideoNotifyEventNew constructs a VideoNotifyEvent value that implements xgb.Event from a byte slice.
func VideoNotifyEventNew(buf []byte) xgb.Event {
	v := VideoNotifyEvent{}
	b := 1 // don't read event number

	v.Reason = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Time = xproto.Timestamp(xgb.Get32(buf[b:]))
	b += 4

	v.Drawable = xproto.Drawable(xgb.Get32(buf[b:]))
	b += 4

	v.Port = Port(xgb.Get32(buf[b:]))
	b += 4

	return v
}

// Bytes writes a VideoNotifyEvent value to a byte slice.
func (v VideoNotifyEvent) Bytes() []byte {
	buf := make([]byte, 32)
	b := 0

	// write event number
	buf[b] = 0
	b += 1

	buf[b] = v.Reason
	b += 1

	b += 2 // skip sequence number

	xgb.Put32(buf[b:], uint32(v.Time))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Drawable))
	b += 4

	xgb.Put32(buf[b:], uint32(v.Port))
	b += 4

	return buf
}

// SequenceId returns the sequence id attached to the VideoNotify event.
// Events without a sequence number (KeymapNotify) return 0.
// This is mostly used internally.
func (v VideoNotifyEvent) SequenceId() uint16 {
	return v.Sequence
}

// String is a rudimentary string representation of VideoNotifyEvent.
func (v VideoNotifyEvent) String() string {
	fieldVals := make([]string, 0, 4)
	fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence))
	fieldVals = append(fieldVals, xgb.Sprintf("Reason: %d", v.Reason))
	fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time))
	fieldVals = append(fieldVals, xgb.Sprintf("Drawable: %d", v.Drawable))
	fieldVals = append(fieldVals, xgb.Sprintf("Port: %d", v.Port))
	return "VideoNotify {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}

func init() {
	xgb.NewExtEventFuncs["XVideo"][0] = VideoNotifyEventNew
}

const (
	VideoNotifyReasonStarted   = 0
	VideoNotifyReasonStopped   = 1
	VideoNotifyReasonBusy      = 2
	VideoNotifyReasonPreempted = 3
	VideoNotifyReasonHardError = 4
)

// Skipping definition for base type 'Bool'

// Skipping definition for base type 'Byte'

// Skipping definition for base type 'Card8'

// Skipping definition for base type 'Char'

// Skipping definition for base type 'Void'

// Skipping definition for base type 'Double'

// Skipping definition for base type 'Float'

// Skipping definition for base type 'Int16'

// Skipping definition for base type 'Int32'

// Skipping definition for base type 'Int8'

// Skipping definition for base type 'Card16'

// Skipping definition for base type 'Card32'

// GetPortAttributeCookie is a cookie used only for GetPortAttribute requests.
type GetPortAttributeCookie struct {
	*xgb.Cookie
}

// GetPortAttribute sends a checked request.
// If an error occurs, it will be returned with the reply by calling GetPortAttributeCookie.Reply.
func GetPortAttribute(c *xgb.Conn, Port Port, Attribute xproto.Atom) GetPortAttributeCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GetPortAttribute' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(getPortAttributeRequest(c, Port, Attribute), cookie)
	return GetPortAttributeCookie{cookie}
}

// GetPortAttributeUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func GetPortAttributeUnchecked(c *xgb.Conn, Port Port, Attribute xproto.Atom) GetPortAttributeCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GetPortAttribute' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(getPortAttributeRequest(c, Port, Attribute), cookie)
	return GetPortAttributeCookie{cookie}
}

// GetPortAttributeReply represents the data returned from a GetPortAttribute request.
type GetPortAttributeReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	Value int32
}

// Reply blocks and returns the reply data for a GetPortAttribute request.
func (cook GetPortAttributeCookie) Reply() (*GetPortAttributeReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return getPortAttributeReply(buf), nil
}

// getPortAttributeReply reads a byte slice into a GetPortAttributeReply value.
func getPortAttributeReply(buf []byte) *GetPortAttributeReply {
	v := new(GetPortAttributeReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Value = int32(xgb.Get32(buf[b:]))
	b += 4

	return v
}

// getPortAttributeRequest writes a GetPortAttribute request to a byte slice for transfer.
func getPortAttributeRequest(c *xgb.Conn, Port Port, Attribute xproto.Atom) []byte {
	size := 12
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 14 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Attribute))
	b += 4

	return buf
}

// GetStillCookie is a cookie used only for GetStill requests.
type GetStillCookie struct {
	*xgb.Cookie
}

// GetStill sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func GetStill(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) GetStillCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GetStill' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(getStillRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return GetStillCookie{cookie}
}

// GetStillChecked sends a checked request.
// If an error occurs, it can be retrieved using GetStillCookie.Check.
func GetStillChecked(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) GetStillCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GetStill' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(getStillRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return GetStillCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook GetStillCookie) Check() error {
	return cook.Cookie.Check()
}

// getStillRequest writes a GetStill request to a byte slice for transfer.
func getStillRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) []byte {
	size := 32
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 8 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	xgb.Put32(buf[b:], uint32(Gc))
	b += 4

	xgb.Put16(buf[b:], uint16(VidX))
	b += 2

	xgb.Put16(buf[b:], uint16(VidY))
	b += 2

	xgb.Put16(buf[b:], VidW)
	b += 2

	xgb.Put16(buf[b:], VidH)
	b += 2

	xgb.Put16(buf[b:], uint16(DrwX))
	b += 2

	xgb.Put16(buf[b:], uint16(DrwY))
	b += 2

	xgb.Put16(buf[b:], DrwW)
	b += 2

	xgb.Put16(buf[b:], DrwH)
	b += 2

	return buf
}

// GetVideoCookie is a cookie used only for GetVideo requests.
type GetVideoCookie struct {
	*xgb.Cookie
}

// GetVideo sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func GetVideo(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) GetVideoCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GetVideo' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(getVideoRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return GetVideoCookie{cookie}
}

// GetVideoChecked sends a checked request.
// If an error occurs, it can be retrieved using GetVideoCookie.Check.
func GetVideoChecked(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) GetVideoCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GetVideo' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(getVideoRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return GetVideoCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook GetVideoCookie) Check() error {
	return cook.Cookie.Check()
}

// getVideoRequest writes a GetVideo request to a byte slice for transfer.
func getVideoRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) []byte {
	size := 32
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 7 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	xgb.Put32(buf[b:], uint32(Gc))
	b += 4

	xgb.Put16(buf[b:], uint16(VidX))
	b += 2

	xgb.Put16(buf[b:], uint16(VidY))
	b += 2

	xgb.Put16(buf[b:], VidW)
	b += 2

	xgb.Put16(buf[b:], VidH)
	b += 2

	xgb.Put16(buf[b:], uint16(DrwX))
	b += 2

	xgb.Put16(buf[b:], uint16(DrwY))
	b += 2

	xgb.Put16(buf[b:], DrwW)
	b += 2

	xgb.Put16(buf[b:], DrwH)
	b += 2

	return buf
}

// GrabPortCookie is a cookie used only for GrabPort requests.
type GrabPortCookie struct {
	*xgb.Cookie
}

// GrabPort sends a checked request.
// If an error occurs, it will be returned with the reply by calling GrabPortCookie.Reply.
func GrabPort(c *xgb.Conn, Port Port, Time xproto.Timestamp) GrabPortCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GrabPort' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(grabPortRequest(c, Port, Time), cookie)
	return GrabPortCookie{cookie}
}

// GrabPortUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func GrabPortUnchecked(c *xgb.Conn, Port Port, Time xproto.Timestamp) GrabPortCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'GrabPort' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(grabPortRequest(c, Port, Time), cookie)
	return GrabPortCookie{cookie}
}

// GrabPortReply represents the data returned from a GrabPort request.
type GrabPortReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	Result   byte
}

// Reply blocks and returns the reply data for a GrabPort request.
func (cook GrabPortCookie) Reply() (*GrabPortReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return grabPortReply(buf), nil
}

// grabPortReply reads a byte slice into a GrabPortReply value.
func grabPortReply(buf []byte) *GrabPortReply {
	v := new(GrabPortReply)
	b := 1 // skip reply determinant

	v.Result = buf[b]
	b += 1

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	return v
}

// grabPortRequest writes a GrabPort request to a byte slice for transfer.
func grabPortRequest(c *xgb.Conn, Port Port, Time xproto.Timestamp) []byte {
	size := 12
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 3 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Time))
	b += 4

	return buf
}

// ListImageFormatsCookie is a cookie used only for ListImageFormats requests.
type ListImageFormatsCookie struct {
	*xgb.Cookie
}

// ListImageFormats sends a checked request.
// If an error occurs, it will be returned with the reply by calling ListImageFormatsCookie.Reply.
func ListImageFormats(c *xgb.Conn, Port Port) ListImageFormatsCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'ListImageFormats' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(listImageFormatsRequest(c, Port), cookie)
	return ListImageFormatsCookie{cookie}
}

// ListImageFormatsUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func ListImageFormatsUnchecked(c *xgb.Conn, Port Port) ListImageFormatsCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'ListImageFormats' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(listImageFormatsRequest(c, Port), cookie)
	return ListImageFormatsCookie{cookie}
}

// ListImageFormatsReply represents the data returned from a ListImageFormats request.
type ListImageFormatsReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	NumFormats uint32
	// padding: 20 bytes
	Format []ImageFormatInfo // size: ImageFormatInfoListSize(Format)
}

// Reply blocks and returns the reply data for a ListImageFormats request.
func (cook ListImageFormatsCookie) Reply() (*ListImageFormatsReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return listImageFormatsReply(buf), nil
}

// listImageFormatsReply reads a byte slice into a ListImageFormatsReply value.
func listImageFormatsReply(buf []byte) *ListImageFormatsReply {
	v := new(ListImageFormatsReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumFormats = xgb.Get32(buf[b:])
	b += 4

	b += 20 // padding

	v.Format = make([]ImageFormatInfo, v.NumFormats)
	b += ImageFormatInfoReadList(buf[b:], v.Format)

	return v
}

// listImageFormatsRequest writes a ListImageFormats request to a byte slice for transfer.
func listImageFormatsRequest(c *xgb.Conn, Port Port) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 16 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	return buf
}

// PutImageCookie is a cookie used only for PutImage requests.
type PutImageCookie struct {
	*xgb.Cookie
}

// PutImage sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func PutImage(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, Id uint32, SrcX, SrcY int16, SrcW, SrcH uint16, DrwX, DrwY int16, DrwW, DrwH, Width, Height uint16, Data []byte) PutImageCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'PutImage' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(putImageRequest(c, Port, Drawable, Gc, Id, SrcX, SrcY, SrcW, SrcH, DrwX, DrwY, DrwW, DrwH, Width, Height, Data), cookie)
	return PutImageCookie{cookie}
}

// PutImageChecked sends a checked request.
// If an error occurs, it can be retrieved using PutImageCookie.Check.
func PutImageChecked(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, Id uint32, SrcX, SrcY int16, SrcW, SrcH uint16, DrwX, DrwY int16, DrwW, DrwH, Width, Height uint16, Data []byte) PutImageCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'PutImage' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(putImageRequest(c, Port, Drawable, Gc, Id, SrcX, SrcY, SrcW, SrcH, DrwX, DrwY, DrwW, DrwH, Width, Height, Data), cookie)
	return PutImageCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook PutImageCookie) Check() error {
	return cook.Cookie.Check()
}

// putImageRequest writes a PutImage request to a byte slice for transfer.
func putImageRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, Id uint32, SrcX, SrcY int16, SrcW, SrcH uint16, DrwX, DrwY int16, DrwW, DrwH, Width, Height uint16, Data []byte) []byte {
	size := xgb.Pad((40 + xgb.Pad((len(Data) * 1))))
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 18 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	xgb.Put32(buf[b:], uint32(Gc))
	b += 4

	xgb.Put32(buf[b:], Id)
	b += 4

	xgb.Put16(buf[b:], uint16(SrcX))
	b += 2

	xgb.Put16(buf[b:], uint16(SrcY))
	b += 2

	xgb.Put16(buf[b:], SrcW)
	b += 2

	xgb.Put16(buf[b:], SrcH)
	b += 2

	xgb.Put16(buf[b:], uint16(DrwX))
	b += 2

	xgb.Put16(buf[b:], uint16(DrwY))
	b += 2

	xgb.Put16(buf[b:], DrwW)
	b += 2

	xgb.Put16(buf[b:], DrwH)
	b += 2

	xgb.Put16(buf[b:], Width)
	b += 2

	xgb.Put16(buf[b:], Height)
	b += 2

	copy(buf[b:], Data[:len(Data)])
	b += int(len(Data))

	return buf
}

// PutStillCookie is a cookie used only for PutStill requests.
type PutStillCookie struct {
	*xgb.Cookie
}

// PutStill sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func PutStill(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) PutStillCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'PutStill' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(putStillRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return PutStillCookie{cookie}
}

// PutStillChecked sends a checked request.
// If an error occurs, it can be retrieved using PutStillCookie.Check.
func PutStillChecked(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) PutStillCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'PutStill' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(putStillRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return PutStillCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook PutStillCookie) Check() error {
	return cook.Cookie.Check()
}

// putStillRequest writes a PutStill request to a byte slice for transfer.
func putStillRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) []byte {
	size := 32
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 6 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	xgb.Put32(buf[b:], uint32(Gc))
	b += 4

	xgb.Put16(buf[b:], uint16(VidX))
	b += 2

	xgb.Put16(buf[b:], uint16(VidY))
	b += 2

	xgb.Put16(buf[b:], VidW)
	b += 2

	xgb.Put16(buf[b:], VidH)
	b += 2

	xgb.Put16(buf[b:], uint16(DrwX))
	b += 2

	xgb.Put16(buf[b:], uint16(DrwY))
	b += 2

	xgb.Put16(buf[b:], DrwW)
	b += 2

	xgb.Put16(buf[b:], DrwH)
	b += 2

	return buf
}

// PutVideoCookie is a cookie used only for PutVideo requests.
type PutVideoCookie struct {
	*xgb.Cookie
}

// PutVideo sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func PutVideo(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) PutVideoCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'PutVideo' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(putVideoRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return PutVideoCookie{cookie}
}

// PutVideoChecked sends a checked request.
// If an error occurs, it can be retrieved using PutVideoCookie.Check.
func PutVideoChecked(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) PutVideoCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'PutVideo' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(putVideoRequest(c, Port, Drawable, Gc, VidX, VidY, VidW, VidH, DrwX, DrwY, DrwW, DrwH), cookie)
	return PutVideoCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook PutVideoCookie) Check() error {
	return cook.Cookie.Check()
}

// putVideoRequest writes a PutVideo request to a byte slice for transfer.
func putVideoRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, VidX, VidY int16, VidW, VidH uint16, DrwX, DrwY int16, DrwW, DrwH uint16) []byte {
	size := 32
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 5 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	xgb.Put32(buf[b:], uint32(Gc))
	b += 4

	xgb.Put16(buf[b:], uint16(VidX))
	b += 2

	xgb.Put16(buf[b:], uint16(VidY))
	b += 2

	xgb.Put16(buf[b:], VidW)
	b += 2

	xgb.Put16(buf[b:], VidH)
	b += 2

	xgb.Put16(buf[b:], uint16(DrwX))
	b += 2

	xgb.Put16(buf[b:], uint16(DrwY))
	b += 2

	xgb.Put16(buf[b:], DrwW)
	b += 2

	xgb.Put16(buf[b:], DrwH)
	b += 2

	return buf
}

// QueryAdaptorsCookie is a cookie used only for QueryAdaptors requests.
type QueryAdaptorsCookie struct {
	*xgb.Cookie
}

// QueryAdaptors sends a checked request.
// If an error occurs, it will be returned with the reply by calling QueryAdaptorsCookie.Reply.
func QueryAdaptors(c *xgb.Conn, Window xproto.Window) QueryAdaptorsCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryAdaptors' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryAdaptorsRequest(c, Window), cookie)
	return QueryAdaptorsCookie{cookie}
}

// QueryAdaptorsUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func QueryAdaptorsUnchecked(c *xgb.Conn, Window xproto.Window) QueryAdaptorsCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryAdaptors' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryAdaptorsRequest(c, Window), cookie)
	return QueryAdaptorsCookie{cookie}
}

// QueryAdaptorsReply represents the data returned from a QueryAdaptors request.
type QueryAdaptorsReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	NumAdaptors uint16
	// padding: 22 bytes
	Info []AdaptorInfo // size: AdaptorInfoListSize(Info)
}

// Reply blocks and returns the reply data for a QueryAdaptors request.
func (cook QueryAdaptorsCookie) Reply() (*QueryAdaptorsReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryAdaptorsReply(buf), nil
}

// queryAdaptorsReply reads a byte slice into a QueryAdaptorsReply value.
func queryAdaptorsReply(buf []byte) *QueryAdaptorsReply {
	v := new(QueryAdaptorsReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumAdaptors = xgb.Get16(buf[b:])
	b += 2

	b += 22 // padding

	v.Info = make([]AdaptorInfo, v.NumAdaptors)
	b += AdaptorInfoReadList(buf[b:], v.Info)

	return v
}

// queryAdaptorsRequest writes a QueryAdaptors request to a byte slice for transfer.
func queryAdaptorsRequest(c *xgb.Conn, Window xproto.Window) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 1 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Window))
	b += 4

	return buf
}

// QueryBestSizeCookie is a cookie used only for QueryBestSize requests.
type QueryBestSizeCookie struct {
	*xgb.Cookie
}

// QueryBestSize sends a checked request.
// If an error occurs, it will be returned with the reply by calling QueryBestSizeCookie.Reply.
func QueryBestSize(c *xgb.Conn, Port Port, VidW, VidH, DrwW, DrwH uint16, Motion bool) QueryBestSizeCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryBestSize' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryBestSizeRequest(c, Port, VidW, VidH, DrwW, DrwH, Motion), cookie)
	return QueryBestSizeCookie{cookie}
}

// QueryBestSizeUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func QueryBestSizeUnchecked(c *xgb.Conn, Port Port, VidW, VidH, DrwW, DrwH uint16, Motion bool) QueryBestSizeCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryBestSize' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryBestSizeRequest(c, Port, VidW, VidH, DrwW, DrwH, Motion), cookie)
	return QueryBestSizeCookie{cookie}
}

// QueryBestSizeReply represents the data returned from a QueryBestSize request.
type QueryBestSizeReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	ActualWidth  uint16
	ActualHeight uint16
}

// Reply blocks and returns the reply data for a QueryBestSize request.
func (cook QueryBestSizeCookie) Reply() (*QueryBestSizeReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryBestSizeReply(buf), nil
}

// queryBestSizeReply reads a byte slice into a QueryBestSizeReply value.
func queryBestSizeReply(buf []byte) *QueryBestSizeReply {
	v := new(QueryBestSizeReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.ActualWidth = xgb.Get16(buf[b:])
	b += 2

	v.ActualHeight = xgb.Get16(buf[b:])
	b += 2

	return v
}

// queryBestSizeRequest writes a QueryBestSize request to a byte slice for transfer.
func queryBestSizeRequest(c *xgb.Conn, Port Port, VidW, VidH, DrwW, DrwH uint16, Motion bool) []byte {
	size := 20
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 12 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put16(buf[b:], VidW)
	b += 2

	xgb.Put16(buf[b:], VidH)
	b += 2

	xgb.Put16(buf[b:], DrwW)
	b += 2

	xgb.Put16(buf[b:], DrwH)
	b += 2

	if Motion {
		buf[b] = 1
	} else {
		buf[b] = 0
	}
	b += 1

	b += 3 // padding

	return buf
}

// QueryEncodingsCookie is a cookie used only for QueryEncodings requests.
type QueryEncodingsCookie struct {
	*xgb.Cookie
}

// QueryEncodings sends a checked request.
// If an error occurs, it will be returned with the reply by calling QueryEncodingsCookie.Reply.
func QueryEncodings(c *xgb.Conn, Port Port) QueryEncodingsCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryEncodings' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryEncodingsRequest(c, Port), cookie)
	return QueryEncodingsCookie{cookie}
}

// QueryEncodingsUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func QueryEncodingsUnchecked(c *xgb.Conn, Port Port) QueryEncodingsCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryEncodings' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryEncodingsRequest(c, Port), cookie)
	return QueryEncodingsCookie{cookie}
}

// QueryEncodingsReply represents the data returned from a QueryEncodings request.
type QueryEncodingsReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	NumEncodings uint16
	// padding: 22 bytes
	Info []EncodingInfo // size: EncodingInfoListSize(Info)
}

// Reply blocks and returns the reply data for a QueryEncodings request.
func (cook QueryEncodingsCookie) Reply() (*QueryEncodingsReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryEncodingsReply(buf), nil
}

// queryEncodingsReply reads a byte slice into a QueryEncodingsReply value.
func queryEncodingsReply(buf []byte) *QueryEncodingsReply {
	v := new(QueryEncodingsReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumEncodings = xgb.Get16(buf[b:])
	b += 2

	b += 22 // padding

	v.Info = make([]EncodingInfo, v.NumEncodings)
	b += EncodingInfoReadList(buf[b:], v.Info)

	return v
}

// queryEncodingsRequest writes a QueryEncodings request to a byte slice for transfer.
func queryEncodingsRequest(c *xgb.Conn, Port Port) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 2 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	return buf
}

// QueryExtensionCookie is a cookie used only for QueryExtension requests.
type QueryExtensionCookie struct {
	*xgb.Cookie
}

// QueryExtension sends a checked request.
// If an error occurs, it will be returned with the reply by calling QueryExtensionCookie.Reply.
func QueryExtension(c *xgb.Conn) QueryExtensionCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryExtension' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryExtensionRequest(c), cookie)
	return QueryExtensionCookie{cookie}
}

// QueryExtensionUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func QueryExtensionUnchecked(c *xgb.Conn) QueryExtensionCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryExtension' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryExtensionRequest(c), cookie)
	return QueryExtensionCookie{cookie}
}

// QueryExtensionReply represents the data returned from a QueryExtension request.
type QueryExtensionReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	Major uint16
	Minor uint16
}

// Reply blocks and returns the reply data for a QueryExtension request.
func (cook QueryExtensionCookie) Reply() (*QueryExtensionReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryExtensionReply(buf), nil
}

// queryExtensionReply reads a byte slice into a QueryExtensionReply value.
func queryExtensionReply(buf []byte) *QueryExtensionReply {
	v := new(QueryExtensionReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.Major = xgb.Get16(buf[b:])
	b += 2

	v.Minor = xgb.Get16(buf[b:])
	b += 2

	return v
}

// queryExtensionRequest writes a QueryExtension request to a byte slice for transfer.
func queryExtensionRequest(c *xgb.Conn) []byte {
	size := 4
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 0 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	return buf
}

// QueryImageAttributesCookie is a cookie used only for QueryImageAttributes requests.
type QueryImageAttributesCookie struct {
	*xgb.Cookie
}

// QueryImageAttributes sends a checked request.
// If an error occurs, it will be returned with the reply by calling QueryImageAttributesCookie.Reply.
func QueryImageAttributes(c *xgb.Conn, Port Port, Id uint32, Width, Height uint16) QueryImageAttributesCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryImageAttributes' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryImageAttributesRequest(c, Port, Id, Width, Height), cookie)
	return QueryImageAttributesCookie{cookie}
}

// QueryImageAttributesUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func QueryImageAttributesUnchecked(c *xgb.Conn, Port Port, Id uint32, Width, Height uint16) QueryImageAttributesCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryImageAttributes' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryImageAttributesRequest(c, Port, Id, Width, Height), cookie)
	return QueryImageAttributesCookie{cookie}
}

// QueryImageAttributesReply represents the data returned from a QueryImageAttributes request.
type QueryImageAttributesReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	NumPlanes uint32
	DataSize  uint32
	Width     uint16
	Height    uint16
	// padding: 12 bytes
	Pitches []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
	Offsets []uint32 // size: xgb.Pad((int(NumPlanes) * 4))
}

// Reply blocks and returns the reply data for a QueryImageAttributes request.
func (cook QueryImageAttributesCookie) Reply() (*QueryImageAttributesReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryImageAttributesReply(buf), nil
}

// queryImageAttributesReply reads a byte slice into a QueryImageAttributesReply value.
func queryImageAttributesReply(buf []byte) *QueryImageAttributesReply {
	v := new(QueryImageAttributesReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumPlanes = xgb.Get32(buf[b:])
	b += 4

	v.DataSize = xgb.Get32(buf[b:])
	b += 4

	v.Width = xgb.Get16(buf[b:])
	b += 2

	v.Height = xgb.Get16(buf[b:])
	b += 2

	b += 12 // padding

	v.Pitches = make([]uint32, v.NumPlanes)
	for i := 0; i < int(v.NumPlanes); i++ {
		v.Pitches[i] = xgb.Get32(buf[b:])
		b += 4
	}

	v.Offsets = make([]uint32, v.NumPlanes)
	for i := 0; i < int(v.NumPlanes); i++ {
		v.Offsets[i] = xgb.Get32(buf[b:])
		b += 4
	}

	return v
}

// queryImageAttributesRequest writes a QueryImageAttributes request to a byte slice for transfer.
func queryImageAttributesRequest(c *xgb.Conn, Port Port, Id uint32, Width, Height uint16) []byte {
	size := 16
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 17 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], Id)
	b += 4

	xgb.Put16(buf[b:], Width)
	b += 2

	xgb.Put16(buf[b:], Height)
	b += 2

	return buf
}

// QueryPortAttributesCookie is a cookie used only for QueryPortAttributes requests.
type QueryPortAttributesCookie struct {
	*xgb.Cookie
}

// QueryPortAttributes sends a checked request.
// If an error occurs, it will be returned with the reply by calling QueryPortAttributesCookie.Reply.
func QueryPortAttributes(c *xgb.Conn, Port Port) QueryPortAttributesCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryPortAttributes' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, true)
	c.NewRequest(queryPortAttributesRequest(c, Port), cookie)
	return QueryPortAttributesCookie{cookie}
}

// QueryPortAttributesUnchecked sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func QueryPortAttributesUnchecked(c *xgb.Conn, Port Port) QueryPortAttributesCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'QueryPortAttributes' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, true)
	c.NewRequest(queryPortAttributesRequest(c, Port), cookie)
	return QueryPortAttributesCookie{cookie}
}

// QueryPortAttributesReply represents the data returned from a QueryPortAttributes request.
type QueryPortAttributesReply struct {
	Sequence uint16 // sequence number of the request for this reply
	Length   uint32 // number of bytes in this reply
	// padding: 1 bytes
	NumAttributes uint32
	TextSize      uint32
	// padding: 16 bytes
	Attributes []AttributeInfo // size: AttributeInfoListSize(Attributes)
}

// Reply blocks and returns the reply data for a QueryPortAttributes request.
func (cook QueryPortAttributesCookie) Reply() (*QueryPortAttributesReply, error) {
	buf, err := cook.Cookie.Reply()
	if err != nil {
		return nil, err
	}
	if buf == nil {
		return nil, nil
	}
	return queryPortAttributesReply(buf), nil
}

// queryPortAttributesReply reads a byte slice into a QueryPortAttributesReply value.
func queryPortAttributesReply(buf []byte) *QueryPortAttributesReply {
	v := new(QueryPortAttributesReply)
	b := 1 // skip reply determinant

	b += 1 // padding

	v.Sequence = xgb.Get16(buf[b:])
	b += 2

	v.Length = xgb.Get32(buf[b:]) // 4-byte units
	b += 4

	v.NumAttributes = xgb.Get32(buf[b:])
	b += 4

	v.TextSize = xgb.Get32(buf[b:])
	b += 4

	b += 16 // padding

	v.Attributes = make([]AttributeInfo, v.NumAttributes)
	b += AttributeInfoReadList(buf[b:], v.Attributes)

	return v
}

// queryPortAttributesRequest writes a QueryPortAttributes request to a byte slice for transfer.
func queryPortAttributesRequest(c *xgb.Conn, Port Port) []byte {
	size := 8
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 15 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	return buf
}

// SelectPortNotifyCookie is a cookie used only for SelectPortNotify requests.
type SelectPortNotifyCookie struct {
	*xgb.Cookie
}

// SelectPortNotify sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func SelectPortNotify(c *xgb.Conn, Port Port, Onoff bool) SelectPortNotifyCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'SelectPortNotify' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(selectPortNotifyRequest(c, Port, Onoff), cookie)
	return SelectPortNotifyCookie{cookie}
}

// SelectPortNotifyChecked sends a checked request.
// If an error occurs, it can be retrieved using SelectPortNotifyCookie.Check.
func SelectPortNotifyChecked(c *xgb.Conn, Port Port, Onoff bool) SelectPortNotifyCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'SelectPortNotify' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(selectPortNotifyRequest(c, Port, Onoff), cookie)
	return SelectPortNotifyCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook SelectPortNotifyCookie) Check() error {
	return cook.Cookie.Check()
}

// selectPortNotifyRequest writes a SelectPortNotify request to a byte slice for transfer.
func selectPortNotifyRequest(c *xgb.Conn, Port Port, Onoff bool) []byte {
	size := 12
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 11 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	if Onoff {
		buf[b] = 1
	} else {
		buf[b] = 0
	}
	b += 1

	b += 3 // padding

	return buf
}

// SelectVideoNotifyCookie is a cookie used only for SelectVideoNotify requests.
type SelectVideoNotifyCookie struct {
	*xgb.Cookie
}

// SelectVideoNotify sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func SelectVideoNotify(c *xgb.Conn, Drawable xproto.Drawable, Onoff bool) SelectVideoNotifyCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'SelectVideoNotify' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(selectVideoNotifyRequest(c, Drawable, Onoff), cookie)
	return SelectVideoNotifyCookie{cookie}
}

// SelectVideoNotifyChecked sends a checked request.
// If an error occurs, it can be retrieved using SelectVideoNotifyCookie.Check.
func SelectVideoNotifyChecked(c *xgb.Conn, Drawable xproto.Drawable, Onoff bool) SelectVideoNotifyCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'SelectVideoNotify' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(selectVideoNotifyRequest(c, Drawable, Onoff), cookie)
	return SelectVideoNotifyCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook SelectVideoNotifyCookie) Check() error {
	return cook.Cookie.Check()
}

// selectVideoNotifyRequest writes a SelectVideoNotify request to a byte slice for transfer.
func selectVideoNotifyRequest(c *xgb.Conn, Drawable xproto.Drawable, Onoff bool) []byte {
	size := 12
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 10 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	if Onoff {
		buf[b] = 1
	} else {
		buf[b] = 0
	}
	b += 1

	b += 3 // padding

	return buf
}

// SetPortAttributeCookie is a cookie used only for SetPortAttribute requests.
type SetPortAttributeCookie struct {
	*xgb.Cookie
}

// SetPortAttribute sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func SetPortAttribute(c *xgb.Conn, Port Port, Attribute xproto.Atom, Value int32) SetPortAttributeCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'SetPortAttribute' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(setPortAttributeRequest(c, Port, Attribute, Value), cookie)
	return SetPortAttributeCookie{cookie}
}

// SetPortAttributeChecked sends a checked request.
// If an error occurs, it can be retrieved using SetPortAttributeCookie.Check.
func SetPortAttributeChecked(c *xgb.Conn, Port Port, Attribute xproto.Atom, Value int32) SetPortAttributeCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'SetPortAttribute' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(setPortAttributeRequest(c, Port, Attribute, Value), cookie)
	return SetPortAttributeCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook SetPortAttributeCookie) Check() error {
	return cook.Cookie.Check()
}

// setPortAttributeRequest writes a SetPortAttribute request to a byte slice for transfer.
func setPortAttributeRequest(c *xgb.Conn, Port Port, Attribute xproto.Atom, Value int32) []byte {
	size := 16
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 13 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Attribute))
	b += 4

	xgb.Put32(buf[b:], uint32(Value))
	b += 4

	return buf
}

// ShmPutImageCookie is a cookie used only for ShmPutImage requests.
type ShmPutImageCookie struct {
	*xgb.Cookie
}

// ShmPutImage sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func ShmPutImage(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, Shmseg shm.Seg, Id, Offset uint32, SrcX, SrcY int16, SrcW, SrcH uint16, DrwX, DrwY int16, DrwW, DrwH, Width, Height uint16, SendEvent byte) ShmPutImageCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'ShmPutImage' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(shmPutImageRequest(c, Port, Drawable, Gc, Shmseg, Id, Offset, SrcX, SrcY, SrcW, SrcH, DrwX, DrwY, DrwW, DrwH, Width, Height, SendEvent), cookie)
	return ShmPutImageCookie{cookie}
}

// ShmPutImageChecked sends a checked request.
// If an error occurs, it can be retrieved using ShmPutImageCookie.Check.
func ShmPutImageChecked(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, Shmseg shm.Seg, Id, Offset uint32, SrcX, SrcY int16, SrcW, SrcH uint16, DrwX, DrwY int16, DrwW, DrwH, Width, Height uint16, SendEvent byte) ShmPutImageCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'ShmPutImage' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(shmPutImageRequest(c, Port, Drawable, Gc, Shmseg, Id, Offset, SrcX, SrcY, SrcW, SrcH, DrwX, DrwY, DrwW, DrwH, Width, Height, SendEvent), cookie)
	return ShmPutImageCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook ShmPutImageCookie) Check() error {
	return cook.Cookie.Check()
}

// shmPutImageRequest writes a ShmPutImage request to a byte slice for transfer.
func shmPutImageRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable, Gc xproto.Gcontext, Shmseg shm.Seg, Id, Offset uint32, SrcX, SrcY int16, SrcW, SrcH uint16, DrwX, DrwY int16, DrwW, DrwH, Width, Height uint16, SendEvent byte) []byte {
	size := 52
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 19 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	xgb.Put32(buf[b:], uint32(Gc))
	b += 4

	xgb.Put32(buf[b:], uint32(Shmseg))
	b += 4

	xgb.Put32(buf[b:], Id)
	b += 4

	xgb.Put32(buf[b:], Offset)
	b += 4

	xgb.Put16(buf[b:], uint16(SrcX))
	b += 2

	xgb.Put16(buf[b:], uint16(SrcY))
	b += 2

	xgb.Put16(buf[b:], SrcW)
	b += 2

	xgb.Put16(buf[b:], SrcH)
	b += 2

	xgb.Put16(buf[b:], uint16(DrwX))
	b += 2

	xgb.Put16(buf[b:], uint16(DrwY))
	b += 2

	xgb.Put16(buf[b:], DrwW)
	b += 2

	xgb.Put16(buf[b:], DrwH)
	b += 2

	xgb.Put16(buf[b:], Width)
	b += 2

	xgb.Put16(buf[b:], Height)
	b += 2

	buf[b] = SendEvent
	b += 1

	b += 3 // padding

	return buf
}

// StopVideoCookie is a cookie used only for StopVideo requests.
type StopVideoCookie struct {
	*xgb.Cookie
}

// StopVideo sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func StopVideo(c *xgb.Conn, Port Port, Drawable xproto.Drawable) StopVideoCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'StopVideo' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(stopVideoRequest(c, Port, Drawable), cookie)
	return StopVideoCookie{cookie}
}

// StopVideoChecked sends a checked request.
// If an error occurs, it can be retrieved using StopVideoCookie.Check.
func StopVideoChecked(c *xgb.Conn, Port Port, Drawable xproto.Drawable) StopVideoCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'StopVideo' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(stopVideoRequest(c, Port, Drawable), cookie)
	return StopVideoCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook StopVideoCookie) Check() error {
	return cook.Cookie.Check()
}

// stopVideoRequest writes a StopVideo request to a byte slice for transfer.
func stopVideoRequest(c *xgb.Conn, Port Port, Drawable xproto.Drawable) []byte {
	size := 12
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 9 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Drawable))
	b += 4

	return buf
}

// UngrabPortCookie is a cookie used only for UngrabPort requests.
type UngrabPortCookie struct {
	*xgb.Cookie
}

// UngrabPort sends an unchecked request.
// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
func UngrabPort(c *xgb.Conn, Port Port, Time xproto.Timestamp) UngrabPortCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'UngrabPort' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(false, false)
	c.NewRequest(ungrabPortRequest(c, Port, Time), cookie)
	return UngrabPortCookie{cookie}
}

// UngrabPortChecked sends a checked request.
// If an error occurs, it can be retrieved using UngrabPortCookie.Check.
func UngrabPortChecked(c *xgb.Conn, Port Port, Time xproto.Timestamp) UngrabPortCookie {
	c.ExtLock.RLock()
	defer c.ExtLock.RUnlock()
	if _, ok := c.Extensions["XVideo"]; !ok {
		panic("Cannot issue request 'UngrabPort' using the uninitialized extension 'XVideo'. xv.Init(connObj) must be called first.")
	}
	cookie := c.NewCookie(true, false)
	c.NewRequest(ungrabPortRequest(c, Port, Time), cookie)
	return UngrabPortCookie{cookie}
}

// Check returns an error if one occurred for checked requests that are not expecting a reply.
// This cannot be called for requests expecting a reply, nor for unchecked requests.
func (cook UngrabPortCookie) Check() error {
	return cook.Cookie.Check()
}

// ungrabPortRequest writes a UngrabPort request to a byte slice for transfer.
func ungrabPortRequest(c *xgb.Conn, Port Port, Time xproto.Timestamp) []byte {
	size := 12
	b := 0
	buf := make([]byte, size)

	c.ExtLock.RLock()
	buf[b] = c.Extensions["XVideo"]
	c.ExtLock.RUnlock()
	b += 1

	buf[b] = 4 // request opcode
	b += 1

	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
	b += 2

	xgb.Put32(buf[b:], uint32(Port))
	b += 4

	xgb.Put32(buf[b:], uint32(Time))
	b += 4

	return buf
}