builder/builder_binary.go

////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen -go
////////////////////////////////////////////////////////////////////////////////

package builder

import (
	"android.googlesource.com/platform/tools/gpu/atom"
	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/memory"
	"android.googlesource.com/platform/tools/gpu/service"
)

func init() {
	registry.Add((*GetFramebufferColor)(nil).Class())
	registry.Add((*GetFramebufferDepth)(nil).Class())
	registry.Add((*GetHierarchy)(nil).Class())
	registry.Add((*GetMemoryInfo)(nil).Class())
	registry.Add((*GetState)(nil).Class())
	registry.Add((*GetTimingInfo)(nil).Class())
	registry.Add((*PrerenderFramebuffers)(nil).Class())
	registry.Add((*RenderFramebufferColor)(nil).Class())
	registry.Add((*RenderFramebufferDepth)(nil).Class())
	registry.Add((*ReplaceAtom)(nil).Class())
	registry.Add((*atomFramebufferDimensions)(nil).Class())
	registry.Add((*captureFramebufferDimensions)(nil).Class())
	registry.Add((*captures)(nil).Class())
	registry.Add((*getCaptureFramebufferDimensions)(nil).Class())
}

var (
	binaryIDGetFramebufferColor             = binary.ID{0x0e, 0xb7, 0x51, 0x0b, 0xcb, 0xab, 0x3f, 0x68, 0x29, 0x23, 0xe4, 0xfd, 0x33, 0xb3, 0xf1, 0xf4, 0x9d, 0xd0, 0xa4, 0x8e}
	binaryIDGetFramebufferDepth             = binary.ID{0x59, 0xd2, 0x23, 0x3c, 0xfd, 0xdc, 0xbf, 0x12, 0xf5, 0xe3, 0xff, 0x94, 0x6c, 0x8a, 0xb8, 0x86, 0xba, 0x9d, 0xb6, 0x55}
	binaryIDGetHierarchy                    = binary.ID{0x58, 0xc3, 0xc8, 0x77, 0xcf, 0x3d, 0xd5, 0x5f, 0xba, 0x3f, 0x2c, 0xa9, 0x7e, 0x16, 0xdf, 0x52, 0x5b, 0xbb, 0x65, 0x8b}
	binaryIDGetMemoryInfo                   = binary.ID{0x22, 0xa8, 0x99, 0x68, 0xab, 0xd1, 0x15, 0x03, 0xc1, 0xa8, 0x64, 0x09, 0xc6, 0x32, 0xe0, 0xbe, 0x47, 0xdd, 0x4e, 0xfc}
	binaryIDGetState                        = binary.ID{0x1a, 0xda, 0x15, 0x58, 0x2c, 0x9d, 0xff, 0x1a, 0x42, 0xcc, 0x07, 0xa5, 0xd4, 0x52, 0x07, 0xd1, 0xc1, 0x45, 0x05, 0xf9}
	binaryIDGetTimingInfo                   = binary.ID{0x18, 0xb3, 0x4b, 0x61, 0x18, 0x55, 0xe0, 0x28, 0xc9, 0xcb, 0x16, 0x0f, 0x7f, 0x43, 0x8c, 0x78, 0x96, 0x27, 0xdb, 0xc7}
	binaryIDPrerenderFramebuffers           = binary.ID{0x3c, 0xf2, 0xf2, 0xa2, 0x16, 0xa8, 0xe1, 0xe2, 0x7f, 0x51, 0xb8, 0xbb, 0xaa, 0x36, 0x11, 0x8d, 0x00, 0xb6, 0xf6, 0x79}
	binaryIDRenderFramebufferColor          = binary.ID{0xc2, 0x1c, 0x41, 0xbf, 0x83, 0x9e, 0xd9, 0xdd, 0x8f, 0x52, 0x56, 0xc2, 0xba, 0xaa, 0xd2, 0xed, 0x23, 0xc2, 0xd2, 0x86}
	binaryIDRenderFramebufferDepth          = binary.ID{0xa9, 0x18, 0x0d, 0x72, 0xb6, 0x3d, 0xe5, 0x46, 0xaf, 0x7a, 0x63, 0xe4, 0x25, 0xa6, 0x80, 0xa8, 0x3b, 0x2c, 0x2b, 0x7d}
	binaryIDReplaceAtom                     = binary.ID{0x81, 0x95, 0x81, 0x1b, 0xdd, 0x39, 0xfe, 0x7c, 0x43, 0x51, 0x80, 0xbc, 0x3b, 0xf1, 0x71, 0x44, 0x1e, 0x7b, 0x9e, 0x3a}
	binaryIDatomFramebufferDimensions       = binary.ID{0xb6, 0xbb, 0x6b, 0x01, 0xb6, 0x82, 0xdb, 0x1f, 0xca, 0x6c, 0x74, 0x22, 0xc4, 0x74, 0xca, 0x61, 0xdd, 0x28, 0xe6, 0xf3}
	binaryIDcaptureFramebufferDimensions    = binary.ID{0xb6, 0xbf, 0x92, 0x09, 0xa7, 0xde, 0x07, 0xf3, 0x0d, 0x9b, 0x37, 0xf8, 0x67, 0x83, 0x83, 0xbb, 0xb4, 0x8b, 0x53, 0xf5}
	binaryIDcaptures                        = binary.ID{0xcd, 0x35, 0x8f, 0x5e, 0x40, 0x7f, 0x41, 0x75, 0x9b, 0xf7, 0x39, 0x22, 0xe1, 0xc2, 0x06, 0xd0, 0x20, 0xcc, 0xca, 0xe4}
	binaryIDgetCaptureFramebufferDimensions = binary.ID{0x92, 0xe3, 0x84, 0xf0, 0x3e, 0x83, 0x2c, 0x83, 0xc0, 0x22, 0x15, 0xad, 0x75, 0x9b, 0x02, 0xdc, 0x1f, 0x4e, 0x49, 0x4c}
)

