PyPI - tatolab-testpattern - Versions diffs - 0.68.27__py3-none-any.whl - Mend

tatolab-testpattern 0.68.27__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

tatolab/testpattern/__init__.py +341 -0
tatolab/testpattern/potato_sprite_160x160.rgba +0 -0
tatolab/testpattern/py.typed +0 -0
tatolab/testpattern/sample_stream_captions_548x62.rgba +1 -0
tatolab/testpattern/test_pattern_frame.comp +96 -0
tatolab_testpattern-0.68.27.dist-info/METADATA +50 -0
tatolab_testpattern-0.68.27.dist-info/RECORD +10 -0
tatolab_testpattern-0.68.27.dist-info/WHEEL +4 -0
tatolab_testpattern-0.68.27.dist-info/entry_points.txt +2 -0
tatolab_testpattern-0.68.27.dist-info/licenses/LICENSE +134 -0

tatolab/testpattern/__init__.py ADDED Viewed

@@ -0,0 +1,341 @@
+# Copyright (c) 2025 Jonathan Fontanez
+# SPDX-License-Identifier: BUSL-1.1
+"""`TestPatternSource`: SMPTE bars, a bouncing potato and the sample stream's captions, on the GPU.
+A frame's picture is a function of its index alone: the potato leaves the
+top-left corner at frame zero and moves four pixels a frame along each axis,
+bouncing off every edge, and the caption panel sits in the bottom-right corner.
+One compute dispatch per frame writes the picture into a texture from the
+node's output pool.
+"""
+from __future__ import annotations
+import ctypes
+import dataclasses
+import struct
+from importlib import resources
+from typing import Annotated, Any
+from tatolab.stream import (
+    ComputeKernel,
+    GpuContextFullAccess,
+    GpuSurfaceHandle,
+    NodeOutputTextureRing,
+    RuntimeContextFullAccess,
+    RuntimeContextLimitedAccess,
+    VideoFrame,
+    log,
+    monotonic_now_ns,
+    msgpack,
+    node,
+)
+from tatolab.stream.catalog import BinaryEntry
+__all__ = ["TestPatternSource", "TestPatternSourceConfig"]
+_THIS_PACKAGE = "tatolab.testpattern"
+VIDEO_OUTPUT_PORT_NAME = "video"
+TEST_PATTERN_FRAMES_PER_SECOND = 30
+LARGEST_TEST_PATTERN_FRAME_SIDE_PIXELS = 16_384
+"""The largest frame side the source renders: 16K, far past any frame a stream asks for."""
+POTATO_SPRITE_PIXELS_PER_FRAME = 4
+"""How far the potato travels along each axis per frame."""
+CAPTION_PANEL_MARGIN_PIXELS = 24
+"""The gap between the caption panel and the frame's right and bottom edges."""
+DROPPED_FRAMES_BETWEEN_REPORTS = 1800
+"""A run of frames the output pool refused is logged at its first and then at every this many."""
+_TEST_PATTERN_FRAME_TEXTURE_FORMAT = "rgba8_unorm"
+_TEST_PATTERN_FRAME_TEXTURE_USAGE = ["storage_binding", "texture_binding"]
+_OVERLAY_TEXTURE_USAGE = ["texture_binding"]
+# The shader's `local_size_x` and `local_size_y`.
+_WORKGROUP_TILE_SIZE_IN_PIXELS = 16
+_POTATO_SPRITE_BINDING_NAME = "potato_sprite_texture"
+_CAPTION_PANEL_BINDING_NAME = "caption_panel_texture"
+_TEST_PATTERN_FRAME_BINDING_NAME = "test_pattern_frame"
+# The shader's `TestPatternFramePushConstants` block, field for field.
+_PUSH_CONSTANT_BLOCK_STRUCT = struct.Struct("<IIiiIIiiII")
+_SIGNED_PIXEL_OFFSET_RANGE = (-(2**31), 2**31 - 1)
+@dataclasses.dataclass(frozen=True)
+class BakedRgbaOverlay:
+    """A picture shipped in this package as tightly packed RGBA rows."""
+    resource_name: str
+    width: int
+    height: int
+    def rgba_rows(self) -> bytes:
+        """The overlay's `width × height` RGBA pixels, row by row."""
+        rgba = resources.files(_THIS_PACKAGE).joinpath(self.resource_name).read_bytes()
+        expected_byte_count = self.width * self.height * 4
+        if len(rgba) != expected_byte_count:
+            raise RuntimeError(
+                f"TestPatternSource: {self.resource_name} holds {len(rgba)} bytes, not the "
+                f"{expected_byte_count} of {self.width}x{self.height} RGBA pixels"
+            )
+        return rgba
+POTATO_SPRITE = BakedRgbaOverlay("potato_sprite_160x160.rgba", 160, 160)
+"""The potato, drawn over the bars wherever its frame index puts it."""
+SAMPLE_STREAM_CAPTION_PANEL = BakedRgbaOverlay("sample_stream_captions_548x62.rgba", 548, 62)
+""""Tatolab stream setup successfully" over "sample stream", right-aligned, in Press Start 2P
+white on an opaque dark panel."""
+@dataclasses.dataclass(frozen=True)
+class OverlayTopLeftInTheFrame:
+    """Where an overlay's top-left pixel lands; negative where the frame is smaller than it."""
+    left: int
+    top: int
+def _saturated_to_a_signed_pixel_offset(pixel_offset: int) -> int:
+    smallest, largest = _SIGNED_PIXEL_OFFSET_RANGE
+    return max(smallest, min(largest, pixel_offset))
+def _bounced_position_along(distance: int, travel: int) -> int:
+    if travel == 0:
+        return 0
+    distance_into_the_round_trip = distance % (2 * travel)
+    if distance_into_the_round_trip <= travel:
+        return distance_into_the_round_trip
+    return 2 * travel - distance_into_the_round_trip
+def potato_sprite_top_left_at_frame(
+    frame_index: int, frame_width: int, frame_height: int
+) -> OverlayTopLeftInTheFrame:
+    """Where the potato sits in frame `frame_index`, bouncing off every edge it reaches."""
+    distance = (frame_index * POTATO_SPRITE_PIXELS_PER_FRAME) % 2**64
+    return OverlayTopLeftInTheFrame(
+        left=_bounced_position_along(distance, max(frame_width - POTATO_SPRITE.width, 0)),
+        top=_bounced_position_along(distance, max(frame_height - POTATO_SPRITE.height, 0)),
+    )
+def caption_panel_top_left(frame_width: int, frame_height: int) -> OverlayTopLeftInTheFrame:
+    """Where the caption panel sits: the bottom-right corner, inset by its margin."""
+    def inset_from_the_far_edge(frame_side: int, panel_side: int) -> int:
+        return _saturated_to_a_signed_pixel_offset(
+            frame_side - panel_side - CAPTION_PANEL_MARGIN_PIXELS
+        )
+    return OverlayTopLeftInTheFrame(
+        left=inset_from_the_far_edge(frame_width, SAMPLE_STREAM_CAPTION_PANEL.width),
+        top=inset_from_the_far_edge(frame_height, SAMPLE_STREAM_CAPTION_PANEL.height),
+    )
+def pack_push_constants_for_frame(frame_index: int, frame_width: int, frame_height: int) -> bytes:
+    """The kernel's push-constant block for frame `frame_index`."""
+    potato_sprite = potato_sprite_top_left_at_frame(frame_index, frame_width, frame_height)
+    caption_panel = caption_panel_top_left(frame_width, frame_height)
+    return _PUSH_CONSTANT_BLOCK_STRUCT.pack(
+        frame_width,
+        frame_height,
+        potato_sprite.left,
+        potato_sprite.top,
+        POTATO_SPRITE.width,
+        POTATO_SPRITE.height,
+        caption_panel.left,
+        caption_panel.top,
+        SAMPLE_STREAM_CAPTION_PANEL.width,
+        SAMPLE_STREAM_CAPTION_PANEL.height,
+    )
+def compute_kernel_glsl_rendering_a_test_pattern_frame() -> str:
+    """The compute kernel that renders one frame."""
+    return resources.files(_THIS_PACKAGE).joinpath("test_pattern_frame.comp").read_text()
+def _is_plain_int(value: Any) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool)
+@dataclasses.dataclass
+class TestPatternSourceConfig:
+    """What a `TestPatternSource` is configured with: the frame size; the animation, rate and format are fixed."""
+    __test__ = False
+    width: Annotated[int, "Frame width in pixels."] = 1280
+    height: Annotated[int, "Frame height in pixels."] = 720
+    def __post_init__(self) -> None:
+        for dimension_name, dimension in (("width", self.width), ("height", self.height)):
+            if not _is_plain_int(dimension) or not (
+                1 <= dimension <= LARGEST_TEST_PATTERN_FRAME_SIDE_PIXELS
+            ):
+                raise ValueError(
+                    f"TestPatternSourceConfig: {dimension_name} is a frame side of 1 to "
+                    f"{LARGEST_TEST_PATTERN_FRAME_SIDE_PIXELS} pixels, got {dimension!r}"
+                )
+def _workgroups_covering(pixels: int) -> int:
+    return (pixels + _WORKGROUP_TILE_SIZE_IN_PIXELS - 1) // _WORKGROUP_TILE_SIZE_IN_PIXELS
+def _upload_overlay_into_a_texture(
+    gpu_full_access: GpuContextFullAccess, overlay: BakedRgbaOverlay
+) -> GpuSurfaceHandle:
+    rgba_rows = overlay.rgba_rows()
+    overlay_texture = gpu_full_access.acquire_texture(
+        overlay.width, overlay.height, _TEST_PATTERN_FRAME_TEXTURE_FORMAT, _OVERLAY_TEXTURE_USAGE
+    )
+    row_byte_count = overlay.width * 4
+    overlay_texture.lock(read_only=False)
+    try:
+        base_address = overlay_texture.base_address
+        if base_address is None:
+            raise RuntimeError(
+                f"TestPatternSource: the {overlay.resource_name} texture opened no host mapping"
+            )
+        bytes_per_row = overlay_texture.bytes_per_row
+        for row_index in range(overlay.height):
+            ctypes.memmove(
+                base_address + row_index * bytes_per_row,
+                rgba_rows[row_index * row_byte_count : (row_index + 1) * row_byte_count],
+                row_byte_count,
+            )
+    finally:
+        overlay_texture.unlock()
+    return overlay_texture
+@node(
+    execution="continuous",
+    interval_ms=33,
+    description=(
+        "Synthetic SMPTE-style color bars with a bouncing potato and the sample stream's "
+        "captions, rendered on the GPU — demos a pipeline with no camera attached"
+    ),
+)
+class TestPatternSource:
+    """The sample stream's animation at about 30 frames a second, as RGBA `VideoFrame`s."""
+    __test__ = False
+    def __init__(self, config: TestPatternSourceConfig) -> None:
+        self._config = config
+        self._frame_ring = NodeOutputTextureRing(
+            _TEST_PATTERN_FRAME_TEXTURE_FORMAT, _TEST_PATTERN_FRAME_TEXTURE_USAGE
+        )
+        self._compute_kernel: "ComputeKernel | None" = None
+        self._potato_sprite_texture: "GpuSurfaceHandle | None" = None
+        self._caption_panel_texture: "GpuSurfaceHandle | None" = None
+        # Advances only on a published frame, so frame N's picture never depends on a dropped one.
+        self._next_frame_index = 0
+        self._consecutive_dropped_frames = 0
+    @node.output(
+        description="Test-pattern video frames",
+        catalog=BinaryEntry(mode="snapshot", mime="application/msgpack"),
+    )
+    def video(self) -> VideoFrame: ...
+    def setup(self, ctx: RuntimeContextFullAccess) -> None:
+        gpu_full_access = ctx.gpu_full_access
+        self._compute_kernel = gpu_full_access.create_compute_kernel(
+            source=compute_kernel_glsl_rendering_a_test_pattern_frame(),
+            push_constant_size=_PUSH_CONSTANT_BLOCK_STRUCT.size,
+            bindings={
+                _POTATO_SPRITE_BINDING_NAME: "sampled_texture",
+                _CAPTION_PANEL_BINDING_NAME: "sampled_texture",
+                _TEST_PATTERN_FRAME_BINDING_NAME: "storage_image",
+            },
+        )
+        self._potato_sprite_texture = _upload_overlay_into_a_texture(
+            gpu_full_access, POTATO_SPRITE
+        )
+        self._caption_panel_texture = _upload_overlay_into_a_texture(
+            gpu_full_access, SAMPLE_STREAM_CAPTION_PANEL
+        )
+        log.info(
+            f"TestPatternSource: rendering {self._config.width}x{self._config.height} on the GPU"
+        )
+    def process(self, ctx: RuntimeContextLimitedAccess) -> None:
+        if (
+            self._compute_kernel is None
+            or self._potato_sprite_texture is None
+            or self._caption_panel_texture is None
+        ):
+            return
+        frame_width, frame_height = self._config.width, self._config.height
+        try:
+            frame_texture = self._frame_ring.next_texture_for_this_frame(
+                ctx.gpu_limited_access, frame_width, frame_height
+            )
+        except RuntimeError as refusal:
+            self._note_a_frame_the_output_pool_refused(refusal)
+            return
+        self._consecutive_dropped_frames = 0
+        self._compute_kernel.dispatch(
+            bindings={
+                _POTATO_SPRITE_BINDING_NAME: self._potato_sprite_texture,
+                _CAPTION_PANEL_BINDING_NAME: self._caption_panel_texture,
+                _TEST_PATTERN_FRAME_BINDING_NAME: frame_texture,
+            },
+            group_count=(
+                _workgroups_covering(frame_width),
+                _workgroups_covering(frame_height),
+                1,
+            ),
+            push_constants=pack_push_constants_for_frame(
+                self._next_frame_index, frame_width, frame_height
+            ),
+        )
+        self._next_frame_index += 1
+        timestamp_ns = monotonic_now_ns()
+        ctx.outputs.write(
+            VIDEO_OUTPUT_PORT_NAME,
+            msgpack.pack(
+                {
+                    "surface_id": frame_texture.surface_id,
+                    "width": frame_width,
+                    "height": frame_height,
+                    "timestamp_ns": timestamp_ns,
+                    "fps": TEST_PATTERN_FRAMES_PER_SECOND,
+                    "color_info": {"primaries": "bt709", "transfer": "srgb", "range": "full"},
+                }
+            ),
+            timestamp_ns=timestamp_ns,
+        )
+    def teardown(self, ctx: RuntimeContextFullAccess) -> None:
+        del ctx
+        for overlay_texture in (self._potato_sprite_texture, self._caption_panel_texture):
+            if overlay_texture is not None:
+                overlay_texture.close()
+        self._potato_sprite_texture = None
+        self._caption_panel_texture = None
+        self._compute_kernel = None
+    def _note_a_frame_the_output_pool_refused(self, refusal: RuntimeError) -> None:
+        self._consecutive_dropped_frames += 1
+        if (self._consecutive_dropped_frames - 1) % DROPPED_FRAMES_BETWEEN_REPORTS == 0:
+            log.warn(
+                f"TestPatternSource: dropped frame {self._next_frame_index}, "
+                f"{self._consecutive_dropped_frames} in a row: {refusal}"
+            )

