gfx: add the GStreamer name edge for the shared-memory transports

Sh4lt and Shmdata hand over shared-memory *buffers*, not streams, and resolve
their caps through Video::gstreamerToLibav() to an AVPixelFormat -- after which a
format the decode path does not take natively is CPU-converted to RGBA. Removing
that conversion needs the layout and a stride, which is what a VideoPixelFormat
is, so they need an edge into the vocabulary.

The rest of the 54-entry gst map stays AV-first, as agreed: most of what arrives
over GStreamer is a stream format and the decode pipeline is AV-based. This table
covers the buffer layouts only.

It is a direct table rather than the existing map composed with the libav bridge,
and that is the point. Routing through AVPixelFormat loses the V-before-U
layouts, because FFmpeg has no pixel format for them: "YV12" would arrive as
YUV420P with red and blue exchanged, and "YVU9" likewise. The suite asserts that
YV12 and I420 do not collapse onto each other and that the swap is recorded.

This is the mapping, not the rewiring. Pointing Sh4lt and Shmdata at host-import
instead of the rescaler is the follow-up, and it wants those transports actually
running to validate, which needs a producer this machine does not have.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014rZgzE8JjWvHDtaVUhxpLE

Author: jcelerier

src/plugins/score-plugin-gfx/CMakeLists.txt

