shithub: mycel

Info  •  Files  •  Log  •  Branches

no more superfluous png encoding in between

--- a/browser/browser.go

+++ b/browser/browser.go

@@ -2,7 +2,6 @@

 import (

 	"9fans.net/go/draw"

-	"bytes"

 	"errors"

 	"fmt"

 	"github.com/psilva261/opossum"

@@ -200,19 +199,11 @@

 			return nil, fmt.Errorf("serialize: %w", err)

 		}

 		log.Printf("newImage: xml: %v", xml)

-		buf, err := img.Svg(xml, n.Width(), n.Height())

-		if err == nil {

-			var err error

-			r := bytes.NewReader(buf)

-			i, err = duit.ReadImage(display, r)

-			if err != nil {

-				return nil, fmt.Errorf("read image %v: %v", xml, err)

-			}

-

-			goto img_elem

-		} else {

+		i, err = img.Svg(dui, xml, n.Width(), n.Height())

+		if err != nil {

 			return nil, fmt.Errorf("img svg %v: %v", xml, err)

 		}

+		goto img_elem

 	} else if n.Data() == "img" {

 		_, s := srcSet(n)

 		if s != "" {

@@ -228,16 +219,10 @@

 		mw, _ := n.CssPx("max-width")

 		w := n.Width()

 		h := n.Height()

-		r, err := img.Load(browser, src, mw, w, h)

+		i, err = img.Load(dui, browser, src, mw, w, h)

 		if err != nil {

-			return nil, fmt.Errorf("load draw image: %w", err)

+			return nil, fmt.Errorf("load image: %w", err)

 		}

-		log.Printf("Read %v...", src)

-		i, err = duit.ReadImage(display, r)

-		if err != nil {

-			return nil, fmt.Errorf("duit read image: %w", err)

-		}

-		log.Printf("Done reading %v", src)

 		imageCache[src] = i

 	}

--- a/img/img.go

+++ b/img/img.go

@@ -1,17 +1,18 @@

 package img

 import (

+	"9fans.net/go/draw"

 	"bytes"

 	"encoding/base64"

 	"fmt"

+	"github.com/mjl-/duit"

 	"github.com/psilva261/opossum"

 	"github.com/psilva261/opossum/logger"

 	"github.com/srwiley/oksvg"

 	"github.com/srwiley/rasterx"

-	"golang.org/x/image/draw"

+	xdraw "golang.org/x/image/draw"

 	"image"

-	"image/png"

-	"io"

+	imagedraw "image/draw"

 	"net/url"

 	"strings"

@@ -151,7 +152,23 @@

 // Svg returns the svg+xml encoded as jpg with the sizing defined in

 // viewbox unless w and h != 0

-func Svg(data string, w, h int) (bs []byte, err error) {

+func Svg(dui *duit.DUI, data string, w, h int) (ni *draw.Image, err error) {

+	rgba, err := svg(data, w, h)

+	if err != nil {

+		return nil, err

+	}

+	ni, err = dui.Display.AllocImage(rgba.Bounds(), draw.ABGR32, false, draw.White)

+	if err != nil {

+		return nil, fmt.Errorf("allocimage: %s", err)

+	}

+	_, err = ni.Load(rgba.Bounds(), rgba.Pix)

+	if err != nil {

+		return nil, fmt.Errorf("load image: %s", err)

+	}

+	return

+}

+

+func svg(data string, w, h int) (img *image.RGBA, err error) {

 	data = strings.ReplaceAll(data, "currentColor", "black")

 	data = strings.ReplaceAll(data, "inherit", "black")

 	data = quoteAttrs(data)

@@ -171,16 +188,40 @@

 	rgba := image.NewRGBA(image.Rect(0, 0, w, h))

 	icon.Draw(rasterx.NewDasher(w, h, rasterx.NewScannerGV(w, h, rgba, rgba.Bounds())), 1)

-	buf := bytes.NewBufferString("")

-	if err = png.Encode(buf, rgba); err != nil {

-		return nil, fmt.Errorf("encode: %w", err)

+	return rgba, nil

+}

+

+// Load and resize to w and h if != 0

+//

+// Stolen from duit.ReadImage

+func Load(dui *duit.DUI, f opossum.Fetcher, src string, maxW, w, h int) (ni *draw.Image, err error) {

+	drawImg, err := load(f, src, maxW, w, h)

+	if err != nil {

+		return nil, err

 	}

+	var rgba *image.RGBA

+	switch i := drawImg.(type) {

+	case *image.RGBA:

+		rgba = i

+	default:

+		b := drawImg.Bounds()

+		rgba = image.NewRGBA(image.Rectangle{image.ZP, b.Size()})

+		imagedraw.Draw(rgba, rgba.Bounds(), drawImg, b.Min, imagedraw.Src)

+	}

-	return buf.Bytes(), nil

+	// todo: package image claims data is in r,g,b,a.  who is reversing the bytes? devdraw? will this work on big endian?

+	ni, err = dui.Display.AllocImage(rgba.Bounds(), draw.ABGR32, false, draw.White)

+	if err != nil {

+		return nil, fmt.Errorf("allocimage: %s", err)

+	}

+	_, err = ni.Load(rgba.Bounds(), rgba.Pix)

+	if err != nil {

+		return nil, fmt.Errorf("load image: %s", err)

+	}

+	return

 }

-// Load and resize to w and h if != 0

-func Load(f opossum.Fetcher, src string, maxW, w, h int) (r io.Reader, err error) {

+func load(f opossum.Fetcher, src string, maxW, w, h int) (img image.Image, err error) {

 	var imgUrl *url.URL

 	var data []byte

 	var contentType opossum.ContentType

@@ -199,41 +240,38 @@

 	}

 	if contentType.IsSvg() {

-		data, err = Svg(string(data), w, h)

+		img, err := svg(string(data), w, h)

 		if err != nil {

 			return nil, fmt.Errorf("svg: %v", err)

 		}

-	} else if maxW != 0 || w != 0 || h != 0 {

-		img, _, err := image.Decode(bytes.NewReader(data))

+		return img, nil

+	} else {

+		img, _, err = image.Decode(bytes.NewReader(data))

 		if err != nil {

 			return nil, fmt.Errorf("decode %v: %w", imgUrl, err)

 		}

+		if maxW != 0 || w != 0 || h != 0 {

+			dx := img.Bounds().Max.X

+			dy := img.Bounds().Max.Y

+			log.Printf("dx,dy=%v,%v", dx, dy)

+			if w == 0 && h == 0 && 0 < maxW && maxW < dx {

+				w = maxW

+			}

-		dx := img.Bounds().Max.X

-		dy := img.Bounds().Max.Y

-		log.Printf("dx,dy=%v,%v", dx, dy)

-		if w == 0 && h == 0 && 0 < maxW && maxW < dx {

-			w = maxW

-		}

+			newX, newY, skip := newSizes(dx, dy, w, h)

-		newX, newY, skip := newSizes(dx, dy, w, h)

-

-		if !skip {

-			log.Printf("resize image to %v x %v", newX, newY)

-			dst := image.NewRGBA(image.Rect(0, 0, newX, newY))

-			draw.NearestNeighbor.Scale(dst, dst.Rect, img, img.Bounds(), draw.Over, nil)

-			buf := bytes.NewBufferString("")

-

-			if err = png.Encode(buf, dst); err != nil {

-				return nil, fmt.Errorf("encode: %w", err)

+			if !skip {

+				log.Printf("resize image to %v x %v", newX, newY)

+				dst := image.NewRGBA(image.Rect(0, 0, newX, newY))

+				xdraw.NearestNeighbor.Scale(dst, dst.Rect, img, img.Bounds(), xdraw.Over, nil)

+				img = dst

+			} else {

+				log.Printf("skip resizing")

 			}

-			data = buf.Bytes()

-		} else {

-			log.Printf("skip resizing")

 		}

 	}

-	return bytes.NewReader(data), nil

+	return img, nil

 }

 func newSizes(oldX, oldY, wantedX, wantedY int) (newX, newY int, skip bool) {

--- a/img/img_test.go

+++ b/img/img_test.go

@@ -46,7 +46,7 @@

                </svg>

        `

-	_, err := Svg(xml, 0, 0)

+	_, err := svg(xml, 0, 0)

 	if err != nil {

 		t.Fatalf(err.Error())

 	}

@@ -61,7 +61,7 @@

        `

 	xml = `<svg xmlns=http://www.w3.org/2000/svg viewBox=0 0 37 37 fill=#000000><path class=border fill=blue stroke=green/></svg>`

-	_, err := Svg(xml, 0, 0)

+	_, err := svg(xml, 0, 0)

 	if err != nil {

 		t.Fatalf(err.Error())

 	}

@@ -110,13 +110,9 @@

 			t.Fail()

 		}

 		b := &MockBrowser{buf.Bytes()}

-		r, err := Load(b, "", mw, w, h)

+		img, err := load(b, "", mw, w, h)

 		if err != nil {

 			t.Errorf("load: %v", err)

-		}

-		img, _, err := image.Decode(r)

-		if err != nil {

-			t.Errorf("decode")

 		}

 		dx := img.Bounds().Max.X

 		dy := img.Bounds().Max.Y

--- a/style/experimental.go

+++ b/style/experimental.go

@@ -3,7 +3,6 @@

 import (

 	"9fans.net/go/draw"

 	"fmt"

-	"github.com/mjl-/duit"

 	"github.com/psilva261/opossum"

 	"github.com/psilva261/opossum/img"

 	"github.com/psilva261/opossum/logger"

@@ -194,18 +193,12 @@

 		w := cs.Width()

 		h := cs.Height()

-		r, err := img.Load(fetcher, imgUrl, 0, w, h)

+		var err error

+		i, err = img.Load(dui, fetcher, imgUrl, 0, w, h)

 		if err != nil {

 			log.Errorf("bg img load %v: %v", imgUrl, err)

-			return nil

-		}

-

-		i, err = duit.ReadImage(dui.Display, r)

-		if err != nil {

-			log.Errorf("bg read image %v: %v", imgUrl, err)

 			return

 		}

-		return i

 	}

 	return

 }