tatolab/testpattern/potato_sprite_160x160.rgba ADDED Viewed

Binary file

tatolab/testpattern/py.typed ADDED Viewed

File without changes

tatolab/testpattern/sample_stream_captions_548x62.rgba ADDED Viewed

	@@ -0,0 +1 @@
1	+ ��

tatolab/testpattern/test_pattern_frame.comp ADDED Viewed

@@ -0,0 +1,96 @@
+// Copyright (c) 2025 Jonathan Fontanez
+// SPDX-License-Identifier: BUSL-1.1
+// One test-pattern frame: SMPTE bars, the potato sprite over them, the caption
+// panel over both. Every channel is blended as a whole byte, so every device
+// writes the same bytes for the same push constants.
+#version 450
+layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
+layout(set = 0, binding = 0) uniform sampler2D potato_sprite_texture;
+layout(set = 0, binding = 1) uniform sampler2D caption_panel_texture;
+layout(set = 0, binding = 2, rgba8) uniform writeonly image2D test_pattern_frame;
+layout(push_constant) uniform TestPatternFramePushConstants {
+    uint frame_width;
+    uint frame_height;
+    int potato_sprite_left;
+    int potato_sprite_top;
+    uint potato_sprite_width;
+    uint potato_sprite_height;
+    int caption_panel_left;
+    int caption_panel_top;
+    uint caption_panel_width;
+    uint caption_panel_height;
+} placement;
+const uint SMPTE_BAR_COUNT = 8u;
+const uvec4 SMPTE_BAR_COLORS_RGBA[SMPTE_BAR_COUNT] = uvec4[](
+    uvec4(255u, 255u, 255u, 255u), // white
+    uvec4(255u, 255u, 0u, 255u),   // yellow
+    uvec4(0u, 255u, 255u, 255u),   // cyan
+    uvec4(0u, 255u, 0u, 255u),     // green
+    uvec4(255u, 0u, 255u, 255u),   // magenta
+    uvec4(255u, 0u, 0u, 255u),     // red
+    uvec4(0u, 0u, 255u, 255u),     // blue
+    uvec4(0u, 0u, 0u, 255u)        // black
+);
+// An `rgba8_unorm` texel holds `byte / 255` exactly enough that rounding
+// recovers the byte.
+uvec4 texel_bytes(sampler2D overlay_texture, ivec2 within_overlay) {
+    return uvec4(round(texelFetch(overlay_texture, within_overlay, 0) * 255.0));
+}
+// `above` composited over an opaque `below`, rounded to the nearest byte.
+uvec4 composite_over_opaque(uvec4 above, uvec4 below) {
+    if (above.a == 0u) {
+        return below;
+    }
+    if (above.a == 255u) {
+        return above;
+    }
+    uvec3 blended = (above.rgb * above.a + below.rgb * (255u - above.a) + 127u) / 255u;
+    return uvec4(blended, 255u);
+}
+// The overlay byte quadruple covering frame pixel `at`, or a transparent one
+// where the overlay placed at `top_left` does not cover it.
+uvec4 overlay_bytes_at(
+    sampler2D overlay_texture, ivec2 at, ivec2 top_left, uvec2 overlay_extent) {
+    ivec2 within_overlay = at - top_left;
+    if (any(lessThan(within_overlay, ivec2(0)))
+        || any(greaterThanEqual(uvec2(within_overlay), overlay_extent))) {
+        return uvec4(0u);
+    }
+    return texel_bytes(overlay_texture, within_overlay);
+}
+void main() {
+    uvec2 at = gl_GlobalInvocationID.xy;
+    if (at.x >= placement.frame_width || at.y >= placement.frame_height) {
+        return;
+    }
+    uint bar = min((at.x * SMPTE_BAR_COUNT) / placement.frame_width, SMPTE_BAR_COUNT - 1u);
+    uvec4 pixel = SMPTE_BAR_COLORS_RGBA[bar];
+    pixel = composite_over_opaque(
+        overlay_bytes_at(
+            potato_sprite_texture,
+            ivec2(at),
+            ivec2(placement.potato_sprite_left, placement.potato_sprite_top),
+            uvec2(placement.potato_sprite_width, placement.potato_sprite_height)),
+        pixel);
+    pixel = composite_over_opaque(
+        overlay_bytes_at(
+            caption_panel_texture,
+            ivec2(at),
+            ivec2(placement.caption_panel_left, placement.caption_panel_top),
+            uvec2(placement.caption_panel_width, placement.caption_panel_height)),
+        pixel);
+    imageStore(test_pattern_frame, ivec2(at), vec4(pixel) / 255.0);
+}

