1 files changed, 117 insertions, 0 deletions

diff --git a/image/webp/client.go b/image/webp/client.go
new file mode 100644
index 0000000..6b08b72
--- /dev/null
+++ b/image/webp/client.go
@@ -0,0 +1,117 @@
+package webp
+
+import (
+        "bytes"
+        "context"
+        "fmt"
+        "image"
+        "io"
+        "net"
+        "net/http"
+        "os"
+        "os/exec"
+        "path"
+        "strconv"
+        "syscall"
+
+        "golang.org/x/image/tiff"
+)
+
+// WebPConvertClient starts a webp conversion server and manages
+// its lifecycle. Call Convert to convert an image.Image to a webp
+// bytestream. This struct is only threadsafe after Start has been
+// called.
+type WebPConvertClient struct {
+        p *exec.Cmd
+        c *http.Client
+}
+
+// Start starts the server, cancelling the passed context will stop
+// the server process. It is important to pass a real context into the
+// process and not just context.Background. This function will return an
+// error if setup fails but does not block.
+func (c *WebPConvertClient) Start(ctx context.Context) error {
+        sockDir, err := os.MkdirTemp("", "webp-*")
+        if err != nil {
+                return err
+        }
+
+        sockPath := path.Join(sockDir, "webp.sock")
+
+        c.c = &http.Client{
+                Transport: &http.Transport{
+                        DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
+                                var d net.Dialer
+                                return d.DialContext(ctx, "unix", sockPath)
+                        },
+                },
+        }
+
+        c.p = exec.CommandContext(ctx, "webp-convert-server", sockPath)
+        if c.p.Err != nil {
+                return c.p.Err
+        }
+
+        c.p.Cancel = func() error {
+                if err := c.p.Process.Signal(syscall.SIGTERM); err != nil {
+                        return err
+                }
+                return os.ErrProcessDone
+        }
+
+        ec := make(chan error, 1)
+        go func() {
+                ec <- c.p.Run()
+                os.RemoveAll(sockDir)
+        }()
+
+        select {
+        case err = <-ec:
+                return err
+        default:
+                return nil
+        }
+}
+
+// Convert encodes an image as TIFF and sends it to the conversion
+// server. It returns either an error or the webp encoded bytes from the
+// input image.
+func (c *WebPConvertClient) Convert(ctx context.Context, img image.Image, quality int, lossless, exact bool) ([]byte, error) {
+        if c.c == nil {
+                return nil, fmt.Errorf("WebPConvertClient has not been started")
+        }
+
+        bb := &bytes.Buffer{}
+        if err := tiff.Encode(bb, img, &tiff.Options{Compression: tiff.Uncompressed}); err != nil {
+                return nil, err
+        }
+
+        req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://unix/", bb)
+        if err != nil {
+                return nil, err
+        }
+        req.Header.Add("quality", strconv.Itoa(quality))
+        req.Header.Add("lossless", fmt.Sprintf("%t", lossless))
+        req.Header.Add("exact", fmt.Sprintf("%t", exact))
+
+        res, err := c.c.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer res.Body.Close()
+
+        if res.StatusCode != 200 {
+                e, err := io.ReadAll(res.Body)
+                if err != nil {
+                        return nil, err
+                }
+                return nil, fmt.Errorf("WebPConvertClient server error: %s", e)
+        }
+
+        bb.Reset()
+        if _, err := io.Copy(bb, res.Body); err != nil {
+                return nil, err
+        }
+
+        return bb.Bytes(), nil
+}