gpu: decode into the pool and encode from it on Linux, on the sidecar's Vulkan device

cli/ffrwd/execute.py

@@ -3506,7 +3506,11 @@ def for_run(cls, member: str = "") -> _Log:
     def append(self, chunk: bytes) -> None:
         with self._turn:
             if self._file is not None:
+                # Flushed as it comes: a member killed with the run, or a
+                # host killed before it closes the file, leaves what it
+                # wrote rather than an empty `.part`.
                 self._file.write(chunk)
+                self._file.flush()
             self._chunks.append(chunk)
             self._held += len(chunk)
             while self._held - len(self._chunks[0]) >= self._keep:

cli/ffrwd/hardware.py

@@ -124,14 +124,17 @@ def _same(*names: str) -> dict[str, str]:
         # encoder refuses.
         codec_sw_formats={"hevc": {"yuv444p": "yuv444p", "yuvj444p": "yuv444p"}},
     ),
+    # Vulkan. `hwupload` makes no device of its own here either: ffmpeg
+    # refuses it ("A hardware device reference is required to upload frames
+    # to") unless the command names one.
     _Family(
         hwaccels=frozenset({"vulkan"}),
         output_format="vulkan",
         encoder_suffix="_vulkan",
         filter_suffix="_vulkan",
         upload="hwupload",
         encoder_needs_device=True,
-        upload_device="",
+        upload_device="vulkan",
         variants={
             "scale": {"width": "w", "height": "h", "w": "w", "h": "h"},
             "overlay": _same("x", "y"),

cli/ffrwd/processes.py

@@ -6671,7 +6671,8 @@ def rewrite(ref: FrameRef) -> FrameRef:
             rows_modules=self._rows_modules(sidecar, members),
             lookahead=sidecar.lookahead + self.encode_delays.get(sidecar.id, 0),
             av=bool(self.decodes.get(sidecar.id) or self.encodes.get(sidecar.id))
-            or any(node.filter in (DEVICE_FILTER, DECODE, ENCODE) for node in nodes.values()),
+            or any(node.filter in (DEVICE_FILTER, DECODE, ENCODE) for node in nodes.values())
+            or self._holds_a_port_feed(members),
             graph=Graph(
                 input_paths=[PIPE] * len(read_order),
                 sources={alias: index for index, alias in enumerate(read_order)},
@@ -6851,6 +6852,22 @@ def _region_tags(
             return ()
         return tuple(tuple(found.get(alias, {}).items()) for alias in order)
 
+    def _holds_a_port_feed(self, members: Sequence[str]) -> bool:
+        """Whether a node of this region holds an input a port serves: its
+        feeder may send the picture coded (a run-time lateral copies an
+        input's own h264), which the sidecar decodes with libavcodec whatever
+        the output's encoder is."""
+        for name in members:
+            shape = self.node_shapes.get(name)
+            if shape is None:
+                continue
+            node = self.g.nodes[name]
+            for port in shape.inputs:
+                hold = port.pairing.hold
+                if hold is not None and hold.port_param is not None and port.name not in node.ports:
+                    return True
+        return False
+
     def _region_listens(
         self, members: Sequence[str], names: Mapping[str, str]
     ) -> tuple[tuple[int, str, str], ...]:

cli/tests/test_hardware.py

@@ -291,7 +291,8 @@ def test_nothing_changes_without_a_hardware_encoder_or_a_hwaccel_or_the_filters(
 def test_the_vulkan_family_sends_a_picture_up_again_before_its_encoder() -> None:
     """The flips have Vulkan variants and ride the card; `pad` has none, so
     the picture comes down for it and, the encoder reading only the card's
-    frames, goes up again ahead of the file."""
+    frames, goes up again ahead of the file. `hwupload` makes no device of
+    its own, so the command names one for the filtergraph."""
     g = _graph(
         [
             _node("n1", "hflip", {}, ["src:f:v:0"]),
@@ -302,7 +303,14 @@ def test_the_vulkan_family_sends_a_picture_up_again_before_its_encoder() -> None
         options={"f": {"hwaccel": "vulkan"}},
     )
     kept = keep_on_the_card(g, _reference(), _FILM)
-    assert kept.input_options == {"f": {"hwaccel": "vulkan", "hwaccel_output_format": "vulkan"}}
+    assert kept.input_options == {
+        "f": {
+            "init_hw_device": "vulkan=up",
+            "filter_hw_device": "up",
+            "hwaccel": "vulkan",
+            "hwaccel_output_format": "vulkan",
+        }
+    }
     assert _filters(kept) == [
         ("n1", "hflip_vulkan", {}, ["src:f:v:0"]),
         ("n2", "scale_vulkan", {"w": 1280, "h": -2}, ["n1"]),

cli/tests/test_node_world.py

@@ -2257,6 +2257,20 @@ def impure(params: Mapping[str, object], bound: Sequence[str]) -> dict[str, obje
     assert sidecar.impure == ("matte.wasm",)
 
 
+def test_a_node_holding_an_input_a_port_serves_loads_libav_whatever_the_encoder(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A feeder may send its picture coded, as a run-time lateral copies an
+    input's own h264, and the sidecar decodes it with libavcodec: the region
+    is told where libav is with an encoder of ffmpeg's out, as with one of
+    its own. A node holding no port feed is not."""
+    query = "COPY (SELECT {}" + _FROM + " WITH (video_codec 'libx264')"
+    (fed,) = _plan(query.format("inset(f.video[1], port => 9100)"), monkeypatch).sidecars
+    assert fed.av
+    (plain,) = _plan(query.format("dim(f.video[1], spot(f.video[1]))"), monkeypatch).sidecars
+    assert not plain.av
+
+
 # -- a port held on the GPU takes the region's edges coded -------------------
 
 

docs/examples.md

@@ -1584,7 +1584,7 @@ ffmpeg -i tests/fixtures/testsrc.mp4 -map 0:v:0 -c:0 copy -avoid_negative_ts dis
   copy -color_range:0 tv -colorspace:0 bt709 boxed.mp4
 ```
 
-With `memory => 'host'` the same module holds nothing on the GPU, and its region takes raw frames on both pipes unless the declaration says `SET ffrwd.edges = 'coded'`. The region's `decode` is told `hw=auto`: where the machine's decoder and the device share one (D3D12 on Windows, Metal on macOS) the decoder's frames land on the device directly; elsewhere the decoded picture reaches it through the sidecar's own upload at the module's input and comes back through one download at the output, which the `upload` and `download` rows of `--profile` count.
+With `memory => 'host'` the same module holds nothing on the GPU, and its region takes raw frames on both pipes unless the declaration says `SET ffrwd.edges = 'coded'`. The region's `decode` is told `hw=auto`: where the machine's decoder and the device share one (D3D12 on Windows, Metal on macOS, Vulkan on Linux) the decoder's frames land on the device directly; elsewhere the decoded picture reaches it through the sidecar's own upload at the module's input and comes back through one download at the output, which the `upload` and `download` rows of `--profile` count.
 
 The device is on the adapter the sidecar picks by default, the one `ffrwd setup gpu` marks in its list. `--gpu-adapter` on `run` or `compile`, or `FFRWD_GPU_ADAPTER` where the flag is absent, names another, by its index in that list or by part of its name: `ffrwd run --gpu-adapter radeon -f query.sql` opens the device on that adapter, so `gpu_box` and the decoder and encoder sharing the device run there, and the printed command carries `-gpu-adapter radeon` after the `-gpu` grant. With neither, the command is the one above. Where the adapter has no decoder for the stream, `hw=auto` falls back as it does anywhere, to a decoder on a device of its own or to software.