aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorPřemysl Janouch <p@janouch.name>2018-08-25 05:51:33 +0200
committerPřemysl Janouch <p@janouch.name>2018-09-02 18:25:37 +0200
commitcea179291352b38bec3dd9ea9fac94fc8024da80 (patch)
tree12ece62ac95c4e3ca14a3aa7f91b7fe0304db16e
parentff7518c74dd5ae14e41910f713ecb194965b3f17 (diff)
downloadhaven-cea179291352b38bec3dd9ea9fac94fc8024da80.tar.gz
haven-cea179291352b38bec3dd9ea9fac94fc8024da80.tar.xz
haven-cea179291352b38bec3dd9ea9fac94fc8024da80.zip
xgb-image: add a demo that shows a scaled picture
-rw-r--r--prototypes/xgb-image.go252
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))
+ }
+ }
+}