type binaryClassGetFramebufferColor struct{}

func (*GetFramebufferColor) Class() binary.Class {
	return (*binaryClassGetFramebufferColor)(nil)
}
func doEncodeGetFramebufferColor(e binary.Encoder, o *GetFramebufferColor) error {
	if err := e.Value(&o.Device); err != nil {
		return err
	}
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Value(&o.API); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.After)); err != nil {
		return err
	}
	if err := e.Value(&o.Settings); err != nil {
		return err
	}
	return nil
}
func doDecodeGetFramebufferColor(d binary.Decoder, o *GetFramebufferColor) error {
	if err := d.Value(&o.Device); err != nil {
		return err
	}
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if err := d.Value(&o.API); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.After = atom.ID(obj)
	}
	if err := d.Value(&o.Settings); err != nil {
		return err
	}
	return nil
}
func doSkipGetFramebufferColor(d binary.Decoder) error {
	if err := d.SkipValue((*service.DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if err := d.SkipValue((*service.RenderSettings)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetFramebufferColor) ID() binary.ID      { return binaryIDGetFramebufferColor }
func (*binaryClassGetFramebufferColor) New() binary.Object { return &GetFramebufferColor{} }
func (*binaryClassGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetFramebufferColor(e, obj.(*GetFramebufferColor))
}
func (*binaryClassGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetFramebufferColor{}
	return obj, doDecodeGetFramebufferColor(d, obj)
}
func (*binaryClassGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetFramebufferColor(d, obj.(*GetFramebufferColor))
}
func (*binaryClassGetFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipGetFramebufferColor(d)
}
func (*binaryClassGetFramebufferColor) Schema() *schema.Class { return schemaGetFramebufferColor }

var schemaGetFramebufferColor = &schema.Class{
	TypeID: binaryIDGetFramebufferColor,
	Name:   "GetFramebufferColor",
	Fields: []schema.Field{
		schema.Field{Declared: "Device", Type: &schema.Struct{Name: "service.DeviceId"}},
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "API", Type: &schema.Struct{Name: "service.ApiId"}},
		schema.Field{Declared: "After", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		schema.Field{Declared: "Settings", Type: &schema.Struct{Name: "service.RenderSettings"}},
	},
}

type binaryClassGetFramebufferDepth struct{}

func (*GetFramebufferDepth) Class() binary.Class {
	return (*binaryClassGetFramebufferDepth)(nil)
}
func doEncodeGetFramebufferDepth(e binary.Encoder, o *GetFramebufferDepth) error {
	if err := e.Value(&o.Device); err != nil {
		return err
	}
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Value(&o.API); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.After)); err != nil {
		return err
	}
	return nil
}
func doDecodeGetFramebufferDepth(d binary.Decoder, o *GetFramebufferDepth) error {
	if err := d.Value(&o.Device); err != nil {
		return err
	}
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if err := d.Value(&o.API); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.After = atom.ID(obj)
	}
	return nil
}
func doSkipGetFramebufferDepth(d binary.Decoder) error {
	if err := d.SkipValue((*service.DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetFramebufferDepth) ID() binary.ID      { return binaryIDGetFramebufferDepth }
func (*binaryClassGetFramebufferDepth) New() binary.Object { return &GetFramebufferDepth{} }
func (*binaryClassGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetFramebufferDepth(e, obj.(*GetFramebufferDepth))
}
func (*binaryClassGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetFramebufferDepth{}
	return obj, doDecodeGetFramebufferDepth(d, obj)
}
func (*binaryClassGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetFramebufferDepth(d, obj.(*GetFramebufferDepth))
}
func (*binaryClassGetFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipGetFramebufferDepth(d)
}
func (*binaryClassGetFramebufferDepth) Schema() *schema.Class { return schemaGetFramebufferDepth }

var schemaGetFramebufferDepth = &schema.Class{
	TypeID: binaryIDGetFramebufferDepth,
	Name:   "GetFramebufferDepth",
	Fields: []schema.Field{
		schema.Field{Declared: "Device", Type: &schema.Struct{Name: "service.DeviceId"}},
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "API", Type: &schema.Struct{Name: "service.ApiId"}},
		schema.Field{Declared: "After", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
	},
}

type binaryClassGetHierarchy struct{}

func (*GetHierarchy) Class() binary.Class {
	return (*binaryClassGetHierarchy)(nil)
}
func doEncodeGetHierarchy(e binary.Encoder, o *GetHierarchy) error {
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	return nil
}
func doDecodeGetHierarchy(d binary.Decoder, o *GetHierarchy) error {
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	return nil
}
func doSkipGetHierarchy(d binary.Decoder) error {
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetHierarchy) ID() binary.ID      { return binaryIDGetHierarchy }
func (*binaryClassGetHierarchy) New() binary.Object { return &GetHierarchy{} }
func (*binaryClassGetHierarchy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetHierarchy(e, obj.(*GetHierarchy))
}
func (*binaryClassGetHierarchy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetHierarchy{}
	return obj, doDecodeGetHierarchy(d, obj)
}
func (*binaryClassGetHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetHierarchy(d, obj.(*GetHierarchy))
}
func (*binaryClassGetHierarchy) Skip(d binary.Decoder) error { return doSkipGetHierarchy(d) }
func (*binaryClassGetHierarchy) Schema() *schema.Class       { return schemaGetHierarchy }

var schemaGetHierarchy = &schema.Class{
	TypeID: binaryIDGetHierarchy,
	Name:   "GetHierarchy",
	Fields: []schema.Field{
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
	},
}

type binaryClassGetMemoryInfo struct{}

func (*GetMemoryInfo) Class() binary.Class {
	return (*binaryClassGetMemoryInfo)(nil)
}
func doEncodeGetMemoryInfo(e binary.Encoder, o *GetMemoryInfo) error {
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.After)); err != nil {
		return err
	}
	if err := e.Value(&o.Range); err != nil {
		return err
	}
	return nil
}
func doDecodeGetMemoryInfo(d binary.Decoder, o *GetMemoryInfo) error {
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.After = atom.ID(obj)
	}
	if err := d.Value(&o.Range); err != nil {
		return err
	}
	return nil
}
func doSkipGetMemoryInfo(d binary.Decoder) error {
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if err := d.SkipValue((*memory.Range)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetMemoryInfo) ID() binary.ID      { return binaryIDGetMemoryInfo }
func (*binaryClassGetMemoryInfo) New() binary.Object { return &GetMemoryInfo{} }
func (*binaryClassGetMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetMemoryInfo(e, obj.(*GetMemoryInfo))
}
func (*binaryClassGetMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetMemoryInfo{}
	return obj, doDecodeGetMemoryInfo(d, obj)
}
func (*binaryClassGetMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetMemoryInfo(d, obj.(*GetMemoryInfo))
}
func (*binaryClassGetMemoryInfo) Skip(d binary.Decoder) error { return doSkipGetMemoryInfo(d) }
func (*binaryClassGetMemoryInfo) Schema() *schema.Class       { return schemaGetMemoryInfo }

var schemaGetMemoryInfo = &schema.Class{
	TypeID: binaryIDGetMemoryInfo,
	Name:   "GetMemoryInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "After", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		schema.Field{Declared: "Range", Type: &schema.Struct{Name: "memory.Range"}},
	},
}