tatolab_testpattern-0.68.27.dist-info/METADATA ADDED Viewed

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: tatolab-testpattern
+Version: 0.68.27
+Summary: A test-pattern video source for Tatolab streams: SMPTE bars and a bouncing potato, rendered on the GPU.
+Project-URL: Homepage, https://tatolab.com
+Project-URL: Install, https://tatolab.com/docs/install
+Project-URL: Source, https://github.com/tatolab/streamlib
+Author-email: Jonathan Fontanez <fontanezj1@gmail.com>
+License-Expression: BUSL-1.1
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: tatolab-stream>=0.68.7
+Description-Content-Type: text/markdown
+# tatolab-testpattern
+The sample stream's test pattern, built the way a third party builds a node: an
+ordinary Python package that depends on `tatolab-stream` and on no engine crate.
+Its GPU work is one compute kernel built through `create_compute_kernel`, the
+surface every node is handed.
+- `TestPatternSource` publishes SMPTE-style colour bars with a bouncing potato
+  and the sample stream's caption panel on `video`, about 30 frames a second, as
+  RGBA `VideoFrame`s tagged BT.709 primaries, the sRGB transfer and full range.
+  - Config: `width` and `height` of each frame, 1280x720 by default, each side 1
+    to 16384 pixels.
+  - A frame's picture is a function of its index alone: the potato leaves the
+    top-left corner at frame zero, travels four pixels a frame along each axis
+    and bounces off every edge; the caption panel sits 24 pixels in from the
+    bottom-right corner. The index advances only when a frame is published, so
+    a frame the output pool refused never shifts the next one's picture.
+```python
+from tatolab.testpattern import TestPatternSource
+source = stream_builder.add(TestPatternSource, config={"width": 1920, "height": 1080})
+```
+## Check it
+```bash
+uv venv --python 3.12 .venv && VIRTUAL_ENV=.venv uv pip install ../../sdk/tatolab-stream -e . pytest
+.venv/bin/pytest tests && uvx pyright@1.1.411
+```
+The pixel tests run on a runtime, in the integration suite's
+`test_test_pattern_module.py`.

