{CUDA Decoding} Restore SW decoder fallback in xprsDecoderMaker

Summary:
The CUDA-enabled Linux wheel segfaults on any machine without an NVIDIA driver. The GitHub CI "Test wheel" job crashes with exit 139 after a burst of:

    Cannot load libcuda.so.1
    [XPRS][WARNING]: Loading CUDA functions failed
    [DecoderFactory][WARNING]: Could not create a decoder for 'H.265'!

Root cause: the SW-fallback fixes intended for `arvr/libraries/vrs/utils/xprs/XprsDecoder.cpp` never landed. The landed commit for D103253728 (`a4556645655d`) touched only the four `arvr/projects/compression/xprs/` files -- the `XprsDecoder.cpp` hunks were dropped somewhere during rebasing, even though the reviewed diff contained them. The same happened to the monochrome-skip hunks from D110227872. Internal master's copy of this file was last modified 2026-04-29, so ShipIt correctly exported a file that had never received the fixes.

Consequence: with no `libcuda`, `getNvCodecContext()` throws, `enumDecoders()` catches it and returns non-OK -- while still having collected the SW `hevc`/`h264` decoders. The stale `xprsDecoderMaker` bails on the non-OK result (`if (xprs::enumDecoders(decoders) != XprsResult::OK) return nullptr;`) without ever looking at those SW decoders, so no decoder is created and the null decoder is later dereferenced.

This re-applies the four lost changes to that file:
- Tolerate a non-OK `enumDecoders()` result; fail only when the decoder list is genuinely empty. (Fixes the crash.)
- On decoder `init()` failure, `continue` to the next decoder instead of returning `nullptr`, so HW->SW fallback works.
- Downgrade the recoverable HW->SW decode-probe log from `XR_LOGE` to `XR_LOGW`.
- Skip HW decoders up front for monochrome streams (`isMonochromePixelFormat`), which NVDEC cannot decode.

No change to the GPU path: color streams still select `hevc_cuvid`.

Reviewed By: kongchen1992

Differential Revision: D114806413

Author: YLouWashU

vrs/utils/xprs/XprsDecoder.cpp

@@ -93,6 +93,22 @@ Ocean::Worker* getWorkers(uint32_t pixels) {
   return pixels >= 640 * 480 ? Ocean::WorkerPool::get().scopedWorker()() : nullptr;
 }
 
+// NVDEC hardware cannot decode monochrome (4:0:0) H.265 — the format used by
+// Aria's grayscale SLAM and eye-tracking cameras. The decoded output pixel
+// format being grayscale is a reliable proxy for a monochrome bitstream, so the
+// decoder maker uses this to skip HW decoders for such streams up front.
+bool isMonochromePixelFormat(PixelFormat fmt) {
+  switch (fmt) {
+    case PixelFormat::GREY8:
+    case PixelFormat::GREY10:
+    case PixelFormat::GREY12:
+    case PixelFormat::GREY16:
+      return true;
+    default:
+      return false;
+  }
+}
+
 } // namespace
 
 namespace vrs::vxprs {
@@ -337,7 +353,11 @@ class VXDecoder : public vrs::utils::DecoderI {
     compressedBuffer.data = const_cast<uint8_t*>(encodedFrame.data());
     XprsResult res = xprsDecoder_->decodeFrame(frame, compressedBuffer);
     if (res != XprsResult::OK) {
-      XR_LOGE("Failed to decode xprs frame: {}", xprs::getErrorMessage(res));
+      // Logged at WARNING, not ERROR: this path is hit during normal HW->SW
+      // decoder probing in xprsDecoderMaker (e.g. NVDEC rejecting a monochrome
+      // stream), where the failure is expected and recovered by falling back to
+      // the next decoder. The caller turns this into a DecoderError it handles.
+      XR_LOGW("Failed to decode xprs frame: {}", xprs::getErrorMessage(res));
       return domainError(utils::DecodeStatus::DecoderError);
     }
     return SUCCESS;
@@ -373,7 +393,13 @@ unique_ptr<utils::DecoderI> xprsDecoderMaker(
   const string& codecFormatName = outputImageSpec.getCodecName();
   unique_ptr<VXDecoder> decoder;
   xprs::CodecList decoders;
-  if (xprs::enumDecoders(decoders) != XprsResult::OK) {
+  // enumDecoders may return non-OK while still populating `decoders` with the
+  // SW decoders that were collected before a HW decoder threw (e.g. CUDA init
+  // failure on a non-GPU machine). Don't bail early — only fail if the list is
+  // truly empty after enumeration.
+  (void)xprs::enumDecoders(decoders);
+  if (decoders.empty()) {
+    XR_LOGE("xprs::enumDecoders returned no decoders");
     return nullptr;
   }
   xprs::VideoCodecFormat codecFormat{};
@@ -388,18 +414,33 @@ unique_ptr<utils::DecoderI> xprsDecoderMaker(
     if (!options.useHwCodecs && dec.hwAccel) {
       continue;
     }
+    // NVDEC can't decode monochrome H.265 (Aria SLAM/eye cameras). Skip HW
+    // decoders for grayscale streams here so we go straight to SW with one
+    // informational log, instead of attempting NVDEC and emitting fallback
+    // warnings for an expected, unsupported-by-hardware condition.
+    if (dec.hwAccel && isMonochromePixelFormat(outputImageSpec.getPixelFormat())) {
+      XR_LOGI(
+          "Skipping HW decoder '{}' for monochrome {} stream (NVDEC decodes color only); using SW decoder",
+          dec.implementationName,
+          codecFormatName);
+      continue;
+    }
     unique_ptr<xprs::IVideoDecoder> xprsDecoder{createDecoder(dec)};
     if (!xprsDecoder) {
       XR_LOGE("Creating xprs decoder '{}' for {} failed!", dec.implementationName, codecFormatName);
     } else {
       XprsResult res = xprsDecoder->init({});
       if (res != XprsResult::OK) {
-        XR_LOGE(
-            "Failed to initialized xprs decoder '{}' for {}: {}",
+        // Decoder init failure is recoverable — try the next decoder in the
+        // preferred-order list (typically HW first, then SW). Returning here
+        // would prevent SW fallback when a HW decoder fails to initialize on
+        // a non-GPU machine.
+        XR_LOGW(
+            "Decoder '{}' for {} init failed ({}), trying next decoder",
             dec.implementationName,
             codecFormatName,
             xprs::getErrorMessage(res));
-        return nullptr;
+        continue;
       }
       decoder = make_unique<VXDecoder>(std::move(xprsDecoder));
       if (decoder->decode(encodedFrame, outDecodedFrame, outputImageSpec) == 0) {