Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ptp

Source of release 0.1.0

0.1.0 / src / ptp / virtual.lucb

# mark: A virtual camera ======================================================================

## The virtual camera's one storage, and its folders as a camera lays them out:
## DCIM (handle 1) holding 100LUCE (handle 2) holding the files (handles 3 on).
let virtual_storage: u32 = 0x00010001
let dcim_handle: u32 = 1
let roll_handle: u32 = 2
let first_file: u32 = 3

## A camera that answers PTP from the files directly in a folder.
struct Virtual:
    var folder: Buffer
    var names: List[str]
    var sizes: List[u32]
    var pool: TextPool
    var open: bool
    ## Whether it offers GetPartialObject, and whether its data phase comes without
    ## a container header (as ImageCaptureCore hands it over).
    var partial: bool
    var bare_data: bool
    var reply: Buffer
    var path: Buffer

    func close():
        self.folder.destroy()
        self.names.destroy()
        self.sizes.destroy()
        self.pool.destroy()
        self.reply.destroy()
        self.path.destroy()

    ## Answer `operation`: its data into `reply`, its response code returned.
    func answer(operation: u16, parameters: const u32[]) -> u16!:
        if operation == get_device_info:
            try self.put_device_info()
            return ok
        if operation == open_session:
            if self.open:
                return session_already_open
            self.open = true
            return ok
        if not self.open:
            return 0x2003
        if operation == close_session:
            self.open = false
            return ok
        if operation == get_storage_ids:
            try put_u32_array(&self.reply, [virtual_storage])
            return ok
        if operation == get_storage_info:
            if parameters.length < 1 or parameters[0] != virtual_storage:
                return 0x2008
            for value in [4, 2, 0]:
                try put_u16(&self.reply, (u16)value)
            try put_u64(&self.reply, 34359738368)
            try put_u64(&self.reply, 17179869184)
            try put_u32(&self.reply, 0xFFFFFFFF)
            try put_text(&self.reply, "Virtual card")
            try put_text(&self.reply, paths.base(self.folder.text()))
            return ok
        if operation == get_object_handles:
            try put_u32(&self.reply, (u32)(self.names.length() + 2))
            for handle in 1..<(u32)(self.names.length() + 3):
                try put_u32(&self.reply, handle)
            return ok
        let handle = parameters[0] if parameters.length > 0 else 0
        if operation == get_object_info:
            var info = ObjectInfo(storage = virtual_storage, format = association_format)
            if handle == dcim_handle:
                info.name = "DCIM"
            elif handle == roll_handle:
                info.name = "100LUCE"
                info.parent = dcim_handle
            elif let at = self.file_at(handle):
                info.name = self.names.at(at)
                info.format = format_of(info.name)
                info.size = self.sizes.at(at)
                info.parent = roll_handle
                info.captured = "20261013T120000"
                info.modified = "20261013T120000"
            else:
                return 0x2009
            try put_object_info(&self.reply, &info)
            return ok
        if operation == get_object or operation == get_partial_object and self.partial:
            let at = self.file_at(handle) else return 0x2009
            try self.read_file(at, parameters, operation == get_partial_object)
            return ok
        return 0x2005

    ## The position in `names` of file `handle`.
    func file_at(handle: u32) -> usize?:
        if handle < first_file or (usize)(handle - first_file) >= self.names.length():
            return none
        return (usize)(handle - first_file)

    ## Put file `at` into the reply: whole, or (`partial`) the piece the parameters ask for.
    func read_file(at: usize, parameters: const u32[], partial: bool) -> !:
        self.path.clear()
        let joined = try paths.join(self.folder.text(), self.names.at(at))
        defer joined.release()
        try self.path.put_text(joined.value)
        var file = try files.File.open(try self.path.terminated())
        defer file.destroy()
        var offset: u64 = 0
        var wanted = (u64)self.sizes.at(at)
        if partial:
            offset = (u64)parameters[1] if parameters.length > 1 else 0
            let asked = (u64)parameters[2] if parameters.length > 2 else 0
            let left = wanted - offset if offset < wanted else 0
            wanted = asked if asked < left else left
        _ = try file.seek((i64)offset)
        var chunk: u8[65536]
        while wanted > 0:
            let want = (usize)wanted if wanted < (u64)chunk.length else chunk.length
            let got = try file.read(chunk[..<want])
            if got == 0:
                break
            try self.reply.put(chunk[..<got])
            wanted -= (u64)got

    func put_device_info() -> !:
        try put_u16(&self.reply, 100)
        try put_u32(&self.reply, 0)
        try put_u16(&self.reply, 0)
        try put_text(&self.reply, "")
        try put_u16(&self.reply, 0)
        var operations: List[u16]
        defer operations.destroy()
        for code in [get_device_info, open_session, close_session, get_storage_ids, get_storage_info, get_object_handles, get_object_info, get_object]:
            try operations.append(code)
        if self.partial:
            try operations.append(get_partial_object)
        try put_u16_array(&self.reply, operations.view())
        for _at in 0..<3:
            # An empty array: its count alone.
            try put_u32(&self.reply, 0)
        try put_u16_array(&self.reply, [exif_jpeg_format, dng_format])
        try put_text(&self.reply, "Luce")
        try put_text(&self.reply, "Virtual Camera")
        try put_text(&self.reply, "1.0")
        try put_text(&self.reply, "0001")