@@ -231,11 +231,13 @@ set(HDRS
     Gfx/Graph/interop/DirectShowPixelFormat.hpp
     Gfx/Graph/interop/DrmPixelFormat.hpp
     Gfx/Graph/interop/VideoPixelFormatQRhi.hpp
+    Gfx/Graph/interop/GStreamerPixelFormat.hpp
     Gfx/Graph/interop/VideoPixelFormat.cpp
     Gfx/Graph/interop/V4L2PixelFormat.cpp
     Gfx/Graph/interop/DirectShowPixelFormat.cpp
     Gfx/Graph/interop/DrmPixelFormat.cpp
     Gfx/Graph/interop/VideoPixelFormatQRhi.cpp
+    Gfx/Graph/interop/GStreamerPixelFormat.cpp
 
     Gfx/Graph/decoders/GPUVideoDecoder.hpp
     Gfx/Graph/decoders/GPUVideoDecoderFactory.hpp

src/plugins/score-plugin-gfx/Gfx/Graph/interop/GStreamerPixelFormat.cpp

@@ -0,0 +1,70 @@
+#include <Gfx/Graph/interop/GStreamerPixelFormat.hpp>
+
+#include <algorithm>
+#include <array>
+#include <utility>
+
+namespace score::gfx::interop
+{
+namespace
+{
+using Row = std::pair<std::string_view, VideoPixelFormat>;
+using V = VideoPixelFormat;
+
+// GStreamer names the memory byte order directly, so these read literally: its
+// "RGBA" is R,G,B,A in memory. The V-before-U spellings are distinct layouts, not
+// their U-first twins with a flag.
+constexpr std::array kRows{
+    // packed 8-bit RGB
+    Row{"RGBA", V::RGBA8}, Row{"BGRA", V::BGRA8},
+    Row{"ARGB", V::ARGB8}, Row{"ABGR", V::ABGR8},
+    Row{"RGBx", V::RGBX8}, Row{"BGRx", V::BGRX8},
+    Row{"xRGB", V::XRGB8}, Row{"xBGR", V::XBGR8},
+    Row{"RGB", V::RGB24},  Row{"BGR", V::BGR24},
+    Row{"RGB16", V::RGB565}, Row{"RGB15", V::RGB555},
+    // packed 10-bit RGB
+    Row{"r210", V::R210},
+    // packed YUV
+    Row{"YUY2", V::YUYV422}, Row{"YVYU", V::YVYU422},
+    Row{"UYVY", V::UYVY422}, Row{"VYUY", V::VYUY422},
+    Row{"AYUV", V::AYUV},    Row{"VUYA", V::VUYA},
+    Row{"v210", V::V210},    Row{"v216", V::V216},
+    Row{"Y210", V::Y210},    Row{"Y410", V::XV30},
+    Row{"IYU1", V::UYYVYY411},
+    // planar, U before V
+    Row{"I420", V::YUV420P}, Row{"Y42B", V::YUV422P},
+    Row{"Y444", V::YUV444P}, Row{"Y41B", V::YUV411P},
+    Row{"YUV9", V::YUV410P},
+    // planar, V before U
+    Row{"YV12", V::YVU420P}, Row{"YVU9", V::YVU410P},
+    // planar high bit depth
+    Row{"I420_10LE", V::YUV420P10}, Row{"I422_10LE", V::YUV422P10},
+    Row{"Y444_10LE", V::YUV444P10}, Row{"I422_12LE", V::YUV422P12},
+    Row{"Y444_12LE", V::YUV444P12}, Row{"I422_16LE", V::YUV422P16},
+    Row{"A444", V::YUVA444P},
+    // semi-planar
+    Row{"NV12", V::NV12}, Row{"NV21", V::NV21},
+    Row{"NV16", V::NV16}, Row{"NV61", V::NV61},
+    Row{"NV24", V::NV24},
+    Row{"P010_10LE", V::P010}, Row{"P016_LE", V::P216},
+    // greyscale
+    Row{"GRAY8", V::Mono8},
+    Row{"GRAY16_LE", V::Mono16}, Row{"GRAY16_BE", V::Mono16BE},
+};
+} // namespace
+
+VideoPixelFormat fromGStreamerFormat(std::string_view name) noexcept
+{
+  const auto it = std::find_if(
+      kRows.begin(), kRows.end(), [name](const Row& r) { return r.first == name; });
+  return it != kRows.end() ? it->second : V::Unknown;
+}
+
+std::string_view toGStreamerFormat(VideoPixelFormat f) noexcept
+{
+  const auto it = std::find_if(
+      kRows.begin(), kRows.end(), [f](const Row& r) { return r.second == f; });
+  return it != kRows.end() ? it->first : std::string_view{};
+}
+
+} // namespace score::gfx::interop

src/plugins/score-plugin-gfx/Gfx/Graph/interop/GStreamerPixelFormat.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+/**
+ * @file GStreamerPixelFormat.hpp
+ * @brief GStreamer video-format name <-> VideoPixelFormat.
+ *
+ * GStreamer names formats with strings in caps ("NV12", "I420", "v210"), and
+ * `Video::gstreamerToLibav()` already maps those to AVPixelFormat for the decode
+ * path. That mapping stays: most of what arrives over GStreamer is a *stream*
+ * format, and the decode pipeline is AV-based.
+ *
+ * This table exists for the transports that hand over a *buffer* -- Sh4lt and
+ * Shmdata pass shared memory -- where the layout is what matters, because a
+ * layout plus a stride is what lets a frame be imported straight onto the GPU
+ * instead of being converted on the CPU first.
+ *
+ * It is a direct table rather than a composition of the existing map with the
+ * libav bridge, and that is the point: going through AVPixelFormat loses the
+ * V-before-U layouts, since FFmpeg has no pixel format for them. "YV12" would
+ * arrive as YUV420P with red and blue exchanged.
+ */
+
+#include <Gfx/Graph/interop/VideoPixelFormat.hpp>
+
+#include <score_plugin_gfx_export.h>
+
+#include <string_view>
+
+namespace score::gfx::interop
+{
+
+/// The layout behind a GStreamer format name, or Unknown when score has no row
+/// for it -- which includes the formats that are streams rather than buffers.
+SCORE_PLUGIN_GFX_EXPORT
+VideoPixelFormat fromGStreamerFormat(std::string_view name) noexcept;
+
+/// The GStreamer name for a layout, or an empty view when it has none.
+SCORE_PLUGIN_GFX_EXPORT
+std::string_view toGStreamerFormat(VideoPixelFormat f) noexcept;
+
+} // namespace score::gfx::interop

tests/unit/VideoPixelFormatTest.cpp

@@ -25,6 +25,7 @@
 #include <Gfx/Graph/interop/VideoPixelFormat.hpp>
 #include <Gfx/Graph/interop/DirectShowPixelFormat.hpp>
 #include <Gfx/Graph/interop/DrmPixelFormat.hpp>
+#include <Gfx/Graph/interop/GStreamerPixelFormat.hpp>
 #include <Gfx/Graph/interop/VideoPixelFormatQRhi.hpp>
 #include <Gfx/Graph/interop/VideoPixelFormatAV.hpp>
 #if defined(__linux__)
@@ -1214,3 +1215,55 @@ TEST_CASE("texture formats map back only where unambiguous", "[gfx][pixfmt][qrhi
     CHECK(vpf::fromTextureFormat(vpf::planeTextureFormat(f, 0)) == f);
   }
 }
