xgb-image: add a demo that shows a scaled picture

1 files changed, 252 insertions, 0 deletions

diff --git a/prototypes/xgb-image.go b/prototypes/xgb-image.go
new file mode 100644
index 0000000..5c3d74a
--- /dev/null
+++ b/prototypes/xgb-image.go
@@ -0,0 +1,252 @@
+package main
+
+import (
+	"encoding/binary"
+	"github.com/BurntSushi/xgb"
+	"github.com/BurntSushi/xgb/render"
+	"github.com/BurntSushi/xgb/xproto"
+	"log"
+	"os"
+	"time"
+
+	"image"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+)
+
+func F64ToFixed(f float64) render.Fixed { return render.Fixed(f * 65536) }
+func FixedToF64(f render.Fixed) float64 { return float64(f) / 65536 }
+
+func main() {
+	/*
+		pf, err := os.Create("pprof.out")
+		if err != nil {
+			log.Fatal(err)
+		}
+		pprof.StartCPUProfile(pf)
+		defer pprof.StopCPUProfile()
+	*/
+
+	// Load a picture from the command line.
+	f, err := os.Open(os.Args[1])
+	if err != nil {
+		log.Fatalln(err)
+	}
+	defer f.Close()
+
+	img, name, err := image.Decode(f)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	log.Println("image type is", name)
+
+	// Miscellaneous X11 initialization.
+	X, err := xgb.NewConn()
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	if err := render.Init(X); err != nil {
+		log.Fatalln(err)
+	}
+
+	setup := xproto.Setup(X)
+	screen := setup.DefaultScreen(X)
+
+	visual, depth := screen.RootVisual, screen.RootDepth
+	// TODO: We should check that we find it, though we don't /need/ alpha here,
+	// it's just a minor improvement--affects the backpixel value.
+	for _, i := range screen.AllowedDepths {
+		for _, v := range i.Visuals {
+			// TODO: Could/should check other parameters.
+			if i.Depth == 32 && v.Class == xproto.VisualClassTrueColor {
+				visual, depth = v.VisualId, i.Depth
+				break
+			}
+		}
+	}
+
+	mid, err := xproto.NewColormapId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	_ = xproto.CreateColormap(
+		X, xproto.ColormapAllocNone, mid, screen.Root, visual)
+
+	wid, err := xproto.NewWindowId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	// Border pixel and colormap are required when depth differs from parent.
+	_ = xproto.CreateWindow(X, depth, wid, screen.Root,
+		0, 0, 500, 500, 0, xproto.WindowClassInputOutput,
+		visual, xproto.CwBackPixel|xproto.CwBorderPixel|xproto.CwEventMask|
+			xproto.CwColormap, []uint32{0x80808080, 0,
+			xproto.EventMaskStructureNotify | xproto.EventMaskExposure,
+			uint32(mid)})
+
+	title := []byte("Image")
+	_ = xproto.ChangeProperty(X, xproto.PropModeReplace, wid, xproto.AtomWmName,
+		xproto.AtomString, 8, uint32(len(title)), title)
+
+	_ = xproto.MapWindow(X, wid)
+
+	pformats, err := render.QueryPictFormats(X).Reply()
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	// Similar to XRenderFindVisualFormat.
+	// The DefaultScreen is almost certain to be zero.
+	var pformat render.Pictformat
+	for _, pd := range pformats.Screens[X.DefaultScreen].Depths {
+		// This check seems to be slightly extraneous.
+		if pd.Depth != depth {
+			continue
+		}
+		for _, pv := range pd.Visuals {
+			if pv.Visual == visual {
+				pformat = pv.Format
+			}
+		}
+	}
+
+	// Wrap the window's surface in a picture.
+	pid, err := render.NewPictureId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	render.CreatePicture(X, pid, xproto.Drawable(wid), pformat, 0, []uint32{})
+
+	// setup.BitmapFormatScanline{Pad,Unit} and setup.BitmapFormatBitOrder
+	// don't interest us here since we're only using Z format pixmaps.
+	for _, pf := range setup.PixmapFormats {
+		if pf.Depth == 32 {
+			if pf.BitsPerPixel != 32 || pf.ScanlinePad != 32 {
+				log.Fatalln("unsuported X server")
+			}
+		}
+	}
+
+	pixid, err := xproto.NewPixmapId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	_ = xproto.CreatePixmap(X, 32, pixid, xproto.Drawable(screen.Root),
+		uint16(img.Bounds().Dx()), uint16(img.Bounds().Dy()))
+
+	var bgraFormat render.Pictformat
+	wanted := render.Directformat{
+		RedShift:   16,
+		RedMask:    0xff,
+		GreenShift: 8,
+		GreenMask:  0xff,
+		BlueShift:  0,
+		BlueMask:   0xff,
+		AlphaShift: 24,
+		AlphaMask:  0xff,
+	}
+	for _, pf := range pformats.Formats {
+		if pf.Depth == 32 && pf.Direct == wanted {
+			bgraFormat = pf.Id
+			break
+		}
+	}
+	if bgraFormat == 0 {
+		log.Fatalln("ARGB format not found")
+	}
+
+	// We could also look for the inverse pictformat.
+	var encoding binary.ByteOrder
+	if setup.ImageByteOrder == xproto.ImageOrderMSBFirst {
+		encoding = binary.BigEndian
+	} else {
+		encoding = binary.LittleEndian
+	}
+
+	pixpicid, err := render.NewPictureId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	render.CreatePicture(X, pixpicid, xproto.Drawable(pixid), bgraFormat,
+		0, []uint32{})
+
+	// Do we really need this? :/
+	cid, err := xproto.NewGcontextId(X)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	_ = xproto.CreateGC(X, cid, xproto.Drawable(pixid),
+		xproto.GcGraphicsExposures, []uint32{0})
+
+	// Load data into the pixmap. Also see xgbutil/xgraphics/xsurface.go.
+	// We're being lazy and resolve the 1<<16 limit of requests by sending
+	// a row at a time. The encoding is also done inefficiently.
+	bounds := img.Bounds()
+
+	Lstart := time.Now()
+
+	row := make([]byte, bounds.Dx()*4)
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			r, g, b, a := img.At(x, y).RGBA()
+			encoding.PutUint32(row[x*4:],
+				(a>>8)<<24|(r>>8)<<16|(g>>8)<<8|(b>>8))
+		}
+		_ = xproto.PutImage(X, xproto.ImageFormatZPixmap,
+			xproto.Drawable(pixid), cid, uint16(bounds.Dx()), 1,
+			0, int16(y),
+			0, 32, row)
+	}
+
+	log.Println("uploading took", time.Now().Sub(Lstart))
+
+	// TODO: SHM, for an example see https://github.com/BurntSushi/xgb/issues/28
+
+	var scale float64 = 1
+	for {
+		ev, xerr := X.WaitForEvent()
+		if xerr != nil {
+			log.Printf("Error: %s\n", xerr)
+			return
+		}
+		if ev == nil {
+			return
+		}
+
+		log.Printf("Event: %s\n", ev)
+		switch e := ev.(type) {
+		case xproto.UnmapNotifyEvent:
+			return
+
+		case xproto.ConfigureNotifyEvent:
+			w, h := e.Width, e.Height
+
+			scaleX := float64(bounds.Dx()) / float64(w)
+			scaleY := float64(bounds.Dy()) / float64(h)
+
+			if scaleX < scaleY {
+				scale = scaleY
+			} else {
+				scale = scaleX
+			}
+
+			_ = render.SetPictureTransform(X, pixpicid, render.Transform{
+				F64ToFixed(scale), F64ToFixed(0), F64ToFixed(0),
+				F64ToFixed(0), F64ToFixed(scale), F64ToFixed(0),
+				F64ToFixed(0), F64ToFixed(0), F64ToFixed(1),
+			})
+			_ = render.SetPictureFilter(X, pixpicid, 8, "bilinear", nil)
+
+		case xproto.ExposeEvent:
+			_ = render.Composite(X, render.PictOpSrc,
+				pixpicid, render.PictureNone, pid,
+				0, 0, 0, 0, 0 /* dst-x */, 0, /* dst-y */
+				uint16(float64(img.Bounds().Dx())/scale),
+				uint16(float64(img.Bounds().Dy())/scale))
+		}
+	}
+}