Add support for sd_mini and dynamic button sizes

Author: dhollinger

buttons/colour.go

@@ -17,9 +17,8 @@ type ColourButton struct {
 }
 
 // GetImageForButton is the interface implemention to get the button's image as an image.Image
-func (btn *ColourButton) GetImageForButton() image.Image {
-	ButtonSize := 96
-	img := image.NewRGBA(image.Rect(0, 0, ButtonSize, ButtonSize))
+func (btn *ColourButton) GetImageForButton(btnSize int) image.Image {
+	img := image.NewRGBA(image.Rect(0, 0, btnSize, btnSize))
 	//colour := color.RGBA{red, green, blue, 0}
 	draw.Draw(img, img.Bounds(), image.NewUniform(btn.colour), image.Point{0, 0}, draw.Src)
 	return img

buttons/imagefile.go

@@ -19,9 +19,9 @@ type ImageFileButton struct {
 }
 
 // GetImageForButton is the interface implemention to get the button's image as an image.Image
-func (btn *ImageFileButton) GetImageForButton() image.Image {
+func (btn *ImageFileButton) GetImageForButton(btnSize int) image.Image {
 	// TODO base the 96 on the image bounds
-	newimg := image.NewRGBA(image.Rect(0, 0, 80, 80))
+	newimg := image.NewRGBA(image.Rect(0, 0, btnSize, btnSize))
 	draw.Draw(newimg, newimg.Bounds(), btn.img, image.Point{0, 0}, draw.Src)
 	return newimg
 }
@@ -37,17 +37,17 @@ func (btn *ImageFileButton) GetButtonIndex() int {
 }
 
 // SetFilePath allows the image file to be changed on the fly
-func (btn *ImageFileButton) SetFilePath(filePath string) error {
+func (btn *ImageFileButton) SetFilePath(filePath string, btnSize int) error {
 	btn.filePath = filePath
-	err := btn.loadImage()
+	err := btn.loadImage(btnSize)
 	if err != nil {
 		return err
 	}
 	btn.updateHandler(btn)
 	return nil
 }
 
-func (btn *ImageFileButton) loadImage() error {
+func (btn *ImageFileButton) loadImage(btnSize int) error {
 	f, err := os.Open(btn.filePath)
 	if err != nil {
 		return err
@@ -59,7 +59,7 @@ func (btn *ImageFileButton) loadImage() error {
 	newimg, ok := img.(*image.RGBA)
 	if !ok {
 		// TODO base the 96 on the button size
-		newimg = image.NewRGBA(image.Rect(0, 0, 80, 80))
+		newimg = image.NewRGBA(image.Rect(0, 0, btnSize, btnSize))
 		draw.Draw(newimg, newimg.Bounds(), img, image.Point{0, 0}, draw.Src)
 	}
 
@@ -91,9 +91,9 @@ func (btn *ImageFileButton) Pressed() {
 }
 
 // NewImageFileButton creates a new ImageFileButton with the specified image on it
-func NewImageFileButton(filePath string) (*ImageFileButton, error) {
+func NewImageFileButton(filePath string, btnSize int) (*ImageFileButton, error) {
 	btn := &ImageFileButton{filePath: filePath}
-	err := btn.loadImage()
+	err := btn.loadImage(btnSize)
 	if err != nil {
 		return nil, err
 	}

buttons/text.go

@@ -23,8 +23,8 @@ type TextButton struct {
 }
 
 // GetImageForButton is the interface implemention to get the button's image as an image.Image
-func (btn *TextButton) GetImageForButton() image.Image {
-	img := getImageWithText(btn.label, btn.textColour, btn.backgroundColour)
+func (btn *TextButton) GetImageForButton(btnSize int) image.Image {
+	img := getImageWithText(btn.label, btn.textColour, btn.backgroundColour, btnSize)
 	return img
 }
 
@@ -92,9 +92,8 @@ func NewTextButtonWithColours(label string, textColour color.Color, backgroundCo
 	return btn
 }
 
-func getImageWithText(text string, textColour color.Color, backgroundColour color.Color) image.Image {
+func getImageWithText(text string, textColour color.Color, backgroundColour color.Color, btnSize int) image.Image {
 
-	ButtonSize := 96
 	size := float64(18)
 
 	myfont, err := truetype.Parse(gomedium.TTF)
@@ -113,7 +112,7 @@ func getImageWithText(text string, textColour color.Color, backgroundColour colo
 
 	srcImg := image.NewUniform(textColour)
 
-	dstImg := image.NewRGBA(image.Rect(0, 0, ButtonSize, ButtonSize))
+	dstImg := image.NewRGBA(image.Rect(0, 0, btnSize, btnSize))
 	draw.Draw(dstImg, dstImg.Bounds(), image.NewUniform(backgroundColour), image.Point{0, 0}, draw.Src)
 
 	c := freetype.NewContext()
@@ -123,7 +122,7 @@ func getImageWithText(text string, textColour color.Color, backgroundColour colo
 	c.SetFontSize(size)
 	c.SetClip(dstImg.Bounds())
 
-	x := int((96 - width) / 2) // Horizontally centre text
+	x := int((btnSize - width) / 2) // Horizontally centre text
 	y := int(50 + (size / 3))  // Fudged vertical centre, erm, very "heuristic"
 
 	pt := freetype.Pt(x, y)

comms.go

@@ -2,6 +2,7 @@ package streamdeck
 
 import (
 	"errors"
+	"fmt"
 	"image"
 	"image/color"
 
@@ -125,8 +126,8 @@ func (d *Device) SetBrightness(pct int) {
 	}
 
 	preamble := d.deviceType.brightnessPacket
-	//payload := append(preamble, byte(pct))
-	d.fd.SendFeatureReport(preamble)
+	payload := append(preamble, byte(pct))
+	d.fd.SendFeatureReport(payload)
 }
 
 // ClearButtons writes a black square to all buttons
@@ -137,18 +138,9 @@ func (d *Device) ClearButtons() {
 	}
 }
 
-// Display the Serial Number
-func (d *Device) SetSerial(b []byte) error {
-	_, err := d.fd.Write(b)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
 // WriteColorToButton writes a specified color to the given button
 func (d *Device) WriteColorToButton(btnIndex int, colour color.Color) error {
-	img := getSolidColourImage(colour)
+	img := getSolidColourImage(colour, d.deviceType.imageSize.X)
 	imgForButton, err := getImageForButton(img, d.deviceType.imageFormat)
 	if err != nil {
 		return err
@@ -208,7 +200,7 @@ func (d *Device) ResetComms() {
 
 // WriteRawImageToButton takes an `image.Image` and writes it to the given button, after resizing and rotating the image to fit the button (for some reason the StreamDeck screens are all upside down)
 func (d *Device) WriteRawImageToButton(btnIndex int, rawImg image.Image) error {
-	img := resizeAndRotate(rawImg, d.deviceType.imageSize.X, d.deviceType.imageSize.Y)
+	img := resizeAndRotate(rawImg, d.deviceType.imageSize.X, d.deviceType.imageSize.Y, d.deviceType.name)
 	imgForButton, err := getImageForButton(img, d.deviceType.imageFormat)
 	if err != nil {
 		return err
@@ -218,12 +210,14 @@ func (d *Device) WriteRawImageToButton(btnIndex int, rawImg image.Image) error {
 
 func (d *Device) rawWriteToButton(btnIndex int, rawImage []byte) error {
 	// Based on set_key_image from https://github.com/abcminiuser/python-elgato-streamdeck/blob/master/src/StreamDeck/Devices/StreamDeckXL.py#L151
+
+	if Min(Max(btnIndex, 0), int(d.deviceType.numberOfButtons)) != btnIndex {
+		return errors.New(fmt.Sprintf("Invalid key index: %d", btnIndex))
+	}
+
 	pageNumber := 0
 	bytesRemaining := len(rawImage)
 
-	// Surely no image can be more than 20 packets...?
-	payloads := make([][]byte, 20)
-
 	for bytesRemaining > 0 {
 
 		header := d.deviceType.imageHeaderFunc(uint(bytesRemaining), uint(btnIndex), uint(pageNumber))
@@ -245,13 +239,24 @@ func (d *Device) rawWriteToButton(btnIndex int, rawImage []byte) error {
 
 		thingToSend := append(payload, padding...)
 		d.fd.Write(thingToSend)
-		payloads[pageNumber] = thingToSend
 
 		bytesRemaining = bytesRemaining - thisLength
 		pageNumber = pageNumber + 1
-		if pageNumber >= len(payloads) {
-			return errors.New("Image too big for button comms, aborting - you probably need to reset the Streamdeck at this stage, and modify the size of `payloads` on line 142 to be something bigger")
-		}
 	}
 	return nil
 }
+
+// Golang Min/Max
+func Min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func Max (x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}

decorators/border.go

@@ -15,11 +15,11 @@ func NewBorder(width int, colour color.Color) *Border {
 	return b
 }
 
-func (b *Border) Apply(img image.Image) image.Image {
+func (b *Border) Apply(img image.Image, size int) image.Image {
 	newimg := img.(*image.RGBA)
 	// TODO base the 96 on the image bounds
 	for i := 0; i < b.width; i++ {
-		rect(i, i, 96-i, 96-i, newimg, b.colour)
+		rect(i, i, size-i, size-i, newimg, b.colour)
 	}
 	return newimg
 }

devices/mini.go

@@ -17,43 +17,54 @@ var (
 
 // GetImageHeaderMini returns the USB comms header for a button image for the XL
 func GetImageHeaderMini(bytesRemaining uint, btnIndex uint, pageNumber uint) []byte {
-	thisLength := uint(0)
+	var thisLength uint
 	if miniImageReportPayloadLength < bytesRemaining {
 		thisLength = miniImageReportPayloadLength
 	} else {
 		thisLength = bytesRemaining
 	}
-	header := []byte{'\x02', '\x07', byte(btnIndex)}
-	if thisLength == bytesRemaining {
-		header = append(header, '\x01')
-	} else {
-		header = append(header, '\x00')
+	header := []byte{
+		'\x02',
+		'\x01',
+		byte(pageNumber),
+		0,
+		get_header_element(thisLength, bytesRemaining),
+		byte(btnIndex + 1),
+		'\x00',
+		'\x00',
+		'\x00',
+		'\x00',
+		'\x00',
+		'\x00',
+		'\x00',
+		'\x00',
+		'\x00',
+		'\x00',
 	}
 
-	header = append(header, byte(thisLength&0xff))
-	header = append(header, byte(thisLength>>8))
-
-	header = append(header, byte(pageNumber&0xff))
-	header = append(header, byte(pageNumber>>8))
-
 	return header
 }
 
+func get_header_element(thisLength, bytesRemaining uint) byte {
+	if thisLength == bytesRemaining {
+		return '\x01'
+	} else {
+		return '\x00'
+	}
+}
+
 func init() {
 	miniName = "Streamdeck Mini"
 	miniButtonWidth = 80
 	miniButtonHeight = 80
-	miniImageReportLength = 1024
-	miniImageReportHeaderLength = 16
-	miniImageReportPayloadLength = miniImageReportLength - miniImageReportHeaderLength
+	miniImageReportPayloadLength = 1024
 	streamdeck.RegisterDevicetype(
 		miniName, // Name
 		image.Point{X: int(miniButtonWidth), Y: int(miniButtonHeight)}, // Width/height of a button
 		0x63,                        // USB productID
-		[]byte{'\x03', '\x00', '\x42', '\x00', '\x4C', '\x00', '\x33', '\x00', '\x31', '\x00', '\x4A', '\x00', '\x31', '\x00', '\x42', '\x00', '\x30', '\x00', '\x31', '\x00', '\x35', '\x00', '\x38', '\x00', '\x32', '\x00'},      // Reset packet
+		[]byte{0x0B, 0x63},      // Reset packet
 		6,                          // Number of buttons
-		//[]byte{'\x05', '\x55', '\xaa', '\xd1', '\x01'},      // Set brightness packet preamble
-		[]byte{'\x03', '\x00', '\x42', '\x00', '\x4C', '\x00', '\x33', '\x00', '\x31', '\x00', '\x4A', '\x00', '\x31', '\x00', '\x42', '\x00', '\x30', '\x00', '\x31', '\x00', '\x35', '\x00', '\x38', '\x00', '\x32', '\x00'},      // Reset packet
+		[]byte{0x05, 0x55, 0xaa, 0xd1, 0x01},      // Reset packet
 		0,                           // Button read offset
 		"BMP",                      // Image format
 		miniImageReportPayloadLength, // Amount of image payload allowed per USB packet

image.go

@@ -3,6 +3,7 @@ package streamdeck
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"image"
 	"image/color"
 	"image/draw"
@@ -15,17 +16,31 @@ import (
 	"golang.org/x/image/bmp"
 )
 
-func resizeAndRotate(img image.Image, width, height int) image.Image {
-	g := gift.New(
-		gift.Resize(width, height, gift.LanczosResampling),
-		//gift.UnsharpMask(1, 1, 0),
-		gift.Rotate180(),
-	)
+func resizeAndRotate(img image.Image, width, height int, devname string) image.Image {
+	g, _ := deviceSpecifics(devname, width, height)
 	res := image.NewRGBA(g.Bounds(img.Bounds()))
 	g.Draw(res, img)
 	return res
 }
 
+func deviceSpecifics(devName string, width, height int) (*gift.GIFT, error) {
+	switch devName {
+		case "Streamdeck XL":
+			return gift.New(
+				gift.Resize(width, height, gift.LanczosResampling),
+				gift.Rotate180(),
+			), nil
+		case "Streamdeck Mini":
+			return gift.New(
+				gift.Resize(width, height, gift.LanczosResampling),
+				gift.Rotate90(),
+				gift.FlipVertical(),
+			), nil
+		default:
+			return nil, errors.New(fmt.Sprintf("Unsupported Device: %s", devName))
+	}
+}
+
 func getImageForButton(img image.Image, btnFormat string) ([]byte, error) {
 	var b bytes.Buffer
 	switch btnFormat {
@@ -39,9 +54,8 @@ func getImageForButton(img image.Image, btnFormat string) ([]byte, error) {
 	return b.Bytes(), nil
 }
 
-func getSolidColourImage(colour color.Color) *image.RGBA {
-	ButtonSize := 80
-	img := image.NewRGBA(image.Rect(0, 0, ButtonSize, ButtonSize))
+func getSolidColourImage(colour color.Color, btnSize int) *image.RGBA {
+	img := image.NewRGBA(image.Rect(0, 0, btnSize, btnSize))
 	//colour := color.RGBA{red, green, blue, 0}
 	draw.Draw(img, img.Bounds(), image.NewUniform(colour), image.Point{0, 0}, draw.Src)
 	return img

streamdeck.go

@@ -4,7 +4,7 @@ import "image"
 
 // ButtonDisplay is the interface to satisfy for displaying on a button
 type ButtonDisplay interface {
-	GetImageForButton() image.Image
+	GetImageForButton(int) image.Image
 	GetButtonIndex() int
 	SetButtonIndex(int)
 	RegisterUpdateHandler(func(Button))
@@ -23,7 +23,7 @@ type Button interface {
 
 // ButtonDecorator represents a way to modify the button image, for example to add a highlight or an "on/off" hint
 type ButtonDecorator interface {
-	Apply(image.Image) image.Image
+	Apply(image.Image, int) image.Image
 }
 
 // StreamDeck is the main struct to represent a StreamDeck device, and internally contains the reference to a `Device`
@@ -106,19 +106,15 @@ func (sd *StreamDeck) pressHandler(btnIndex int, d *Device, err error) {
 }
 
 func (sd *StreamDeck) updateButton(b Button) error {
-	img := b.GetImageForButton()
+	img := b.GetImageForButton(sd.dev.deviceType.imageSize.X)
 	decorator, ok := sd.decorators[b.GetButtonIndex()]
 	if ok {
-		img = decorator.Apply(img)
+		img = decorator.Apply(img, sd.dev.deviceType.imageSize.X)
 	}
 	e := sd.dev.WriteRawImageToButton(b.GetButtonIndex(), img)
 	return e
 }
 
 func (sd *StreamDeck) SetBrightness(brightness int) {
-    sd.dev.SetBrightness(brightness)
-}
-
-func (sd *StreamDeck) SetSerial(b []byte) error {
-	return sd.dev.SetSerial(b)
+	sd.dev.SetBrightness(brightness)
 }