Trying to lower rgb camera resoultion

I'm trying to run the rgb camera at 720p but I keep getting this error:

[1844301051F53E0E00] [1.2.4.4] [163.050] [system] [critical] Fatal error. Please report to developers. Log: 'ResourceLocker' '358'

I've played around with the scaling but nothing has worked yet. I'm using an oak-d camera.

std::tuple<dai::Pipeline, int, int> OakCustomLaunch::createPipeline(bool enableDepth,
                                                                    bool enableSpatialDetection,
                                                                    bool enableRGB,
                                                                    bool enableImu,
                                                                    bool single,
                                                                    bool useMobile,
                                                                    bool lrcheck,
                                                                    bool extended,
                                                                    bool subpixel,
                                                                    int stereo_fps,
                                                                    int confidence,
                                                                    int LRchecktresh,
                                                                    int previewWidth, 
                                                                    int previewHeight,
                                                                    int mobile_previewWidth, 
                                                                    int mobile_previewHeight,
                                                                    int rgbScaleNumerator,
                                                                    int rgbScaleDinominator,
                                                                    int detectionClassesCount,
                                                                    std::string resolution,
                                                                    std::string colorResolution,
                                                                    bool syncNN,
                                                                    int imuRate,
                                                                    std::string mobliePath,
                                                                    std::string nnPath) 
{
    dai::Pipeline pipeline;

    dai::node::MonoCamera::Properties::SensorResolution monoResolution;
    int width, height, rgbWidth, rgbHeight;
    if(resolution == "720p") {
        monoResolution = dai::node::MonoCamera::Properties::SensorResolution::THE_720_P;
        width = 1280;
        height = 720;
    } else if(resolution == "400p") {
        monoResolution = dai::node::MonoCamera::Properties::SensorResolution::THE_400_P;
        width = 640;
        height = 400;
    } else if(resolution == "800p") {
        monoResolution = dai::node::MonoCamera::Properties::SensorResolution::THE_800_P;
        width = 1280;
        height = 800;
    } else if(resolution == "480p") {
        monoResolution = dai::node::MonoCamera::Properties::SensorResolution::THE_480_P;
        width = 640;
        height = 480;
    } else {
        ROS_ERROR("Invalid parameter. -> monoResolution: %s", resolution.c_str());
        throw std::runtime_error("Invalid mono camera resolution.");
    }

    //imu
    auto imu = pipeline.create<dai::node::IMU>();
    auto xoutImu = pipeline.create<dai::node::XLinkOut>();
    xoutImu->setStreamName("imu");
    imu->enableIMUSensor({dai::IMUSensor::ACCELEROMETER_RAW, dai::IMUSensor::GYROSCOPE_RAW}, imuRate);
    imu->setBatchReportThreshold(5);
    imu->setMaxBatchReports(20);  // Get one message only for now.
    imu->out.link(xoutImu->input);
    
    // RGB image
    dai::ColorCameraProperties::SensorResolution rgbResolution;
    if(colorResolution == "1080p") {
        rgbResolution = dai::node::ColorCamera::Properties::SensorResolution::THE_1080_P;
        rgbWidth = 1920;
        rgbHeight = 1080;
    } else if(colorResolution == "720p") {
        rgbResolution = dai::node::ColorCamera::Properties::SensorResolution::THE_720_P;
        rgbWidth = 1280;
        rgbHeight = 720;
        ROS_WARN_STREAM("uhhhhhh");
    } else if(colorResolution == "800p") {
        rgbResolution = dai::node::ColorCamera::Properties::SensorResolution::THE_800_P;
        rgbWidth = 1280;
        rgbHeight = 800;
    } else {
        ROS_ERROR("Invalid parameter. -> rgbResolution: %s", colorResolution.c_str());
        throw std::runtime_error("Invalid color camera resolution.");
    }

    auto camRgb = pipeline.create<dai::node::ColorCamera>();
    auto xoutRgb = pipeline.create<dai::node::XLinkOut>();

    xoutRgb->setStreamName("rgb");
    camRgb->setResolution(rgbResolution);
    camRgb->setBoardSocket(dai::CameraBoardSocket::RGB);
    camRgb->setInterleaved(false);

    rgbWidth = rgbWidth * rgbScaleNumerator / rgbScaleDinominator;
    ROS_WARN_STREAM("rgb width is " << rgbWidth << " the %16 is " << rgbWidth  % 16);
    rgbHeight = rgbHeight * rgbScaleNumerator / rgbScaleDinominator;
    camRgb->setIspScale(rgbScaleNumerator, rgbScaleDinominator);
    
    camRgb->setPreviewSize(416, 416);
    camRgb->isp.link(xoutRgb->input);

    if(rgbWidth  % 16 != 0) {
        ROS_ERROR_STREAM("RGB Camera width is "<<  (rgbWidth%16) <<" but it should be multiple of 16. Please choose a different scaling factor.");
        throw std::runtime_error("Adjust RGB Camaera scaling.");
    }

    if(rgbWidth > width || rgbHeight > height) {
        ROS_WARN_STREAM(
            "RGB Camera resolution is heigher than the configured stereo resolution. Upscaling the stereo depth/disparity to match RGB camera resolution.");
    } else if(rgbWidth > width || rgbHeight > height) {
        ROS_WARN_STREAM(
            "RGB Camera resolution is heigher than the configured stereo resolution. Downscaling the stereo depth/disparity to match RGB camera resolution.");
    }

    auto stereo = pipeline.create<dai::node::StereoDepth>();
    auto xoutDepth = pipeline.create<dai::node::XLinkOut>();
    auto monoLeft = pipeline.create<dai::node::MonoCamera>();
    auto monoRight = pipeline.create<dai::node::MonoCamera>();

    xoutDepth->setStreamName("depth");

    // MonoCamera
    monoLeft->setResolution(monoResolution);
    monoLeft->setBoardSocket(dai::CameraBoardSocket::LEFT);
    monoLeft->setFps(stereo_fps);
    monoRight->setResolution(monoResolution);
    monoRight->setBoardSocket(dai::CameraBoardSocket::RIGHT);
    monoRight->setFps(stereo_fps);

    // StereoDepth
    stereo->initialConfig.setConfidenceThreshold(confidence);        // Known to be best
    stereo->setRectifyEdgeFillColor(0);                              // black, to better see the cutout
    stereo->initialConfig.setLeftRightCheckThreshold(LRchecktresh);  // Known to be best
    stereo->setLeftRightCheck(lrcheck);
    stereo->setExtendedDisparity(extended);
    stereo->setSubpixel(subpixel);
    stereo->setDepthAlign(dai::CameraBoardSocket::RGB);

    // Link plugins CAM -> STEREO -> XLINK
    stereo->setRectifyEdgeFillColor(0);
    monoLeft->out.link(stereo->left);
    monoRight->out.link(stereo->right);
    stereo->depth.link(xoutDepth->input);
    
    //Yolo
    if (enableSpatialDetection && !useMobile)
    {
        camRgb->setColorOrder(dai::ColorCameraProperties::ColorOrder::BGR);
        camRgb->setInterleaved(false);
        camRgb->setPreviewSize(previewWidth, previewHeight);

        auto spatialDetectionNetwork = pipeline.create<dai::node::YoloSpatialDetectionNetwork>();
        auto xoutNN = pipeline.create<dai::node::XLinkOut>();
        auto xoutPreview = pipeline.create<dai::node::XLinkOut>();
        xoutPreview->setStreamName("preview");
        xoutNN->setStreamName("detections");

        spatialDetectionNetwork->setBlobPath(nnPath);
        spatialDetectionNetwork->setConfidenceThreshold(0.5f);
        spatialDetectionNetwork->input.setBlocking(false);
        spatialDetectionNetwork->setBoundingBoxScaleFactor(0.5);
        spatialDetectionNetwork->setDepthLowerThreshold(100);
        spatialDetectionNetwork->setDepthUpperThreshold(10000);

        // yolo specific parameters
        spatialDetectionNetwork->setNumClasses(detectionClassesCount);
        spatialDetectionNetwork->setCoordinateSize(4);
        spatialDetectionNetwork->setAnchors({10, 14, 23, 27, 37, 58, 81, 82, 135, 169, 344, 319});
        spatialDetectionNetwork->setAnchorMasks({{"side13", {3, 4, 5}}, {"side26", {1, 2, 3}}});
        spatialDetectionNetwork->setIouThreshold(0.5f);

        // Link plugins CAM -> NN -> XLINK
        camRgb->preview.link(spatialDetectionNetwork->input);
        if(syncNN){
            spatialDetectionNetwork->passthrough.link(xoutPreview->input);
        }else{
            camRgb->preview.link(xoutPreview->input);
        }
        spatialDetectionNetwork->out.link(xoutNN->input);

        stereo->depth.link(spatialDetectionNetwork->inputDepth);
    }
    
    //Mobilenet
    if(enableSpatialDetection && useMobile)
    {
        auto detectionNetwork = pipeline.create<dai::node::MobileNetDetectionNetwork>();
        auto dnOut = pipeline.create<dai::node::XLinkOut>();
        auto xoutPreview = pipeline.create<dai::node::XLinkOut>();

        xoutPreview->setStreamName("preview");
        dnOut->setStreamName("detections");

        camRgb->setPreviewSize(mobile_previewWidth, mobile_previewHeight);
        camRgb->setInterleaved(false);
        camRgb->setColorOrder(dai::ColorCameraProperties::ColorOrder::BGR);

        // testing MobileNet DetectionNetwork
        detectionNetwork->setBlobPath(mobliePath);
        detectionNetwork->setConfidenceThreshold(0.5f);

        // Link plugins CAM -> NN -> XLINK
        camRgb->preview.link(detectionNetwork->input);
        if(syncNN){
            detectionNetwork->passthrough.link(xoutPreview->input);
        }else{
            camRgb->preview.link(xoutPreview->input);
        }
        detectionNetwork->out.link(dnOut->input);
    }
    

    return std::make_tuple(pipeline, width, height);
}