+
+// GStreamer names, for the transports that hand over a buffer rather than a
+// stream. Composing the existing gst->AV map with the libav bridge would lose the
+// V-before-U layouts, so this asserts the direct table gets them right -- that is
+// the whole reason it exists.
+TEST_CASE("GStreamer names resolve to the right layout", "[gfx][pixfmt][gst]")
+{
+  struct Pin { const char* name; V expect; };
+  static const Pin kPins[] = {
+      {"RGBA", V::RGBA8}, {"BGRA", V::BGRA8}, {"ARGB", V::ARGB8}, {"ABGR", V::ABGR8},
+      {"RGBx", V::RGBX8}, {"BGRx", V::BGRX8}, {"xRGB", V::XRGB8}, {"xBGR", V::XBGR8},
+      {"RGB", V::RGB24},  {"BGR", V::BGR24},
+      {"YUY2", V::YUYV422}, {"UYVY", V::UYVY422}, {"YVYU", V::YVYU422},
+      {"v210", V::V210},  {"v216", V::V216},  {"r210", V::R210},
+      {"I420", V::YUV420P}, {"Y42B", V::YUV422P}, {"Y444", V::YUV444P},
+      {"Y41B", V::YUV411P}, {"YUV9", V::YUV410P},
+      {"NV12", V::NV12},  {"NV21", V::NV21},  {"NV16", V::NV16},
+      {"NV61", V::NV61},  {"NV24", V::NV24},
+      {"I420_10LE", V::YUV420P10}, {"I422_10LE", V::YUV422P10},
+      {"P010_10LE", V::P010}, {"A444", V::YUVA444P},
+      {"GRAY8", V::Mono8}, {"GRAY16_LE", V::Mono16}, {"GRAY16_BE", V::Mono16BE},
+  };
+  for(const auto& p : kPins)
+  {
+    INFO("gst format " << p.name);
+    CHECK(vpf::fromGStreamerFormat(p.name) == p.expect);
+    CHECK(vpf::toGStreamerFormat(p.expect) == std::string_view{p.name});
+  }
+  // The point of a direct table: these must NOT collapse onto their U-first
+  // twins, which is what routing through AVPixelFormat would have done.
+  CHECK(vpf::fromGStreamerFormat("YV12") == V::YVU420P);
+  CHECK(vpf::fromGStreamerFormat("YVU9") == V::YVU410P);
+  CHECK(vpf::fromGStreamerFormat("YV12") != vpf::fromGStreamerFormat("I420"));
+  CHECK(vpf::chromaSwappedTwin(vpf::fromGStreamerFormat("YV12"))
+        == vpf::fromGStreamerFormat("I420"));
+  CHECK(vpf::chromaSwappedTwin(vpf::fromGStreamerFormat("NV21"))
+        == vpf::fromGStreamerFormat("NV12"));
+  // Case matters in caps, and unknown names must not guess.
+  CHECK(vpf::fromGStreamerFormat("nv12") == V::Unknown);
+  CHECK(vpf::fromGStreamerFormat("") == V::Unknown);
+  CHECK(vpf::fromGStreamerFormat("ENCODED") == V::Unknown);
+  CHECK(vpf::toGStreamerFormat(V::Unknown).empty());
+  // A name maps to one layout and back, for every row.
+  for(const auto* i : described())
+  {
+    const auto name = vpf::toGStreamerFormat(i->format);
+    if(name.empty())
+      continue;
+    INFO(i->name << " <-> " << name);
+    CHECK(vpf::fromGStreamerFormat(name) == i->format);
+  }
+}