Address PR review comments

- Move memset before empty check in HWMC constructor to ensure params initialization
- Add cleanup of allocated buffers on malloc failure in StreamView::start()
- Use static buffer in processCaptureResult() to avoid per-frame allocation overhead
- Parse ls output with splitlines() to handle multiple DFU device entries
- Quote remaining unquoted $TEGRA_KERNEL_OUT in build_all.sh

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: sareluzi

build_all.sh

@@ -67,7 +67,7 @@ if [[ $CLEAN == 1 ]]; then
     rm -rf "$SRCS/out"
 fi
 
-mkdir -p $TEGRA_KERNEL_OUT
+mkdir -p "$TEGRA_KERNEL_OUT"
 export KERNEL_MODULES_OUT=$TEGRA_KERNEL_OUT/modules
 
 # Check if BUILD_NUMBER is set as it will add a postfix to the kernel name "vermagic" (normally it happens on CI who have BUILD_NUMBER defined)
@@ -103,7 +103,7 @@ if [[ "$JETPACK_VERSION" == "6.x" ]]; then
     fi
     make ARCH=arm64 modules
     make ARCH=arm64 dtbs
-    mkdir -p $TEGRA_KERNEL_OUT/rootfs/boot/dtb
+    mkdir -p "$TEGRA_KERNEL_OUT"/rootfs/boot/dtb
     cp $SRCS/nvidia-oot/device-tree/platform/generic-dts/dtbs/tegra234-p3737-0000+p3701-0000-nv.dtb $TEGRA_KERNEL_OUT/rootfs/boot/dtb/
     cp $SRCS/nvidia-oot/device-tree/platform/generic-dts/dtbs/tegra234-p3737-0000+p3701-0005-nv.dtb $TEGRA_KERNEL_OUT/rootfs/boot/dtb/
     cp $SRCS/nvidia-oot/device-tree/platform/generic-dts/dtbs/tegra234-camera-d4xx-overlay*.dtbo $TEGRA_KERNEL_OUT/rootfs/boot/

test/test_fw_version.py

@@ -32,13 +32,18 @@ def test_fw_version(device):
         assert fw_version == (fw_version & 0x05FFFFFF), "Expected FW version is 5.x.x.x, but received {}".format(fw_version_str)
 
         # Get DFU device name
-        dfu_device = subprocess.check_output(["ls", "/sys/class/d4xx-class/"]).decode()
-        assert "d4xx-dfu-" in dfu_device, "D4xx DFU device not found"
-
-        # Validate DFU device name to prevent path traversal
-        dfu_device_name = dfu_device.strip()
-        if not re.match(r'^d4xx-dfu-[0-9]+$', dfu_device_name):
-            raise ValueError(f"Invalid DFU device name: {dfu_device_name}")
+        dfu_device_output = subprocess.check_output(["ls", "/sys/class/d4xx-class/"]).decode()
+
+        # Parse ls output, which may contain multiple entries, and select a valid DFU device
+        dfu_entries = [line.strip() for line in dfu_device_output.splitlines() if line.strip()]
+        dfu_pattern = re.compile(r'^d4xx-dfu-[0-9]+$')
+        dfu_device_name = None
+        for entry in dfu_entries:
+            if dfu_pattern.match(entry):
+                dfu_device_name = entry
+                break
+
+        assert dfu_device_name is not None, "D4xx DFU device not found"
 
         # Get FW version from DFU device info
         dfu_device_path = f"/dev/{dfu_device_name}"

utilities/streamApp/gui/StreamView.cpp

@@ -235,6 +235,13 @@ int StreamView::start(uint32_t memoryType) {
             void* ptr = malloc(bufferLength);
             if (ptr == nullptr) {
                 RS_LOGE("Failed to allocate buffer %d of size %u", i, bufferLength);
+                // Free previously allocated buffers before returning
+                for (auto& buf : mRsBuffers) {
+                    if (buf.buffer != nullptr) {
+                        free(buf.buffer);
+                    }
+                }
+                mRsBuffers.clear();
                 return -1;
             }
             mRsBuffers.emplace_back(ptr, bufferLength, i);
@@ -286,14 +293,18 @@ void StreamView::processCaptureResult(uint32_t index)
     uint32_t cnt = 0;
     char* left;
     char* right;
-    // Use heap allocation instead of VLA to prevent stack overflow
+    // Use static heap allocation instead of VLA to prevent stack overflow
+    // Static buffer is reused across calls to avoid per-frame allocation overhead
     uint32_t frameSize = mFormat.calcBytesPerFrame();
     constexpr uint32_t MAX_FRAME_SIZE = 64 * 1024 * 1024; // 64MB max
     if (frameSize == 0 || frameSize > MAX_FRAME_SIZE) {
         RS_LOGE("Invalid frame size: %u", frameSize);
         return;
     }
-    std::vector<char> imageVec(frameSize);
+    static std::vector<char> imageVec;
+    if (imageVec.size() < frameSize) {
+        imageVec.resize(frameSize);
+    }
     char* image = imageVec.data();
     //lock_guard<mutex> lock(mMutex);
     switch(mStreamType) {

utilities/streamApp/hwmc.cpp

@@ -24,12 +24,12 @@ using namespace realsense::utils;
 #pragma pack(push, 1)
 struct HWMC {
 	HWMC(const vector<int32_t> &inParams):header(0x14), magic_word(0xCDAB), opcode(0) {
+		memset(params, 0, sizeof(params));
 		if (inParams.empty()) {
 			cerr << "Error: HWMC requires at least an opcode" << endl;
 			return;
 		}
 		opcode = inParams[0];
-		memset(params, 0, sizeof(params));
 		size_t paramCount = std::min(inParams.size() - 1, sizeof(params)/sizeof(params[0]));
 		for (size_t i = 0; i < paramCount; i++)
 			params[i] = inParams[i + 1];