tatolab_testpattern-0.68.27.dist-info/RECORD ADDED Viewed

@@ -0,0 +1,10 @@
+tatolab/testpattern/__init__.py,sha256=LHjqSvMfEURnQEgwKgFo0lWwrRpH83QDa6refAuHlTo,12924
+tatolab/testpattern/potato_sprite_160x160.rgba,sha256=Tq3EhnggkawIoH-nTc5CToapU--Jx1J0nNti0rF_wJg,102400
+tatolab/testpattern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tatolab/testpattern/sample_stream_captions_548x62.rgba,sha256=HKV9AZk1XRO8H1B7y7duX9WN1qL6KHEA_t4ck0T83Wc,135904
+tatolab/testpattern/test_pattern_frame.comp,sha256=PdRLZc4_qBzKQe30yxG5PcJasDkJVPoqOnsDGkB0mm4,3467
+tatolab_testpattern-0.68.27.dist-info/METADATA,sha256=r-U8aSpJ6SugcwmtBZb9ld-XRqIeas1EHQjIpYv36DU,2100
+tatolab_testpattern-0.68.27.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+tatolab_testpattern-0.68.27.dist-info/entry_points.txt,sha256=57nknH8_5SMEU65zK9-adWvrXB8sllKJ56vQXhVs0C0,74
+tatolab_testpattern-0.68.27.dist-info/licenses/LICENSE,sha256=6JmFbJaesl1Pzr79-PQAOnYBnZ0R-PuAd7kPWA_kBG8,6634
+tatolab_testpattern-0.68.27.dist-info/RECORD,,

