@deepblend/dsh-blender-provider-local 0.2.20 → 0.3.0

package/python/deepblend_avif_headers.py

@@ -0,0 +1,222 @@
+"""AVIF item locations and AV1 size metadata, without decoding pixel payloads."""
+from deepblend_image_headers import MAX_IMAGE_PARTS, dimensions
+
+
+class Fields:
+    def __init__(self, reader, start, end):
+        self.reader, self.pos, self.end = reader, start, end
+
+    def take(self, count):
+        if count < 0 or self.pos + count > self.end:
+            raise ValueError('image item fields escape their box')
+        value = self.reader.read(self.pos, count)
+        self.pos += count
+        return value
+
+    def number(self, count):
+        return int.from_bytes(self.take(count), 'big')
+
+    def done(self):
+        if self.pos != self.end:
+            raise ValueError('invalid image item field length')
+
+
+def locations(reader, start, end):
+    fields = Fields(reader, start, end)
+    header = fields.take(4)
+    version = header[0]
+    if version not in (0, 1, 2) or any(header[1:]):
+        raise ValueError('unsupported image location version')
+    sizes = fields.take(2)
+    offset_size, length_size = sizes[0] >> 4, sizes[0] & 15
+    base_size, index_size = sizes[1] >> 4, sizes[1] & 15
+    if any(size > 8 for size in (offset_size, length_size, base_size, index_size)):
+        raise ValueError('invalid image location field width')
+    count = fields.number(2 if version < 2 else 4)
+    if count > MAX_IMAGE_PARTS:
+        raise ValueError('too many image item locations')
+    items = {}
+    for _ in range(count):
+        item = fields.number(2 if version < 2 else 4)
+        method = fields.number(2) if version else 0
+        reference, base, number = fields.number(2), fields.number(base_size), fields.number(2)
+        if item in items or method not in (0, 1) or reference or number > MAX_IMAGE_PARTS:
+            raise ValueError('unsupported or duplicate image item location')
+        extents = []
+        for _ in range(number):
+            if version and index_size:
+                fields.number(index_size)
+            offset, length = fields.number(offset_size), fields.number(length_size)
+            extents.append((base + offset, length))
+        items[item] = (method, extents)
+    fields.done()
+    return items
+
+
+def item_info(reader, start, end, boxes):
+    fields = Fields(reader, start, end)
+    header = fields.take(4)
+    if header[0] not in (0, 1) or any(header[1:]):
+        raise ValueError('unsupported image item information version')
+    count = fields.number(2 if header[0] == 0 else 4)
+    if count > MAX_IMAGE_PARTS:
+        raise ValueError('too many image item definitions')
+    items = {}
+    for kind, pos, stop in boxes(reader, fields.pos, end):
+        if kind != b'infe':
+            raise ValueError('invalid image item definition')
+        entry = Fields(reader, pos, stop)
+        version = entry.take(4)[0]
+        if version not in (2, 3):
+            raise ValueError('unsupported image item definition version')
+        item, protection = entry.number(2 if version == 2 else 4), entry.number(2)
+        if item in items or protection:
+            raise ValueError('protected or duplicate image item')
+        items[item] = entry.take(4)
+    if len(items) != count:
+        raise ValueError('image item count differs from its definitions')
+    return items
+
+
+class ItemReader:
+    def __init__(self, reader, location, idat):
+        self.reader, self.extents = reader, []
+        method, extents = location
+        if method == 1 and idat is None:
+            raise ValueError('image item requires an inline data box')
+        base, limit = idat if method == 1 else (0, reader.size)
+        for offset, length in extents:
+            if offset < 0 or length <= 0 or base + offset + length > limit:
+                raise ValueError('image item payload escapes its data bounds')
+            self.extents.append((base + offset, length))
+        self.size = sum(length for offset, length in self.extents)
+
+    def read(self, offset, count):
+        if offset < 0 or count < 0 or offset + count > self.size:
+            raise ValueError('truncated coded image metadata')
+        chunks = []
+        for start, length in self.extents:
+            if offset >= length:
+                offset -= length
+                continue
+            number = min(count, length - offset)
+            chunks.append(self.reader.read(start + offset, number))
+            count -= number
+            if count == 0:
+                break
+            offset = 0
+        return b''.join(chunks)
+
+
+class Bits:
+    def __init__(self, data):
+        self.data, self.pos = data, 0
+
+    def take(self, count):
+        if self.pos + count > len(self.data) * 8:
+            raise ValueError('truncated AV1 sequence header')
+        value = 0
+        for _ in range(count):
+            value = (value << 1) | ((self.data[self.pos // 8] >> (7 - self.pos % 8)) & 1)
+            self.pos += 1
+        return value
+
+    def uvlc(self):
+        for count in range(32):
+            if self.take(1):
+                self.take(count)
+                return
+        # AV1's saturated value is encoded by 32 leading zero bits.
+
+
+def sequence_size(data):
+    """Read AV1 sequence maxima; they bound even a smaller selected layer."""
+    bits = Bits(data)
+    profile, still, reduced = bits.take(3), bits.take(1), bits.take(1)
+    if profile > 2 or (reduced and not still):
+        raise ValueError('invalid AV1 sequence profile')
+    if reduced:
+        bits.take(5)
+    else:
+        decoder, delay_bits = False, 0
+        if bits.take(1):
+            bits.take(64)
+            if bits.take(1):
+                bits.uvlc()
+            decoder = bool(bits.take(1))
+            if decoder:
+                delay_bits = bits.take(5) + 1
+                bits.take(42)
+        display = bits.take(1)
+        for _ in range(bits.take(5) + 1):
+            bits.take(12)
+            if bits.take(5) > 7:
+                bits.take(1)
+            if decoder and bits.take(1):
+                bits.take(2 * delay_bits + 1)
+            if display and bits.take(1):
+                bits.take(4)
+    width_bits, height_bits = bits.take(4) + 1, bits.take(4) + 1
+    width, height = bits.take(width_bits) + 1, bits.take(height_bits) + 1
+    dimensions(width, height)
+    return width, height
+
+
+def coded_size(item):
+    offset, sizes = 0, []
+    for _ in range(MAX_IMAGE_PARTS):
+        if offset == item.size:
+            if not sizes:
+                raise ValueError('AV1 image requires a coded sequence header')
+            return max(w for w, h in sizes), max(h for w, h in sizes)
+        header = item.read(offset, 1)[0]
+        offset += 1
+        if header & 0x81:
+            raise ValueError('invalid AV1 OBU header')
+        kind = (header >> 3) & 15
+        if header & 4:
+            if item.read(offset, 1)[0] & 7:
+                raise ValueError('invalid AV1 OBU extension')
+            offset += 1
+        length = item.size - offset
+        if header & 2:
+            length = 0
+            for index in range(8):
+                value = item.read(offset, 1)[0]
+                offset += 1
+                length |= (value & 127) << (index * 7)
+                if not value & 128:
+                    break
+            else:
+                raise ValueError('invalid AV1 OBU length')
+        if offset + length > item.size:
+            raise ValueError('AV1 OBU escapes its image item')
+        if kind == 1:
+            # Only this metadata OBU is read; encoded frames and tiles are sought past.
+            sizes.append(sequence_size(item.read(offset, length)))
+        offset += length
+    raise ValueError('AV1 image exceeds its metadata OBU limit')
+
+
+def decoded_item_size(reader, item, item_type, location, idat, extent, dependencies):
+    if location is None:
+        raise ValueError('decoded image item has no payload location')
+    source = ItemReader(reader, location, idat)
+    if item_type == b'av01':
+        width, height = coded_size(source)
+    elif item_type == b'grid':
+        header = source.read(0, 4)
+        if header[0] or header[1] & ~1 or not dependencies:
+            raise ValueError('invalid AVIF grid image')
+        size = 4 if header[1] & 1 else 2
+        data = source.read(4, size * 2)
+        width, height = int.from_bytes(data[:size], 'big'), int.from_bytes(data[size:], 'big')
+        if (header[2] + 1) * (header[3] + 1) != len(dependencies):
+            raise ValueError('AVIF grid tile count differs from its dependencies')
+    elif item_type == b'iden' and len(dependencies) == 1:
+        width, height = extent
+    else:
+        raise ValueError('unsupported decoded AVIF image item type')
+    # Container properties may describe a selected layer rather than sequence maxima.
+    dimensions(*extent)
+    return dimensions(max(width, extent[0]), max(height, extent[1]))

package/python/deepblend_bridge.py

@@ -30,6 +30,7 @@ Owner: DeepBlend Studio — SPEC §20 M6
 
 import json
 import os
+import queue
 import socket
 import sys
 import threading
@@ -132,6 +133,9 @@ class _Bridge:
         self.last_action = None
         self.last_error = None
         self.connected = False
+        self.pending = queue.Queue()
+        self.connection = None
+        self.timer = self._pump
 
     # -- lifecycle ---------------------------------------------------------
 
@@ -164,6 +168,29 @@ class _Bridge:
         self.server.listen(4)
         self.thread = threading.Thread(target=self._serve, name="deepblend-bridge", daemon=True)
         self.thread.start()
+        if not bpy.app.background:
+            bpy.app.timers.register(self.timer, first_interval=0.01, persistent=True)
+
+    def _dispatch_pending(self, timeout=0):
+        """Run Blender API calls on the main thread; the socket thread only does I/O."""
+        try:
+            job = self.pending.get(timeout=timeout)
+        except queue.Empty:
+            return
+        try:
+            job["answer"] = bootstrap._session_dispatch(job["request"], self.options)
+        except Exception as exc:
+            job["answer"] = bootstrap.build_envelope(None, None, None, {
+                "code": "BLENDER_SCRIPT_ERROR", "message": bootstrap.error_text(exc),
+            }, [], [])
+        finally:
+            job["done"].set()
+
+    def _pump(self):
+        if self.server is None:
+            return None
+        self._dispatch_pending()
+        return 0.01
 
     @staticmethod
     def derive_workspace(open_file):
@@ -204,6 +231,13 @@ class _Bridge:
                 pass
 
     def stop(self):
+        if not bpy.app.background and bpy.app.timers.is_registered(self.timer):
+            bpy.app.timers.unregister(self.timer)
+        if self.connection is not None:
+            try:
+                self.connection.shutdown(socket.SHUT_RDWR)
+            except OSError:
+                pass
         try:
             if self.server is not None:
                 self.server.close()
@@ -225,12 +259,14 @@ class _Bridge:
             except Exception:
                 return
             self.connected = True
+            self.connection = connection
             try:
                 self._converse(connection)
             except Exception as exc:
                 self.last_error = bootstrap.error_text(exc)
             finally:
                 self.connected = False
+                self.connection = None
                 try:
                     connection.close()
                 except Exception:
@@ -274,7 +310,12 @@ class _Bridge:
                         return
                     self.requests += 1
                     self.last_action = request.get("action") if isinstance(request, dict) else None
-                    answer = bootstrap._session_dispatch(request, self.options)
+                    job = {"request": request, "done": threading.Event()}
+                    self.pending.put(job)
+                    while not job["done"].wait(0.1):
+                        if self.server is None:
+                            return
+                    answer = job["answer"]
                 answer["kind"] = "result"
                 connection.sendall((json.dumps(answer, ensure_ascii=False) + "\n").encode("utf-8"))
 
@@ -407,9 +448,10 @@ def main():
         return 2
     print(json.dumps({"kind": "ready", "pid": os.getpid(), "socket": socket_path, "workspace": workspace}), flush=True)
     try:
-        # The serve thread is a daemon, so this loop is what keeps the process alive. A SIGTERM (or
-        # the product closing the socket and asking for shutdown) ends it.
-        _BRIDGE.thread.join()
+        # Headless Blender has no UI timer loop. Pump on this main thread instead
+        # of joining the socket worker, which would run bpy from the wrong thread.
+        while _BRIDGE.thread.is_alive():
+            _BRIDGE._dispatch_pending(timeout=0.1)
     except KeyboardInterrupt:
         pass
     finally:

package/python/deepblend_capabilities.py

@@ -366,6 +366,7 @@ def smoke_render(scene, engine):
         saved["resolution_percentage"] = render.resolution_percentage
         saved["file_format"] = render.image_settings.file_format
         saved["cycles_samples"] = getattr(scene.cycles, "samples", None)
+        saved["cycles_device"] = getattr(scene.cycles, "device", None)
         saved["cycles_use_denoising"] = getattr(scene.cycles, "use_denoising", None)
         saved["eevee_samples"] = getattr(scene.eevee, "taa_render_samples", None)
 
@@ -376,6 +377,10 @@ def smoke_render(scene, engine):
         render.resolution_percentage = 100
         render.image_settings.file_format = "PNG"
         if engine == "CYCLES":
+            # This measures engine availability. GPU devices are enumerated
+            # separately; inheriting an open project's GPU setting can trigger
+            # minutes of Metal kernel compilation during a capability query.
+            scene.cycles.device = "CPU"
             # 1 sample and no denoise keeps the probe effectively instantaneous.
             try:
                 scene.cycles.samples = 1
@@ -429,6 +434,8 @@ def smoke_render(scene, engine):
                 render.image_settings.file_format = saved["file_format"]
             if saved.get("cycles_samples") is not None:
                 scene.cycles.samples = saved["cycles_samples"]
+            if saved.get("cycles_device") is not None:
+                scene.cycles.device = saved["cycles_device"]
             if saved.get("cycles_use_denoising") is not None:
                 scene.cycles.use_denoising = saved["cycles_use_denoising"]
             if saved.get("eevee_samples") is not None:

package/python/deepblend_frames.py

@@ -45,6 +45,7 @@ than trusting that.
 Runs inside Blender's embedded interpreter.
 """
 
+import hashlib
 import json
 import os
 import time
@@ -299,6 +300,10 @@ def render_frames(plan, guard):
     profile = plan.get("profile") or {}
     report_progress("configure_render", 4)
     overrides, actual = apply_profile(scene, profile, guard)
+    # Persist the read-back settings before any frame can be accepted. A process
+    # killed before the final result still leaves its completed frames attributable.
+    attempt_token = plan.get("attemptToken")
+    append_event(events_path, {"type": "render_config", "attemptToken": attempt_token, "renderConfig": actual})
     expected_width = int(actual["resolution"][0])
     expected_height = int(actual["resolution"][1])
 
@@ -360,7 +365,12 @@ def render_frames(plan, guard):
         total_bytes += verdict["bytes"]
         # Written AFTER the file is verified on disk, so the journal never claims
         # a frame the ledger would call missing.
-        append_event(events_path, {"type": "frame", "frame": frame, "bytes": verdict["bytes"], "ms": elapsed_ms})
+        digest = hashlib.sha256()
+        with open(path, "rb") as stream:
+            for chunk in iter(lambda: stream.read(256 * 1024), b""):
+                digest.update(chunk)
+        append_event(events_path, {"type": "frame", "frame": frame, "bytes": verdict["bytes"], "ms": elapsed_ms,
+                                   "attemptToken": attempt_token, "sha256": digest.hexdigest()})
 
     report_progress("frames_done", 97, {"rendered": len(written)})
     append_event(events_path, {"type": "frames_done", "rendered": written})

package/python/deepblend_geometry.py

@@ -0,0 +1,210 @@
+"""Deterministic meshes for bounded SceneSpec modeling operations."""
+import math
+
+import bpy
+from deepblend_util import ActionError
+
+
+def apply_model_modifiers(entities, entity_meshes):
+    """Apply dependency-ordered, bounded mesh operations to actual geometry."""
+    by_id = {entity["id"]: entity for entity in entities}
+    done, active = set(), set()
+    bpy.context.view_layer.update()
+
+    def single_mesh(entity_id):
+        meshes = entity_meshes.get(entity_id, [])
+        if len(meshes) != 1:
+            raise ActionError("SCENE_SPEC_INVALID", 'modifier entity "%s" needs exactly one mesh' % entity_id)
+        return meshes[0]
+
+    def visit(entity_id):
+        if entity_id in done:
+            return
+        if entity_id in active:
+            raise ActionError("SCENE_SPEC_INVALID", "boolean dependency cycle: " + entity_id)
+        active.add(entity_id)
+        entity = by_id[entity_id]
+        for entry in entity.get("modifiers", []):
+            kind = entry["type"]
+            obj = single_mesh(entity_id)
+            if kind == "boolean":
+                target = entry["targetEntityId"]
+                if target not in by_id:
+                    raise ActionError("SCENE_SPEC_INVALID", "missing boolean operand: " + target)
+                visit(target)
+                operand = single_mesh(target)
+            estimate = len(obj.data.polygons) * (entry.get("count", 1) if kind == "array" else 1)
+            if estimate > 500_000:
+                raise ActionError("SCENE_SPEC_INVALID", "modifier exceeds the 500000 polygon per-entity budget")
+            modifier = obj.modifiers.new("db_model_" + kind, kind.upper())
+            if kind == "solidify":
+                modifier.thickness = float(entry["thickness"])
+                modifier.offset = float(entry.get("offset", -1))
+                modifier.use_even_offset = True
+            elif kind == "mirror":
+                modifier.use_axis = tuple(axis == entry["axis"] for axis in ("x", "y", "z"))
+                modifier.use_mirror_merge = bool(entry.get("merge", True))
+            elif kind == "array":
+                modifier.count = int(entry["count"])
+                modifier.use_relative_offset = False
+                modifier.use_constant_offset = True
+                modifier.constant_offset_displace = entry["offset"]
+            elif kind == "boolean":
+                modifier.operation = entry["operation"].upper()
+                modifier.solver = "EXACT"
+                modifier.object = operand
+            elif kind == "bevel":
+                modifier.width = float(entry["width"])
+                modifier.segments = int(entry.get("segments", 4))
+                modifier.limit_method = "ANGLE"
+                modifier.angle_limit = math.radians(float(entry.get("angle", 30)))
+                modifier.use_clamp_overlap = True
+                miter_inner = entry.get("miterInner", "arc")
+                if miter_inner not in ("arc", "sharp"):
+                    raise ActionError("SCENE_SPEC_INVALID", "bevel miterInner must be arc or sharp")
+                modifier.miter_inner = {"arc": "MITER_ARC", "sharp": "MITER_SHARP"}[miter_inner]
+                modifier.spread = float(entry["width"])
+            for selected in bpy.context.selected_objects:
+                selected.select_set(False)
+            # Hidden operands still need their own modifier stack evaluated.
+            hidden = obj.hide_viewport
+            obj.hide_viewport = False
+            obj.select_set(True)
+            bpy.context.view_layer.objects.active = obj
+            try:
+                result = bpy.ops.object.modifier_apply(modifier=modifier.name)
+            finally:
+                obj.hide_viewport = hidden
+            if "FINISHED" not in result or not obj.data.polygons:
+                raise ActionError("SCENE_SPEC_INVALID", 'modifier "%s" on "%s" produced no mesh' % (kind, entity_id))
+            if len(obj.data.polygons) > 500_000:
+                raise ActionError("SCENE_SPEC_INVALID", "modifier result exceeds the polygon budget")
+            bpy.context.view_layer.update()
+        active.remove(entity_id)
+        done.add(entity_id)
+
+    for entity in entities:
+        visit(entity["id"])
+
+
+def create_curve(name, spec):
+    """Sweep a round section along a polyline or automatic Bezier spline."""
+    data = bpy.data.curves.new(name + "_path", "CURVE")
+    data.dimensions = "3D"
+    data.resolution_u = int(spec.get("curveResolution", 16))
+    data.render_resolution_u = data.resolution_u
+    data.bevel_depth = float(spec.get("radius", 0.01))
+    data.bevel_resolution = int(spec.get("bevelResolution", 8))
+    data.use_fill_caps = bool(spec.get("capEnds", True))
+    bezier = spec.get("pathInterpolation", "poly") == "bezier"
+    spline = data.splines.new("BEZIER" if bezier else "POLY")
+    points = spline.bezier_points if bezier else spline.points
+    points.add(len(spec["path"]) - 1)
+    for point, coordinate in zip(points, spec["path"]):
+        point.co = coordinate if bezier else (*coordinate, 1)
+        if bezier:
+            point.handle_left_type = "AUTO"
+            point.handle_right_type = "AUTO"
+    spline.use_cyclic_u = bool(spec.get("pathClosed", False))
+    obj = bpy.data.objects.new(name, data)
+    bpy.context.scene.collection.objects.link(obj)
+    for selected in bpy.context.selected_objects:
+        selected.select_set(False)
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = obj
+    result = bpy.ops.object.convert(target="MESH")
+    if "FINISHED" not in result:
+        raise RuntimeError("curve conversion did not produce a mesh")
+    obj = bpy.context.object
+    # Curve conversion duplicates the end-cap rim vertices. Weld those rims
+    # into the side wall; per-corner UVs remain distinct across texture seams.
+    import bmesh
+    mesh = bmesh.new()
+    try:
+        mesh.from_mesh(obj.data)
+        bmesh.ops.remove_doubles(mesh, verts=list(mesh.verts), dist=max(float(spec.get("radius", 0.01)) * 1e-7, 1e-12))
+        bmesh.ops.recalc_face_normals(mesh, faces=list(mesh.faces))
+        mesh.to_mesh(obj.data)
+    finally:
+        mesh.free()
+    return obj
+
+
+def create_lathe(name, spec):
+    """Revolve an ordered [radius, height] boundary about local Z.
+
+    Axis points become one vertex, so caps have no coincident pole rings.
+    UV U runs around the circumference; V follows profile arc length.
+    """
+    import bmesh
+
+    profile = spec["profile"]
+    segments = int(spec.get("segments", 96))
+    closed = bool(spec.get("closedProfile", False))
+    vertices, rings, faces, face_uvs = [], [], [], []
+    distances = [0.0]
+    for a, b in zip(profile, profile[1:]):
+        distances.append(distances[-1] + math.dist(a, b))
+    total = distances[-1] + (math.dist(profile[-1], profile[0]) if closed else 0)
+    for radius, height in profile:
+        ring = []
+        for index in range(1 if radius == 0 else segments):
+            angle = math.tau * index / segments
+            ring.append(len(vertices))
+            vertices.append((radius * math.cos(angle), radius * math.sin(angle), height))
+        rings.append(ring)
+
+    def add_face(indices, uvs):
+        # A pole appears twice in a quad. Collapse it to a triangle while
+        # retaining the texture seam as per-corner UVs.
+        unique = []
+        corners = []
+        for index, uv in zip(indices, uvs):
+            if index not in unique:
+                unique.append(index)
+                corners.append(uv)
+        if len(unique) >= 3:
+            faces.append(unique)
+            face_uvs.append(corners)
+
+    for row in range(len(profile) if closed else len(profile) - 1):
+        following = (row + 1) % len(profile)
+        a, b = rings[row], rings[following]
+        va = distances[row] / total
+        vb = distances[following] / total if following else 1.0
+        for column in range(segments):
+            next_column = (column + 1) % segments
+            ua, ub = column / segments, (column + 1) / segments
+            add_face([a[column % len(a)], a[next_column % len(a)],
+                      b[next_column % len(b)], b[column % len(b)]],
+                     [(ua, va), (ub, va), (ub, vb), (ua, vb)])
+
+    if not closed and spec.get("capEnds", True):
+        for row, reverse in [(0, True), (len(rings) - 1, False)]:
+            ring = rings[row]
+            if len(ring) == 1:
+                continue
+            ordered = list(reversed(ring)) if reverse else list(ring)
+            radius = profile[row][0]
+            add_face(ordered, [(vertices[index][0] / (2 * radius) + 0.5,
+                                vertices[index][1] / (2 * radius) + 0.5) for index in ordered])
+
+    mesh = bpy.data.meshes.new(name + "_mesh")
+    mesh.from_pydata(vertices, [], faces)
+    mesh.update()
+    uv = mesh.uv_layers.new(name="UVMap")
+    for polygon, corners in zip(mesh.polygons, face_uvs):
+        for loop_index, coordinate in zip(polygon.loop_indices, corners):
+            uv.data[loop_index].uv = coordinate
+    bm = bmesh.new()
+    try:
+        bm.from_mesh(mesh)
+        bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        bm.to_mesh(mesh)
+    finally:
+        bm.free()
+    obj = bpy.data.objects.new(name, mesh)
+    bpy.context.scene.collection.objects.link(obj)
+    bpy.context.view_layer.objects.active = obj
+    obj.select_set(True)
+    return obj