rgbmatrix

type Animation interface {
	Next() (image.Image, <-chan time.Time, error)
}

type Canvas struct {
	// contains filtered or unexported fields
}

type HardwareConfig struct {
	// This can have values such as:
	// * regular          -> The standard mapping of this library
	// * adafruit-hat     -> The Adafruit HAT/Bonnet, that uses this library
	// * adafruit-hat-pwm -> Adafruit HAT with the anti-flicker hardware mod
	// * compute-module   -> Additional 3 parallel chains can be used with the Compute Module.
	// https://github.com/hzeller/rpi-rgb-led-matrix/blob/master/wiring.md#alternative-hardware-mappings
	GPIOMapping string

	// Rows the number of rows supported by the display, so 32 or 16.
	Rows int

	// Cols the number of columns supported by the display, so 32 or 64 .
	Cols int

	// Number of daisy-chained panels.
	ChainLength int

	// Parallel is the number of parallel chains connected to the Pi; in old Pis
	// with 26 GPIO pins, that is 1, in newer Pis with 40 interfaces pins, that
	// can also be 2 or 3. The effective number of pixels in vertical direction is
	// then thus rows * parallel.
	Parallel int

	// Some panels use a different chip-set that requires some initialization.
	// If you don't see any output on your panel, try to set FM6126A
	// Some panels have the FM6127 chip, which is also an option.
	PanelType string

	// The outdoor panels have different multiplexing which allows them to be faster and brighter,
	// but by default their output looks jumbled up.
	// They require some pixel-mapping of which there are a few types you can try and hopefully
	// one of them works for your panel; The default=0 is no mapping ('standard' panels),
	//  while 1, 2, ... are different mappings to try
	// Mux type: 0=direct; 1=Stripe; 2=Checkered...
	Multiplexing int

	// This option is useful for certain 64x64 or 32x16 panels.
	// For 64x64 panels, that only have an A and B address line, you'd use RowAddressType to 1.
	// This is only tested with one panel so far, so if it doesn't work for you, please send a pull request.
	// For 32x16 outdoor panels, that have have 4 address line (A, B, C, D), it is necessary to use RowAddressType to 2.
	RowAddressType int

	// A string describing a sequence of pixel mappers that should be applied
	// to this matrix.
	// Semicolon-separated list of pixel-mappers to arrange pixels.
	// Mapping the logical layout of your boards to your physical arrangement.
	// https://github.com/hzeller/rpi-rgb-led-matrix/blob/master/examples-api-use#remapping-coordinates
	PixelMapperConfig string

	// Brightness is the initial brightness of the panel in percent. Valid range
	// is 1..100
	Brightness int

	// Set PWM bits used for output. Default is 11, but if you only deal with
	// limited comic-colors, 1 might be sufficient. Lower require less CPU and
	// increases refresh-rate.
	PWMBits int

	// This shows the current refresh rate of the LED panel
	// the time to refresh a full picture.
	ShowRefreshRate bool

	// This allows to limit the refresh rate to a particular frequency to approach a fixed refresh rate.
	// The refresh rate will now be adapted to always reach this value between frames,
	// so faster refreshes will be slowed down, but the occasional delayed frame will fit into the time-window as well,
	// thus reducing visible brightness fluctuations.
	// You can play with value a little and reduce until you find a good balance between refresh rate and flicker suppression.
	LimitRefresh int

	// This switches from progressive scan and interlaced scan.
	// The latter might look be a little nicer when you have a very low refresh rate
	// but typically it is more annoying because of the comb-effect
	// 0 = progressive; 1 = interlaced (Default: 0).
	ScanMode ScanMode

	// Change the base time-unit for the on-time in the lowest significant bit in
	// nanoseconds.  Higher numbers provide better quality (more accurate color,
	// less ghosting), but have a negative impact on the frame rate.
	// Good values for full-color display (PWM=11) are somewhere between 100 and 300.
	// If you use reduced bit color (e.g. PWM=1) and have sharp contrast applications,
	// then higher values might be good to minimize ghosting.
	PWMLSBNanoseconds int

	// The lower bits can be time dithered
	// i.e. their brightness contribution is achieved by only showing them some frames
	// This will allow higher refresh rate (or same refresh rate with increased PWMLSBNanoseconds).
	PWMDitherBits int

	// Disable the PWM hardware subsystem to create pulses. Typically, you don't
	// want to disable hardware pulsing, this is mostly for debugging and figuring
	// out if there is interference with the sound system.
	// This won't do anything if output enable is not connected to GPIO 18 in
	// non-standard wirings.
	DisableHardwarePulsing bool

	// Switch if your matrix has inverse colors on.
	InverseColors bool

	// These are if you have a different kind of LED panel where the Red, Green and Blue LEDs are mixed up
	// Default: "RGB"
	RGBSequence string
}

type Matrix interface {
	Geometry() (width, height int)
	At(position int) color.Color
	Set(position int, c color.Color)
	Apply([]color.Color) error
	Render() error
	Close() error
	GetBrightness() int
	SetBrightness(int)
}

type RGBLedMatrix struct {
	Config   *HardwareConfig
	RtConfig *RuntimeConfig
	// contains filtered or unexported fields
}

type RuntimeConfig struct {
	// The Raspberry Pi starting with Pi2 are putting out data too fast.
	// In this case, you want to slow down writing to GPIO.
	// Zero for this parameter means 'no slowdown'.
	// The default 1 (one) typically works fine
	// You have to even go further by setting it to 2 (two).
	// If you have a Raspberry Pi with a slower processor (Model A, A+, B+, Zero), then a value of 0 (zero) might work and is desirable.
	//A Raspberry Pi 3 or Pi4 might even need higher values for the panels to be happy.
	GPIOSlowdown int
}

type ScanMode int8

type ToolKit struct {
	// Canvas is the Canvas wrapping the Matrix, if you want to instanciate
	// a ToolKit with a custom Canvas you can use directly the struct,
	// without calling NewToolKit
	Canvas *Canvas

	// Transform function if present is applied just before draw the image to
	// the Matrix, this is a small example:
	//	tk.Transform = func(img image.Image) *image.NRGBA {
	//		return imaging.Fill(img, 64, 96, imaging.Center, imaging.Lanczos)
	//	}
	Transform func(img image.Image) *image.NRGBA
}