Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-photo

Source of release 0.1.1

0.1.1 / src / exporter.lucb

## The exporter: develops photos at full size and writes them out on a thread of
## its own (luce-develop's export), so the window never waits. The window queues
## the photos, then polls events, one line each, fields separated by tabs:
##     exported  done  total  file   a photo is written
##     failed    done  total  file  message
##     done      written  failed     the queue is empty
import interop
import memory
import strings
import sync
import thread
from luce_std.collections import Buffer, List
from luce_std import paths
from luce_develop import export
from luce_ui import ui

struct Job:
    ## NUL-terminated heap copies (strings.copy).
    var source: str
    var settings: str
    var target: str

    func release():
        strings.release(self.source)
        strings.release(self.settings)
        strings.release(self.target)

struct Shared:
    var lock: sync.Mutex
    var wake: sync.Condition
    var jobs: List[Job]
    var events: Buffer
    var format: i64
    var quality: i64
    var edge: i64
    ## luce-develop export's color space: srgb or display_p3.
    var space: i64
    var total: i64
    var done: i64
    var written: i64
    var failed: i64
    var stopping: bool
    ## Who to tell when there is something to take: the window's notifier,
    ## held for this thread (luce-ui's notify_handle), none before `wake_with`.
    var waker: ui.NotifyHandle?

    func post_line(fields: const str[]):
        var line: Buffer
        defer line.destroy()
        for (at, field) in fields.indexed():
            if at > 0:
                line.put_byte('\t') catch failure:
                    return
            for byte in field.bytes:
                line.put_byte(' ' if byte == '\t' or byte == '\n' else byte) catch failure:
                    return
        self.events.put(line.view()) catch failure:
            return
        self.events.put_byte('\n') catch failure:
            return
        if let waker = self.waker:
            waker.notify()

func work(context: void*?):
    let shared = (Shared*)(context else return)
    while true:
        shared.lock.lock()
        while shared.jobs.length() == 0 and not shared.stopping:
            shared.wake.wait(&shared.lock)
        if shared.stopping:
            shared.lock.unlock()
            return
        let job = shared.jobs.at(0)
        shared.jobs.remove(0)
        let format = shared.format
        let quality = shared.quality
        let edge = shared.edge
        let space = shared.space
        shared.lock.unlock()
        var message = ""
        var buffer: u8[256]
        export.export(job.source, job.settings, job.target, format, quality, edge, space) catch failure:
            let length = failure.message.length if failure.message.length < 256 else 256
            memory.copy(buffer[..<length], failure.message.bytes[..<length], length)
            message = (str)buffer[..<length]
        shared.lock.lock()
        shared.done += 1
        var count: u8[24]
        var total: u8[24]
        let done_text = strings.format(count, f"{shared.done}") catch failure:
            recover ""
        let total_text = strings.format(total, f"{shared.total}") catch failure:
            recover ""
        if message == "":
            shared.written += 1
            shared.post_line([(str)"exported", done_text, total_text, paths.base(job.target)])
        else:
            shared.failed += 1
            shared.post_line([(str)"failed", done_text, total_text, paths.base(job.target), message])
        if shared.jobs.length() == 0:
            var written: u8[24]
            var failed: u8[24]
            let written_text = strings.format(written, f"{shared.written}") catch failure:
                recover ""
            let failed_text = strings.format(failed, f"{shared.failed}") catch failure:
                recover ""
            shared.post_line([(str)"done", written_text, failed_text])
        shared.lock.unlock()
        job.release()

pub struct Exporter:
    var shared: Shared*?
    var worker: thread.Handle
    var polled: Buffer

    ## Export with these settings from now on: `format` (luce-develop's export.jpeg
    ## or export.png16), JPEG `quality`, the longer side `edge` (0: full size), and
    ## the color `space` (export.srgb or export.display_p3).
    pub func configure(format: i64, quality: i64, edge: i64, space: i64 = 0):
        let shared = self.shared else return
        shared.lock.lock()
        shared.space = space
        shared.format = format
        shared.quality = quality
        shared.edge = edge
        shared.lock.unlock()

    ## Queue the photo at `source`, developed with `settings`, for `target`.
    pub func add(source: str, settings: str, target: str) -> !:
        let shared = self.shared else return
        let job = Job(source = try strings.copy(source), settings = try strings.copy(settings), target = try strings.copy(target))
        shared.lock.lock()
        if shared.jobs.length() == 0 and shared.done == shared.total:
            shared.done = 0
            shared.total = 0
            shared.written = 0
            shared.failed = 0
        shared.total += 1
        shared.jobs.append(job) catch failure:
            shared.total -= 1
            shared.lock.unlock()
            job.release()
            error(failure.code, failure.message)
        shared.lock.unlock()
        shared.wake.signal()

    ## The events since the last poll, one a line; "" when there are none.
    pub func poll() -> str!:
        self.polled.clear()
        let shared = self.shared else return ""
        shared.lock.lock()
        defer shared.lock.unlock()
        try self.polled.put(shared.events.view())
        shared.events.clear()
        return self.polled.text()

    ## Notify `notifier` whenever something finishes, so the window takes it
    ## on its loop's next turn instead of polling.
    pub func wake_with(notifier: interop.Reference[ui.Notifier]) -> !:
        let shared = self.shared else return
        let handle = try ui.notify_handle(notifier)
        shared.lock.lock()
        if let old = shared.waker:
            old.release()
        shared.waker = handle
        shared.lock.unlock()

    pub func close():
        let shared = self.shared else return
        shared.lock.lock()
        shared.stopping = true
        shared.lock.unlock()
        shared.wake.broadcast()
        self.worker.join() catch failure:
            trap("the export thread could not be joined")
        for job in shared.jobs.view():
            job.release()
        shared.jobs.destroy()
        shared.events.destroy()
        if let waker = shared.waker:
            waker.release()
        free(shared) in memory.heap
        self.shared = none
        self.polled.destroy()

pub let exporter_type: interop.Type[Exporter] = interop.Type[Exporter]("Exporter", Exporter.close, closeable = true, main_thread = true)

## An exporter, its thread started.
pub func start() -> interop.Reference[Exporter]!:
    let shared = try new Shared(format = export.jpeg, quality = 92) in memory.heap
    errdefer free(shared) in memory.heap
    let worker = try thread.spawn(work, (void*)shared, name = "luced-photo export")
    let made = try new Exporter(shared = shared, worker = worker) in memory.heap
    return try interop.Reference[Exporter].adopt(made, exporter_type, memory.heap)