type binaryClassGetState struct{}

func (*GetState) Class() binary.Class {
	return (*binaryClassGetState)(nil)
}
func doEncodeGetState(e binary.Encoder, o *GetState) error {
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.After)); err != nil {
		return err
	}
	return nil
}
func doDecodeGetState(d binary.Decoder, o *GetState) error {
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.After = atom.ID(obj)
	}
	return nil
}
func doSkipGetState(d binary.Decoder) error {
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetState) ID() binary.ID      { return binaryIDGetState }
func (*binaryClassGetState) New() binary.Object { return &GetState{} }
func (*binaryClassGetState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetState(e, obj.(*GetState))
}
func (*binaryClassGetState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetState{}
	return obj, doDecodeGetState(d, obj)
}
func (*binaryClassGetState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetState(d, obj.(*GetState))
}
func (*binaryClassGetState) Skip(d binary.Decoder) error { return doSkipGetState(d) }
func (*binaryClassGetState) Schema() *schema.Class       { return schemaGetState }

var schemaGetState = &schema.Class{
	TypeID: binaryIDGetState,
	Name:   "GetState",
	Fields: []schema.Field{
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "After", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
	},
}

type binaryClassGetTimingInfo struct{}

func (*GetTimingInfo) Class() binary.Class {
	return (*binaryClassGetTimingInfo)(nil)
}
func doEncodeGetTimingInfo(e binary.Encoder, o *GetTimingInfo) error {
	if err := e.Value(&o.Device); err != nil {
		return err
	}
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Int32(int32(o.TimingMask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGetTimingInfo(d binary.Decoder, o *GetTimingInfo) error {
	if err := d.Value(&o.Device); err != nil {
		return err
	}
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.TimingMask = service.TimingMask(obj)
	}
	return nil
}
func doSkipGetTimingInfo(d binary.Decoder) error {
	if err := d.SkipValue((*service.DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGetTimingInfo) ID() binary.ID      { return binaryIDGetTimingInfo }
func (*binaryClassGetTimingInfo) New() binary.Object { return &GetTimingInfo{} }
func (*binaryClassGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGetTimingInfo(e, obj.(*GetTimingInfo))
}
func (*binaryClassGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GetTimingInfo{}
	return obj, doDecodeGetTimingInfo(d, obj)
}
func (*binaryClassGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGetTimingInfo(d, obj.(*GetTimingInfo))
}
func (*binaryClassGetTimingInfo) Skip(d binary.Decoder) error { return doSkipGetTimingInfo(d) }
func (*binaryClassGetTimingInfo) Schema() *schema.Class       { return schemaGetTimingInfo }

var schemaGetTimingInfo = &schema.Class{
	TypeID: binaryIDGetTimingInfo,
	Name:   "GetTimingInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Device", Type: &schema.Struct{Name: "service.DeviceId"}},
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "TimingMask", Type: &schema.Primitive{Name: "service.TimingMask", Method: schema.Int32}},
	},
}

type binaryClassPrerenderFramebuffers struct{}

func (*PrerenderFramebuffers) Class() binary.Class {
	return (*binaryClassPrerenderFramebuffers)(nil)
}
func doEncodePrerenderFramebuffers(e binary.Encoder, o *PrerenderFramebuffers) error {
	if err := e.Value(&o.Device); err != nil {
		return err
	}
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Value(&o.API); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.AtomIDs))); err != nil {
		return err
	}
	for i := range o.AtomIDs {
		if err := e.Uint64(o.AtomIDs[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	return nil
}
func doDecodePrerenderFramebuffers(d binary.Decoder, o *PrerenderFramebuffers) error {
	if err := d.Value(&o.Device); err != nil {
		return err
	}
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if err := d.Value(&o.API); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.AtomIDs = make([]uint64, count)
		for i := range o.AtomIDs {
			if obj, err := d.Uint64(); err != nil {
				return err
			} else {
				o.AtomIDs[i] = uint64(obj)
			}
		}
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	return nil
}
func doSkipPrerenderFramebuffers(d binary.Decoder) error {
	if err := d.SkipValue((*service.DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.ApiId)(nil)); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint64(); err != nil {
				return err
			}
		}
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassPrerenderFramebuffers) ID() binary.ID      { return binaryIDPrerenderFramebuffers }
func (*binaryClassPrerenderFramebuffers) New() binary.Object { return &PrerenderFramebuffers{} }
func (*binaryClassPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodePrerenderFramebuffers(e, obj.(*PrerenderFramebuffers))
}
func (*binaryClassPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &PrerenderFramebuffers{}
	return obj, doDecodePrerenderFramebuffers(d, obj)
}
func (*binaryClassPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodePrerenderFramebuffers(d, obj.(*PrerenderFramebuffers))
}
func (*binaryClassPrerenderFramebuffers) Skip(d binary.Decoder) error {
	return doSkipPrerenderFramebuffers(d)
}
func (*binaryClassPrerenderFramebuffers) Schema() *schema.Class { return schemaPrerenderFramebuffers }

var schemaPrerenderFramebuffers = &schema.Class{
	TypeID: binaryIDPrerenderFramebuffers,
	Name:   "PrerenderFramebuffers",
	Fields: []schema.Field{
		schema.Field{Declared: "Device", Type: &schema.Struct{Name: "service.DeviceId"}},
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "API", Type: &schema.Struct{Name: "service.ApiId"}},
		schema.Field{Declared: "AtomIDs", Type: &schema.Slice{Alias: "", ValueType: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}},
		schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassRenderFramebufferColor struct{}

func (*RenderFramebufferColor) Class() binary.Class {
	return (*binaryClassRenderFramebufferColor)(nil)
}
func doEncodeRenderFramebufferColor(e binary.Encoder, o *RenderFramebufferColor) error {
	if err := e.Value(&o.Device); err != nil {
		return err
	}
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Value(&o.API); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.After)); err != nil {
		return err
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	if err := e.Bool(o.Wireframe); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderFramebufferColor(d binary.Decoder, o *RenderFramebufferColor) error {
	if err := d.Value(&o.Device); err != nil {
		return err
	}
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if err := d.Value(&o.API); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.After = atom.ID(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Wireframe = bool(obj)
	}
	return nil
}
func doSkipRenderFramebufferColor(d binary.Decoder) error {
	if err := d.SkipValue((*service.DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderFramebufferColor) ID() binary.ID      { return binaryIDRenderFramebufferColor }
func (*binaryClassRenderFramebufferColor) New() binary.Object { return &RenderFramebufferColor{} }
func (*binaryClassRenderFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderFramebufferColor(e, obj.(*RenderFramebufferColor))
}
func (*binaryClassRenderFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderFramebufferColor{}
	return obj, doDecodeRenderFramebufferColor(d, obj)
}
func (*binaryClassRenderFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderFramebufferColor(d, obj.(*RenderFramebufferColor))
}
func (*binaryClassRenderFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipRenderFramebufferColor(d)
}
func (*binaryClassRenderFramebufferColor) Schema() *schema.Class { return schemaRenderFramebufferColor }

var schemaRenderFramebufferColor = &schema.Class{
	TypeID: binaryIDRenderFramebufferColor,
	Name:   "RenderFramebufferColor",
	Fields: []schema.Field{
		schema.Field{Declared: "Device", Type: &schema.Struct{Name: "service.DeviceId"}},
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "API", Type: &schema.Struct{Name: "service.ApiId"}},
		schema.Field{Declared: "After", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "Wireframe", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassRenderFramebufferDepth struct{}

func (*RenderFramebufferDepth) Class() binary.Class {
	return (*binaryClassRenderFramebufferDepth)(nil)
}
func doEncodeRenderFramebufferDepth(e binary.Encoder, o *RenderFramebufferDepth) error {
	if err := e.Value(&o.Device); err != nil {
		return err
	}
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Value(&o.API); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.After)); err != nil {
		return err
	}
	if err := e.Uint32(o.FramebufferWidth); err != nil {
		return err
	}
	if err := e.Uint32(o.FramebufferHeight); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderFramebufferDepth(d binary.Decoder, o *RenderFramebufferDepth) error {
	if err := d.Value(&o.Device); err != nil {
		return err
	}
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if err := d.Value(&o.API); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.After = atom.ID(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferWidth = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferHeight = uint32(obj)
	}
	return nil
}
func doSkipRenderFramebufferDepth(d binary.Decoder) error {
	if err := d.SkipValue((*service.DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*service.ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderFramebufferDepth) ID() binary.ID      { return binaryIDRenderFramebufferDepth }
func (*binaryClassRenderFramebufferDepth) New() binary.Object { return &RenderFramebufferDepth{} }
func (*binaryClassRenderFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderFramebufferDepth(e, obj.(*RenderFramebufferDepth))
}
func (*binaryClassRenderFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderFramebufferDepth{}
	return obj, doDecodeRenderFramebufferDepth(d, obj)
}
func (*binaryClassRenderFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderFramebufferDepth(d, obj.(*RenderFramebufferDepth))
}
func (*binaryClassRenderFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipRenderFramebufferDepth(d)
}
func (*binaryClassRenderFramebufferDepth) Schema() *schema.Class { return schemaRenderFramebufferDepth }

var schemaRenderFramebufferDepth = &schema.Class{
	TypeID: binaryIDRenderFramebufferDepth,
	Name:   "RenderFramebufferDepth",
	Fields: []schema.Field{
		schema.Field{Declared: "Device", Type: &schema.Struct{Name: "service.DeviceId"}},
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "API", Type: &schema.Struct{Name: "service.ApiId"}},
		schema.Field{Declared: "After", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		schema.Field{Declared: "FramebufferWidth", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "FramebufferHeight", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassReplaceAtom struct{}

func (*ReplaceAtom) Class() binary.Class {
	return (*binaryClassReplaceAtom)(nil)
}
func doEncodeReplaceAtom(e binary.Encoder, o *ReplaceAtom) error {
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Atom)); err != nil {
		return err
	}
	if err := e.Uint16(uint16(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeReplaceAtom(d binary.Decoder, o *ReplaceAtom) error {
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Atom = atom.ID(obj)
	}
	if obj, err := d.Uint16(); err != nil {
		return err
	} else {
		o.Type = atom.TypeID(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipReplaceAtom(d binary.Decoder) error {
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint16(); err != nil {
		return err
	}
	if err := d.SkipValue((*service.Binary)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassReplaceAtom) ID() binary.ID      { return binaryIDReplaceAtom }
func (*binaryClassReplaceAtom) New() binary.Object { return &ReplaceAtom{} }
func (*binaryClassReplaceAtom) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeReplaceAtom(e, obj.(*ReplaceAtom))
}
func (*binaryClassReplaceAtom) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ReplaceAtom{}
	return obj, doDecodeReplaceAtom(d, obj)
}
func (*binaryClassReplaceAtom) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeReplaceAtom(d, obj.(*ReplaceAtom))
}
func (*binaryClassReplaceAtom) Skip(d binary.Decoder) error { return doSkipReplaceAtom(d) }
func (*binaryClassReplaceAtom) Schema() *schema.Class       { return schemaReplaceAtom }

var schemaReplaceAtom = &schema.Class{
	TypeID: binaryIDReplaceAtom,
	Name:   "ReplaceAtom",
	Fields: []schema.Field{
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
		schema.Field{Declared: "Atom", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "atom.TypeID", Method: schema.Uint16}},
		schema.Field{Declared: "Data", Type: &schema.Struct{Name: "service.Binary"}},
	},
}

type binaryClassatomFramebufferDimensions struct{}

func (*atomFramebufferDimensions) Class() binary.Class {
	return (*binaryClassatomFramebufferDimensions)(nil)
}
func doEncodeatomFramebufferDimensions(e binary.Encoder, o *atomFramebufferDimensions) error {
	if err := e.Uint64(uint64(o.From)); err != nil {
		return err
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	return nil
}
func doDecodeatomFramebufferDimensions(d binary.Decoder, o *atomFramebufferDimensions) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.From = atom.ID(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	return nil
}
func doSkipatomFramebufferDimensions(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassatomFramebufferDimensions) ID() binary.ID      { return binaryIDatomFramebufferDimensions }
func (*binaryClassatomFramebufferDimensions) New() binary.Object { return &atomFramebufferDimensions{} }
func (*binaryClassatomFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeatomFramebufferDimensions(e, obj.(*atomFramebufferDimensions))
}
func (*binaryClassatomFramebufferDimensions) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &atomFramebufferDimensions{}
	return obj, doDecodeatomFramebufferDimensions(d, obj)
}
func (*binaryClassatomFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeatomFramebufferDimensions(d, obj.(*atomFramebufferDimensions))
}
func (*binaryClassatomFramebufferDimensions) Skip(d binary.Decoder) error {
	return doSkipatomFramebufferDimensions(d)
}
func (*binaryClassatomFramebufferDimensions) Schema() *schema.Class {
	return schemaatomFramebufferDimensions
}

var schemaatomFramebufferDimensions = &schema.Class{
	TypeID: binaryIDatomFramebufferDimensions,
	Name:   "atomFramebufferDimensions",
	Fields: []schema.Field{
		schema.Field{Declared: "From", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClasscaptureFramebufferDimensions struct{}

func (*captureFramebufferDimensions) Class() binary.Class {
	return (*binaryClasscaptureFramebufferDimensions)(nil)
}
func doEncodecaptureFramebufferDimensions(e binary.Encoder, o *captureFramebufferDimensions) error {
	if err := e.Uint32(uint32(len(o.Dimensions))); err != nil {
		return err
	}
	for i := range o.Dimensions {
		if err := e.Value(&o.Dimensions[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodecaptureFramebufferDimensions(d binary.Decoder, o *captureFramebufferDimensions) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Dimensions = make([]atomFramebufferDimensions, count)
		for i := range o.Dimensions {
			if err := d.Value(&o.Dimensions[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipcaptureFramebufferDimensions(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*atomFramebufferDimensions)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClasscaptureFramebufferDimensions) ID() binary.ID {
	return binaryIDcaptureFramebufferDimensions
}
func (*binaryClasscaptureFramebufferDimensions) New() binary.Object {
	return &captureFramebufferDimensions{}
}
func (*binaryClasscaptureFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecaptureFramebufferDimensions(e, obj.(*captureFramebufferDimensions))
}
func (*binaryClasscaptureFramebufferDimensions) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &captureFramebufferDimensions{}
	return obj, doDecodecaptureFramebufferDimensions(d, obj)
}
func (*binaryClasscaptureFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecaptureFramebufferDimensions(d, obj.(*captureFramebufferDimensions))
}
func (*binaryClasscaptureFramebufferDimensions) Skip(d binary.Decoder) error {
	return doSkipcaptureFramebufferDimensions(d)
}
func (*binaryClasscaptureFramebufferDimensions) Schema() *schema.Class {
	return schemacaptureFramebufferDimensions
}

var schemacaptureFramebufferDimensions = &schema.Class{
	TypeID: binaryIDcaptureFramebufferDimensions,
	Name:   "captureFramebufferDimensions",
	Fields: []schema.Field{
		schema.Field{Declared: "Dimensions", Type: &schema.Slice{Alias: "", ValueType: &schema.Struct{Name: "atomFramebufferDimensions"}}},
	},
}

type binaryClasscaptures struct{}

func (*captures) Class() binary.Class {
	return (*binaryClasscaptures)(nil)
}
func doEncodecaptures(e binary.Encoder, o *captures) error {
	if err := e.Uint32(uint32(len(o.ids))); err != nil {
		return err
	}
	for i := range o.ids {
		if err := e.Value(&o.ids[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodecaptures(d binary.Decoder, o *captures) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ids = make(service.CaptureIdArray, count)
		for i := range o.ids {
			if err := d.Value(&o.ids[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipcaptures(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClasscaptures) ID() binary.ID      { return binaryIDcaptures }
func (*binaryClasscaptures) New() binary.Object { return &captures{} }
func (*binaryClasscaptures) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecaptures(e, obj.(*captures))
}
func (*binaryClasscaptures) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &captures{}
	return obj, doDecodecaptures(d, obj)
}
func (*binaryClasscaptures) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecaptures(d, obj.(*captures))
}
func (*binaryClasscaptures) Skip(d binary.Decoder) error { return doSkipcaptures(d) }
func (*binaryClasscaptures) Schema() *schema.Class       { return schemacaptures }

var schemacaptures = &schema.Class{
	TypeID: binaryIDcaptures,
	Name:   "captures",
	Fields: []schema.Field{
		schema.Field{Declared: "ids", Type: &schema.Slice{Alias: "service.CaptureIdArray", ValueType: &schema.Struct{Name: "service.CaptureId"}}},
	},
}

type binaryClassgetCaptureFramebufferDimensions struct{}

func (*getCaptureFramebufferDimensions) Class() binary.Class {
	return (*binaryClassgetCaptureFramebufferDimensions)(nil)
}
func doEncodegetCaptureFramebufferDimensions(e binary.Encoder, o *getCaptureFramebufferDimensions) error {
	if err := e.Value(&o.Capture); err != nil {
		return err
	}
	return nil
}
func doDecodegetCaptureFramebufferDimensions(d binary.Decoder, o *getCaptureFramebufferDimensions) error {
	if err := d.Value(&o.Capture); err != nil {
		return err
	}
	return nil
}
func doSkipgetCaptureFramebufferDimensions(d binary.Decoder) error {
	if err := d.SkipValue((*service.CaptureId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassgetCaptureFramebufferDimensions) ID() binary.ID {
	return binaryIDgetCaptureFramebufferDimensions
}
func (*binaryClassgetCaptureFramebufferDimensions) New() binary.Object {
	return &getCaptureFramebufferDimensions{}
}
func (*binaryClassgetCaptureFramebufferDimensions) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodegetCaptureFramebufferDimensions(e, obj.(*getCaptureFramebufferDimensions))
}
func (*binaryClassgetCaptureFramebufferDimensions) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &getCaptureFramebufferDimensions{}
	return obj, doDecodegetCaptureFramebufferDimensions(d, obj)
}
func (*binaryClassgetCaptureFramebufferDimensions) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodegetCaptureFramebufferDimensions(d, obj.(*getCaptureFramebufferDimensions))
}
func (*binaryClassgetCaptureFramebufferDimensions) Skip(d binary.Decoder) error {
	return doSkipgetCaptureFramebufferDimensions(d)
}
func (*binaryClassgetCaptureFramebufferDimensions) Schema() *schema.Class {
	return schemagetCaptureFramebufferDimensions
}

var schemagetCaptureFramebufferDimensions = &schema.Class{
	TypeID: binaryIDgetCaptureFramebufferDimensions,
	Name:   "getCaptureFramebufferDimensions",
	Fields: []schema.Field{
		schema.Field{Declared: "Capture", Type: &schema.Struct{Name: "service.CaptureId"}},
	},
}