itten/go-mxl-pattern-generator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

makefile fix

Browse Source
This commit is contained in:
Dmitry Sergeev
2026-09-13 17:35:16 +03:00
parent c3d0c2edc0
commit 156bd4ba8e
3 changed files with 7 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/generator/opencl.go
-302
View File
@@ -1,302 +0,0 @@
// OpenCL pattern gen
package generator
/*
#cgo linux LDFLAGS: -lOpenCL
#cgo windows LDFLAGS: -lOpenCL
#include <CL/cl.h>
#include <stdlib.h>
static cl_program build_cl_program(cl_context ctx, cl_device_id dev, const char* src, cl_int* err) {
cl_program prog = clCreateProgramWithSource(ctx, 1, &src, NULL, err);
if (*err != CL_SUCCESS) return NULL;
*err = clBuildProgram(prog, 1, &dev, NULL, NULL, NULL);
return prog;
}
static const char* get_build_log(cl_program prog, cl_device_id dev) {
static char buf[4096];
size_t n = 0;
if (clGetProgramBuildInfo(prog, dev, CL_PROGRAM_BUILD_LOG, sizeof(buf) - 1, buf, &n) != CL_SUCCESS) return "";
buf[n < sizeof(buf) - 1 ? n : sizeof(buf) - 1] = '\0';
return buf;
}
*/
import "C"
import (
"fmt"
"os"
"unsafe"
)
type OpenCLGenerator struct {
ctx C.cl_context
queue C.cl_command_queue
kernel C.cl_kernel
prog C.cl_program
dev C.cl_device_id
atlasBuf C.cl_mem
textBuf C.cl_mem
width int
height int
}
// TextConfig describes a burn-in text overlay rendered by the kernel
// with the baked 8x16 bitmap font. FG/BG are 10-bit {Y, Cb, Cr}.
type TextConfig struct {
Str string
X, Y int
Scale int
FG [3]uint32
BG [3]uint32
Boxed bool
}
func (g *OpenCLGenerator) setArg(idx int, size C.size_t, p unsafe.Pointer) error {
if err := C.clSetKernelArg(g.kernel, C.cl_uint(idx), size, p); err != C.CL_SUCCESS {
return fmt.Errorf("opencl: set arg %d failed: %d", idx, err)
}
return nil
}
// setTextArgs pushes the overlay arguments (kernel args 5..16) to the kernel.
// buf is the text byte buffer; a placeholder is allowed when len(cfg.Str) == 0,
// because the kernel checks text_len before dereferencing the text pointer.
func (g *OpenCLGenerator) setTextArgs(buf C.cl_mem, cfg TextConfig) error {
textLen := C.int(len(cfg.Str))
tx, ty := C.int(cfg.X), C.int(cfg.Y)
scale := C.int(cfg.Scale)
if scale < 1 {
scale = 1
}
hasBG := C.int(0)
if cfg.Boxed {
hasBG = 1
}
fgY, fgCb, fgCr := C.cl_uint(cfg.FG[0]), C.cl_uint(cfg.FG[1]), C.cl_uint(cfg.FG[2])
bgY, bgCb, bgCr := C.cl_uint(cfg.BG[0]), C.cl_uint(cfg.BG[1]), C.cl_uint(cfg.BG[2])
args := []struct {
idx int
p unsafe.Pointer
sz C.size_t
}{
{5, unsafe.Pointer(&buf), C.sizeof_cl_mem},
{6, unsafe.Pointer(&textLen), C.sizeof_int},
{7, unsafe.Pointer(&tx), C.sizeof_int},
{8, unsafe.Pointer(&ty), C.sizeof_int},
{9, unsafe.Pointer(&scale), C.sizeof_int},
{10, unsafe.Pointer(&hasBG), C.sizeof_int},
{11, unsafe.Pointer(&fgY), C.sizeof_cl_uint},
{12, unsafe.Pointer(&fgCb), C.sizeof_cl_uint},
{13, unsafe.Pointer(&fgCr), C.sizeof_cl_uint},
{14, unsafe.Pointer(&bgY), C.sizeof_cl_uint},
{15, unsafe.Pointer(&bgCb), C.sizeof_cl_uint},
{16, unsafe.Pointer(&bgCr), C.sizeof_cl_uint},
}
for _, a := range args {
if err := g.setArg(a.idx, a.sz, a.p); err != nil {
return err
}
}
return nil
}
// SetText installs (or, with an empty string, removes) the burn-in overlay.
func (g *OpenCLGenerator) SetText(cfg TextConfig) error {
if len(cfg.Str) > 0 && (cfg.Scale < 1 || cfg.Scale > 8) {
return fmt.Errorf("opencl: text scale must be 1..8, got %d", cfg.Scale)
}
if len(cfg.Str) > 1024 {
return fmt.Errorf("opencl: text too long: %d bytes", len(cfg.Str))
}
var err C.cl_int
buf := g.atlasBuf // placeholder: text_len = 0 keeps the kernel off it
if len(cfg.Str) > 0 {
cData := C.CBytes([]byte(cfg.Str))
defer C.free(cData)
buf = C.clCreateBuffer(g.ctx, C.CL_MEM_READ_ONLY|C.CL_MEM_COPY_HOST_PTR,
C.size_t(len(cfg.Str)), cData, &err)
if err != C.CL_SUCCESS {
return fmt.Errorf("opencl: text buffer upload failed: %d", err)
}
}
if err := g.setTextArgs(buf, cfg); err != nil {
if len(cfg.Str) > 0 {
C.clReleaseMemObject(buf)
}
return err
}
if g.textBuf != nil && g.textBuf != buf {
C.clReleaseMemObject(g.textBuf)
}
if len(cfg.Str) > 0 {
g.textBuf = buf
} else {
g.textBuf = nil
}
return nil
}
func NewOpenCLGenerator(width, height uint, kernelPath string) (*OpenCLGenerator, error) {
var err C.cl_int
var platform C.cl_platform_id
if err = C.clGetPlatformIDs(1, &platform, nil); err != C.CL_SUCCESS {
return nil, fmt.Errorf("opencl: platform not found: %d", err)
}
g := &OpenCLGenerator{width: int(width), height: int(height)}
if err = C.clGetDeviceIDs(platform, C.CL_DEVICE_TYPE_GPU, 1, &g.dev, nil); err != C.CL_SUCCESS {
return nil, fmt.Errorf("opencl: no suitable gpu device found")
}
g.ctx = C.clCreateContext(nil, 1, &g.dev, nil, nil, &err)
if err != C.CL_SUCCESS {
return nil, fmt.Errorf("opencl: ctx creation error")
}
g.queue = C.clCreateCommandQueueWithProperties(g.ctx, g.dev, nil, &err)
if err != C.CL_SUCCESS {
g.queue = C.clCreateCommandQueue(g.ctx, g.dev, 0, &err)
}
src, errGo := os.ReadFile(kernelPath)
if errGo != nil {
g.Close()
return nil, fmt.Errorf("opencl: read kernel error: %w", errGo)
}
cSrc := C.CString(string(src))
defer C.free(unsafe.Pointer(cSrc))
g.prog = C.build_cl_program(g.ctx, g.dev, cSrc, &err)
if err != C.CL_SUCCESS {
msg := "clCreateProgramWithSource failed"
if g.prog != nil {
msg = C.GoString(C.get_build_log(g.prog, g.dev))
}
g.Close()
return nil, fmt.Errorf("opencl: compilation failed: %s", msg)
}
cKName := C.CString("generate_v210_pattern")
defer C.free(unsafe.Pointer(cKName))
g.kernel = C.clCreateKernel(g.prog, cKName, &err)
if err != C.CL_SUCCESS {
g.Close()
return nil, fmt.Errorf("opencl: kernel init failed")
}
g.atlasBuf = C.clCreateBuffer(g.ctx, C.CL_MEM_READ_ONLY|C.CL_MEM_COPY_HOST_PTR,
C.size_t(len(fontAtlas8x16)), unsafe.Pointer(&fontAtlas8x16[0]), &err)
if err != C.CL_SUCCESS {
g.Close()
return nil, fmt.Errorf("opencl: font atlas upload failed: %d", err)
}
if err := g.setArg(4, C.sizeof_cl_mem, unsafe.Pointer(&g.atlasBuf)); err != nil {
g.Close()
return nil, err
}
// Overlay defaults: no text, white on black if SetText is ever called.
if err := g.setTextArgs(g.atlasBuf, TextConfig{
Scale: 1,
FG: [3]uint32{940, 512, 512},
BG: [3]uint32{64, 512, 512},
}); err != nil {
g.Close()
return nil, err
}
return g, nil
}
func (g *OpenCLGenerator) GenerateFrame(dest []byte, frameIndex int) error {
var err C.cl_int
byteSize := C.size_t(len(dest))
// ВАЖНО: Мы маппим память MXL SDK ([]byte) напрямую в OpenCL буфер.
// GPU запишет данные прямо в общую память MXL без лишнего копирования (Zero-Copy).
if want := (g.width * g.height / 6) * 16; len(dest) < want {
return fmt.Errorf("opencl: dest too small: %d bytes, need %d", len(dest), want)
}
clMem := C.clCreateBuffer(
g.ctx,
C.CL_MEM_WRITE_ONLY|C.CL_MEM_USE_HOST_PTR,
byteSize,
unsafe.Pointer(&dest[0]),
&err,
)
if err != C.CL_SUCCESS {
return fmt.Errorf("opencl: mxl host pointer mapping failed: %d", err)
}
defer C.clReleaseMemObject(clMem)
if err := g.setArg(0, C.sizeof_cl_mem, unsafe.Pointer(&clMem)); err != nil {
return err
}
w, h, f := C.int(g.width), C.int(g.height), C.int(frameIndex)
if err := g.setArg(1, C.sizeof_int, unsafe.Pointer(&w)); err != nil {
return err
}
if err := g.setArg(2, C.sizeof_int, unsafe.Pointer(&h)); err != nil {
return err
}
if err := g.setArg(3, C.sizeof_int, unsafe.Pointer(&f)); err != nil {
return err
}
// Каждый поток GPU пакует блок из 6 пикселей (16 байт)
globalWorkSize := C.size_t((g.width * g.height) / 6)
err = C.clEnqueueNDRangeKernel(g.queue, g.kernel, 1, nil, &globalWorkSize, nil, 0, nil, nil)
if err != C.CL_SUCCESS {
return fmt.Errorf("opencl: dispatch failed: %d", err)
}
// Гарантированная синхронизация записи GPU в host-память: map/unmap.
// На discrete GPU драйвер держит копию в device memory; одного clFinish
// недостаточно — данные обязаны появиться в host_ptr только после unmap.
mapped := C.clEnqueueMapBuffer(g.queue, clMem, C.CL_TRUE, C.CL_MAP_READ, 0, byteSize, 0, nil, nil, &err)
if err != C.CL_SUCCESS {
return fmt.Errorf("opencl: map failed: %d", err)
}
if err = C.clEnqueueUnmapMemObject(g.queue, clMem, mapped, 0, nil, nil); err != C.CL_SUCCESS {
return fmt.Errorf("opencl: unmap failed: %d", err)
}
if err = C.clFinish(g.queue); err != C.CL_SUCCESS {
return fmt.Errorf("opencl: finish failed: %d", err)
}
return nil
}
func (g *OpenCLGenerator) Close() error {
if g.textBuf != nil {
C.clReleaseMemObject(g.textBuf)
g.textBuf = nil
}
if g.atlasBuf != nil {
C.clReleaseMemObject(g.atlasBuf)
g.atlasBuf = nil
}
if g.kernel != nil {
C.clReleaseKernel(g.kernel)
g.kernel = nil
}
if g.prog != nil {
C.clReleaseProgram(g.prog)
g.prog = nil
}
if g.queue != nil {
C.clReleaseCommandQueue(g.queue)
g.queue = nil
}
if g.ctx != nil {
C.clReleaseContext(g.ctx)
g.ctx = nil
}
return nil
}