tatolab_testpattern-0.68.27.dist-info/WHEEL ADDED Viewed

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tatolab_testpattern-0.68.27.dist-info/entry_points.txt ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ [tatolab.nodes]
2	+ TestPatternSource = tatolab.testpattern:TestPatternSource

tatolab_testpattern-0.68.27.dist-info/licenses/LICENSE ADDED Viewed

@@ -0,0 +1,134 @@
+License text copyright (c) 2020 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+Parameters
+Licensor:             Jonathan Fontanez
+Licensed Work:        StreamLib
+                      The Licensed Work is (c) 2025 Jonathan Fontanez.
+Additional Use Grant: You may make production use of the Licensed Work, provided
+                      that you do not engage in any Restricted Use.
+                      RESTRICTED USES (require commercial license):
+                      (a) Selling, licensing, sublicensing, or distributing the
+                          Runtime (or any derivative work based on the Runtime)
+                          as a standalone product, SDK, framework, engine, or
+                          library;
+                      (b) Offering the Runtime as a managed service, hosted
+                          platform, cloud offering, or "as-a-service" product
+                          where third parties interact with the Runtime's
+                          functionality;
+                      (c) White-labeling, rebranding, or OEM licensing of the
+                          Runtime for redistribution to third parties;
+                      (d) Creating a product that competes with StreamLib by
+                          providing substantially similar media processing
+                          runtime capabilities derived from the Licensed Work;
+                      (e) Embedding the Runtime in a product where the Runtime
+                          itself (or access to it) is sold, licensed, or
+                          sublicensed separately to end users.
+                      "Runtime" means the StreamLib runtime engine, including
+                      the graph data structures, graph compiler, scheduler,
+                      processor execution system, link/port infrastructure,
+                      GPU context management, and associated infrastructure
+                      code found in this repository.
+                      The Runtime does NOT include Processors you create using
+                      StreamLib's Processor API (see Permitted Uses below).
+                      PERMITTED USES (no commercial license required):
+                      (a) Personal, educational, and research use;
+                      (b) Internal business use for evaluation and development;
+                      (c) Use in open source projects licensed under OSI-approved
+                          licenses;
+                      (d) Use in commercial products where StreamLib is not the
+                          primary value proposition (e.g., a video conferencing
+                          app, a security camera system, a robotics application);
+                      (e) Building, distributing, and selling custom Processors.
+                          "Processors" are components that implement StreamLib's
+                          processor traits (ReactiveProcessor, ContinuousProcessor,
+                          ManualProcessor) to add functionality to the pipeline.
+                          YOU OWN YOUR PROCESSORS. StreamLib claims no rights to
+                          Processor code you create. You may:
+                          - License your Processors under any terms (including
+                            proprietary/commercial)
+                          - Sell your Processors for any price
+                          - Keep your Processor source code private
+                          - Build Processors for clients as a contractor/consultant
+                          This grant exists to encourage a thriving ecosystem of
+                          community and commercial Processors, similar to how game
+                          engines enable developers to build and sell games.
+                      For any Restricted Use, you must obtain a commercial license.
+                      Two options are available:
+                      - Commercial License: For production use that falls under
+                        Restricted Uses.
+                      - Partner License: For consulting companies, integrators,
+                        and strategic partners with additional benefits including
+                        early access, roadmap input, and co-marketing rights.
+Change Date:          January 1, 2029
+Change License:       Apache License, Version 2.0
+For information about alternative licensing arrangements for the Licensed Work,
+please contact: fontanezj1@gmail.com
+Notice
+Business Source License 1.1
+Terms
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production
+use.
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.