## A transport to a camera holding the files directly in `folder` (read when the camera
## is made), in a DCIM/100LUCE folder of one card. `partial` offers GetPartialObject;
## `bare_data` sends the data phase without its container header.
pub func virtual_camera(folder: str, partial: bool = true, bare_data: bool = false) -> Transport!:
    let made = try new Virtual(partial = partial, bare_data = bare_data) in memory.heap
    errdefer virtual_close((void*)made)
    try made.folder.put_text(folder)
    let listed = try files.list(try made.folder.terminated())
    defer listed.release()
    for name in listed.value:
        if name.length == 0 or name.bytes[0] == '.':
            continue
        let joined = try paths.join(folder, name)
        defer joined.release()
        let terminated = try strings.copy(joined.value)
        defer strings.release(terminated)
        let stat = try files.metadata((c.str)terminated)
        if stat.kind != files.FileKind.regular:
            continue
        try made.names.append(try made.pool.keep_text(name.bytes))
        try made.sizes.append((u32)stat.size)
    return Transport(context = (void*)made, exchange = virtual_exchange, close = virtual_close, holds_session = false)

func virtual_close(context: void*):
    let made = (Virtual*)context
    made.close()
    free(made) in memory.heap

## The format a camera gives a file of this name.
func format_of(name: str) -> u16:
    let extension = paths.extension(name)
    if extension == ".JPG" or extension == ".jpg" or extension == ".JPEG" or extension == ".jpeg":
        return exif_jpeg_format
    if extension == ".DNG" or extension == ".dng":
        return dng_format
    return undefined_format

func virtual_exchange(context: void*, command: const u8[], data_out: const u8[], data_in: Buffer*, response: Buffer*) -> !:
    let camera = (Virtual*)context
    let header = try read_header(command)
    if header.kind != command_container or (usize)header.length != command.length:
        error(malformed, "the virtual camera was sent something other than a command")
    var reader = Reader(data = command, at = header_size)
    var parameters: u32[5]
    var count: usize = 0
    while reader.at < command.length and count < 5:
        parameters[count] = try reader.read_u32()
        count += 1
    camera.reply.clear()
    let code = try camera.answer(header.code, parameters[..<count])
    if camera.reply.length() > 0:
        if camera.bare_data:
            try data_in.put(camera.reply.view())
        else:
            try put_data(data_in, header.code, header.transaction, camera.reply.view())
    try put_container(response, response_container, code, header.transaction, no_parameters())