mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-11-24 12:46:38 +00:00
cde2fb6244
* initial work replacing our media decoding / encoding pipeline with ffprobe + ffmpeg
* specify the video codec to use when generating static image from emoji
* update go-storage library (fixes incompatibility after updating go-iotools)
* maintain image aspect ratio when generating a thumbnail for it
* update readme to show go-ffmpreg
* fix a bunch of media tests, move filesize checking to callers of media manager for more flexibility
* remove extra debug from error message
* fix up incorrect function signatures
* update PutFile to just use regular file copy, as changes are file is on separate partition
* fix remaining tests, remove some unneeded tests now we're working with ffmpeg/ffprobe
* update more tests, add more code comments
* add utilities to generate processed emoji / media outputs
* fix remaining tests
* add test for opus media file, add license header to utility cmds
* limit the number of concurrently available ffmpeg / ffprobe instances
* reduce number of instances
* further reduce number of instances
* fix envparsing test with configuration variables
* update docs and configuration with new media-{local,remote}-max-size variables
82 lines
1.8 KiB
Go
82 lines
1.8 KiB
Go
package util
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
|
|
"github.com/tetratelabs/wazero/api"
|
|
)
|
|
|
|
// NOTE:
|
|
// the below functions are not very well optimized
|
|
// for repeated calls. this is relying on the fact
|
|
// that the only place they get used (tempnam), is
|
|
// not called very often, should only be once per run
|
|
// so calls to ExportedFunction() and Call() instead
|
|
// of caching api.Function and using CallWithStack()
|
|
// will work out the same (if only called once).
|
|
|
|
// maxaddr is the maximum
|
|
// wasm32 memory address.
|
|
const maxaddr = ^uint32(0)
|
|
|
|
func malloc(ctx context.Context, mod api.Module, sz uint32) uint32 {
|
|
stack, err := mod.ExportedFunction("malloc").Call(ctx, uint64(sz))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
ptr := api.DecodeU32(stack[0])
|
|
if ptr == 0 {
|
|
panic("out of memory")
|
|
}
|
|
return ptr
|
|
}
|
|
|
|
func free(ctx context.Context, mod api.Module, ptr uint32) {
|
|
if ptr != 0 {
|
|
mod.ExportedFunction("free").Call(ctx, uint64(ptr))
|
|
}
|
|
}
|
|
|
|
func view(ctx context.Context, mod api.Module, ptr uint32, n uint32) []byte {
|
|
if n == 0 {
|
|
n = maxaddr - ptr
|
|
}
|
|
mem := mod.Memory()
|
|
b, ok := mem.Read(ptr, n)
|
|
if !ok {
|
|
panic("out of range")
|
|
}
|
|
return b
|
|
}
|
|
|
|
func read(ctx context.Context, mod api.Module, ptr, n uint32) []byte {
|
|
return bytes.Clone(view(ctx, mod, ptr, n))
|
|
}
|
|
|
|
func readString(ctx context.Context, mod api.Module, ptr, n uint32) string {
|
|
return string(view(ctx, mod, ptr, n))
|
|
}
|
|
|
|
func write(ctx context.Context, mod api.Module, b []byte) uint32 {
|
|
mem := mod.Memory()
|
|
len := uint32(len(b))
|
|
ptr := malloc(ctx, mod, len)
|
|
ok := mem.Write(ptr, b)
|
|
if !ok {
|
|
panic("out of range")
|
|
}
|
|
return ptr
|
|
}
|
|
|
|
func writeString(ctx context.Context, mod api.Module, str string) uint32 {
|
|
mem := mod.Memory()
|
|
len := uint32(len(str) + 1)
|
|
ptr := malloc(ctx, mod, len)
|
|
ok := mem.WriteString(ptr, str)
|
|
if !ok {
|
|
panic("out of range")
|
|
}
|
|
return ptr
|
|
}
|