Fd/neo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: add pure-go webp exif riff injector implementation plan

Browse Source
This commit is contained in:
Fd
2026-07-15 17:03:07 +07:00
parent 2d53ae8be1
commit e417a98154
1 changed files with 412 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/superpowers/plans/2026-07-15-pure-go-exiv-plan.md
+412
View File
@@ -0,0 +1,412 @@
# Pure-Go WebP EXIF RIFF Injector Implementation Plan
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Modify `helper/exif.go` and `helper/media_convert.go` to inject EXIF payloads directly into WebP RIFF byte slices entirely in Go memory, replacing `webpmux`.
**Architecture:** We will implement an `InjectExif(webpBytes []byte, packName, publisher string) ([]byte, error)` function inside `helper/exif.go` to handle raw RIFF parsing in place, and strip out the old Temp File logic. Webpmux invocation in `helper/media_convert.go` will be removed.
**Tech Stack:** Go (encoding/binary)
## Global Constraints
- Target files: `helper/exif.go` and `helper/media_convert.go`
- Do not use CGO or any unstated 3rd party package for RIFF handling. Implement manually using `encoding/binary`.
- Format must be `VP8X` with the EXIF flag bit activated.
---
### Task 1: Clean Up media_convert.go
**Files:**
- Modify:`/Users/fd/Documents/perf/helper/media_convert.go`
**Interfaces:**
- Consumes: Nothing
- Produces: `ConvertImageToWebp`, `ConvertVideoToWebp`
- [ ] **Step 1: Simplify Convert methods**
Remove `InjectExif` from `media_convert.go` since it will be rewritten from scratch in `exif.go`.
```go
package helper
import (
"bytes"
"fmt"
"os"
"os/exec"
"path/filepath"
"github.com/google/uuid"
)
func ConvertImageToWebp(imgData []byte) ([]byte, error) {
convertCmd := exec.Command("convert", "-", "-resize", "512x512", "-background", "none", "-compose", "Copy", "-gravity", "center", "-extent", "512x512", "-quality", "100", "png:-")
convertCmd.Stdin = bytes.NewReader(imgData)
var convertBuf bytes.Buffer
convertCmd.Stdout = &convertBuf
if err := convertCmd.Run(); err != nil {
return nil, fmt.Errorf("convert failed: %w", err)
}
cwebpCmd := exec.Command("cwebp", "-quiet", "-mt", "-exact", "-q", "100", "-m", "6", "-alpha_q", "100", "-o", "-", "--", "-")
cwebpCmd.Stdin = &convertBuf
var cwebpBuf bytes.Buffer
cwebpCmd.Stdout = &cwebpBuf
if err := cwebpCmd.Run(); err != nil {
return nil, fmt.Errorf("cwebp failed: %w", err)
}
return cwebpBuf.Bytes(), nil
}
func ConvertVideoToWebp(vidData []byte) ([]byte, error) {
webpPath := filepath.Join("temp", fmt.Sprintf("%s.webp", uuid.New().String()))
defer os.Remove(webpPath)
ffmpegCmd := exec.Command("ffmpeg",
"-y", "-hide_banner", "-loglevel", "error",
"-i", "pipe:0", "-f", "mp4",
"-ss", "00:00:00", "-t", "00:00:15",
"-vf", "fps=10,scale=720:-1:flags=lanczos:force_original_aspect_ratio=increase,crop=512:512,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1",
"-compression_level", "6",
"-q:v", "60", "-loop", "0",
"-preset", "picture", "-an", "-fps_mode", "auto",
"-f", "webp", webpPath,
)
ffmpegCmd.Stdin = bytes.NewReader(vidData)
if err := ffmpegCmd.Run(); err != nil {
return nil, fmt.Errorf("ffmpeg failed: %w", err)
}
return os.ReadFile(webpPath)
}
```
- [ ] **Step 2: Check standard test suite**
Run: `go build ./...`
- [ ] **Step 3: Commit**
```bash
git add helper/media_convert.go
git commit -m "refactor: remove InjectExif shell wrapper from media_convert"
```
### Task 2: Implement Pure-Go RIFF Injector
**Files:**
- Modify:`/Users/fd/Documents/perf/helper/exif.go`
**Interfaces:**
- Produces: `InjectExif(webpData []byte, packName, publisher string) ([]byte, error)`
- Consumes: Nothing
- [ ] **Step 1: Write `helper/exif.go`**
Overwrite `/Users/fd/Documents/perf/helper/exif.go` with the completely new implementation. The previous dynamic `temp/default.exif` file logic is gone.
```go
package helper
import (
"bytes"
"encoding/binary"
"encoding/json"
"fmt"
"math/big"
)
type StickerMetadata struct {
PackId string `json:"sticker-pack-id"`
Name string `json:"sticker-pack-name"`
Publisher string `json:"sticker-pack-publisher"`
Emojis []string `json:"emojis,omitempty"`
}
func writeUIntLE(buffer []byte, value, offset, byteLength int64) {
slice := make([]byte, byteLength)
val := new(big.Int)
val.SetUint64(uint64(value))
valBytes := val.Bytes()
tmp := make([]byte, len(valBytes))
for i := range valBytes {
tmp[i] = valBytes[len(valBytes)-1-i]
}
copy(slice, tmp)
copy(buffer[offset:], slice)
}
func createMetadataBytes(packName, publisher string) []byte {
exifObj := StickerMetadata{
PackId: "com.wa.bot.sticker",
Name: packName,
Publisher: publisher,
Emojis: []string{"😀"},
}
exifJson, err := json.Marshal(exifObj)
if err != nil {
return nil
}
bit := []byte{0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00}
bit = append(bit, exifJson...)
writeUIntLE(bit, int64(len(exifJson)), 14, 4)
return bit
}
// InjectExif takes raw WebP bytes and constructs a new WebP RIFF byte slice containing the EXIF metadata
func InjectExif(webpData []byte, packName, publisher string) ([]byte, error) {
if len(webpData) < 12 || string(webpData[0:4]) != "RIFF" || string(webpData[8:12]) != "WEBP" {
return nil, fmt.Errorf("not a valid WEBP file")
}
var width, height uint32
hasVP8X := false
var vp8xFlags byte
var vp8xBytes []byte
var chunks [][]byte
// Default defaults for VP8X canvas sizes
width = 512
height = 512
offset := 12
for offset < len(webpData) {
if offset+8 > len(webpData) {
break
}
chunkID := string(webpData[offset : offset+4])
chunkSize := binary.LittleEndian.Uint32(webpData[offset+4 : offset+8])
paddedSize := chunkSize
if paddedSize%2 != 0 {
paddedSize++
}
if offset+8+int(paddedSize) > len(webpData) {
break
}
chunkData := webpData[offset+8 : offset+8+int(paddedSize)]
switch chunkID {
case "VP8X":
hasVP8X = true
vp8xFlags = chunkData[0]
vp8xBytes = chunkData
// extract dimensions
wBytes := []byte{chunkData[4], chunkData[5], chunkData[6], 0}
hBytes := []byte{chunkData[7], chunkData[8], chunkData[9], 0}
width = binary.LittleEndian.Uint32(wBytes) + 1
height = binary.LittleEndian.Uint32(hBytes) + 1
case "VP8 ":
if !hasVP8X {
// extract 14 bit scale block
w := uint32(chunkData[6]) | (uint32(chunkData[7]) << 8)
width = w & 0x3FFF
h := uint32(chunkData[8]) | (uint32(chunkData[9]) << 8)
height = h & 0x3FFF
}
chunks = append(chunks, webpData[offset:offset+8+int(paddedSize)])
case "VP8L":
if !hasVP8X {
// Parse bits 1-28 for w/h
b0 := uint32(chunkData[1])
b1 := uint32(chunkData[2])
b2 := uint32(chunkData[3])
b3 := uint32(chunkData[4])
width = 1 + (((b1 & 0x3F) << 8) | b0)
height = 1 + (((b3 & 0xF) << 10) | (b2 << 2) | ((b1 & 0xC0) >> 6))
}
chunks = append(chunks, webpData[offset:offset+8+int(paddedSize)])
default:
if chunkID != "EXIF" {
chunks = append(chunks, webpData[offset:offset+8+int(paddedSize)])
}
}
offset += 8 + int(paddedSize)
}
exifMeta := createMetadataBytes(packName, publisher)
if exifMeta == nil {
return nil, fmt.Errorf("failed to create exif byte payload")
}
// Turn on EXIF flag (bit 3) in VP8X
if !hasVP8X {
vp8xBytes = make([]byte, 10)
vp8xFlags = 0x08 // EXIF flag is bit 3
vp8xBytes[0] = vp8xFlags
w := width - 1
h := height - 1
vp8xBytes[4] = byte(w)
vp8xBytes[5] = byte(w >> 8)
vp8xBytes[6] = byte(w >> 16)
vp8xBytes[7] = byte(h)
vp8xBytes[8] = byte(h >> 8)
vp8xBytes[9] = byte(h >> 16)
} else {
vp8xBytes[0] = vp8xFlags | 0x08
}
var buf bytes.Buffer
buf.WriteString("RIFF")
buf.Write([]byte{0, 0, 0, 0}) // Total size placeholder
buf.WriteString("WEBP")
// Write VP8X
buf.WriteString("VP8X")
vp8xSize := make([]byte, 4)
binary.LittleEndian.PutUint32(vp8xSize, 10)
buf.Write(vp8xSize)
buf.Write(vp8xBytes)
// Write existing chunks
for _, chunk := range chunks {
buf.Write(chunk)
}
// Write EXIF
buf.WriteString("EXIF")
exifSize := uint32(len(exifMeta))
exifSizeSlice := make([]byte, 4)
binary.LittleEndian.PutUint32(exifSizeSlice, exifSize)
buf.Write(exifSizeSlice)
buf.Write(exifMeta)
if exifSize%2 != 0 {
buf.WriteByte(0)
}
result := buf.Bytes()
totalSize := uint32(len(result) - 8)
binary.LittleEndian.PutUint32(result[4:8], totalSize)
return result, nil
}
```
- [ ] **Step 2: Check test suite**
Run: `go build ./...`
- [ ] **Step 3: Commit**
```bash
git add helper/exif.go
git commit -m "feat: implement pure-go RIFF EXIF injector"
```
### Task 3: Update cmds/media/sticker.go Signature
**Files:**
- Modify:`/Users/fd/Documents/perf/cmds/media/sticker.go`
**Interfaces:**
- Consumes: `helper.InjectExif(rawWebp, packName, publisher)`
- [ ] **Step 1: Replace ResolveExif usages in `cmds/media/sticker.go`**
Read `ctx.Arguments()` directly to compute `packName` and `publisher` locally instead of calling `helper.ResolveExif`. Use the same ENV logic as fallback defaults if args are empty. Remove `helper.ResolveExif` code context cleanup.
```go
package media
import (
"context"
"fmt"
"os"
"strings"
hc "neo/context"
"neo/core"
"neo/helper"
)
func init() { core.Default.Register(Sticker) }
var Sticker = &core.Command{
Name: "sticker",
Aliases: []string{"s", "stiker"},
Category: "media",
Description: "Create sticker from image/video or rewrite existing sticker EXIF",
Run: func(ctx *hc.Ctx) {
ctx.React("👌")
args := ctx.Arguments()
packName := os.Getenv("STICKER_NAME")
if packName == "" {
packName = "Bot"
}
publisher := os.Getenv("STICKER_PUBLISHER")
if publisher == "" {
publisher = "Bot"
}
if len(args) > 0 {
argStr := strings.Join(args, " ")
parts := strings.Split(argStr, "|")
packName = strings.TrimSpace(parts[0])
publisher = "Bot"
if len(parts) > 1 {
publisher = strings.TrimSpace(parts[1])
}
}
msg := ctx.Message()
quoted := hc.GetQuotedMessage(msg)
var err error
var rawWebp []byte
var mediaData []byte
if img := msg.GetImageMessage(); img != nil {
mediaData, err = ctx.Client().Download(context.Background(), img)
if err == nil {
rawWebp, err = helper.ConvertImageToWebp(mediaData)
}
} else if img := quoted.GetImageMessage(); img != nil && quoted != nil {
mediaData, err = ctx.Client().Download(context.Background(), img)
if err == nil {
rawWebp, err = helper.ConvertImageToWebp(mediaData)
}
} else if vid := msg.GetVideoMessage(); vid != nil {
mediaData, err = ctx.Client().Download(context.Background(), vid)
if err == nil {
rawWebp, err = helper.ConvertVideoToWebp(mediaData)
}
} else if vid := quoted.GetVideoMessage(); vid != nil && quoted != nil {
mediaData, err = ctx.Client().Download(context.Background(), vid)
if err == nil {
rawWebp, err = helper.ConvertVideoToWebp(mediaData)
}
} else if smsg := quoted.GetStickerMessage(); smsg != nil && quoted != nil {
rawWebp, err = ctx.Client().Download(context.Background(), smsg)
} else {
ctx.Reply("error: reply to image/video/sticker or send with caption")
return
}
if err != nil {
ctx.Reply(fmt.Sprintf("error processing media: %v", err))
return
}
finalSticker, err := helper.InjectExif(rawWebp, packName, publisher)
if err != nil {
ctx.Reply(fmt.Sprintf("error injecting EXIF: %v", err))
return
}
ctx.SendSticker(finalSticker)
},
}
```
- [ ] **Step 2: Verify Compilation**
Run: `go build ./...`
- [ ] **Step 3: Commit**
```bash
git add cmds/media/sticker.go
git commit -m "feat: use pure-go exif injector in sticker command"
```