Image ARRI Alexa Cinema Camera Filter Effect Enhancer

async function processImage(originalImg, desaturationLevel = 0.15, sCurveIntensity = 1.0, coolShadowAmount = 8, warmHighlightAmount = 5) {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');

    // Ensure the original image is loaded
    if (!originalImg.complete || originalImg.naturalWidth === 0) {
        // Wait for the image to load if it's not already
        await new Promise((resolve, reject) => {
            originalImg.onload = resolve;
            originalImg.onerror = reject;
            // If src is already set and it failed, it might not trigger error again
            // If it's not set, this won't help unless src is set right after calling this function.
            // Assuming originalImg is a valid, loaded Image object as per typical usage.
        });
    }

    canvas.width = originalImg.naturalWidth;
    canvas.height = originalImg.naturalHeight;

    ctx.drawImage(originalImg, 0, 0);

    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    const data = imageData.data;

    const smoothstep = (x) => x * x * (3 - 2 * x);

    for (let i = 0; i < data.length; i += 4) {
        let r = data[i];
        let g = data[i+1];
        let b = data[i+2];
        const alpha = data[i+3];

        // 1. Apply S-Curve for "cinematic" contrast and highlight/shadow roll-off
        let r_norm = r / 255;
        let g_norm = g / 255;
        let b_norm = b / 255;

        let r_s, g_s, b_s;
        if (sCurveIntensity > 0) {
             r_s = (r_norm * (1 - sCurveIntensity) + smoothstep(r_norm) * sCurveIntensity) * 255;
             g_s = (g_norm * (1 - sCurveIntensity) + smoothstep(g_norm) * sCurveIntensity) * 255;
             b_s = (b_norm * (1 - sCurveIntensity) + smoothstep(b_norm) * sCurveIntensity) * 255;
        } else {
             r_s = r;
             g_s = g;
             b_s = b;
        }


        // 2. Apply Desaturation
        let r_d, g_d, b_d;
        if (desaturationLevel > 0) {
            const luma = 0.299 * r_s + 0.587 * g_s + 0.114 * b_s;
            r_d = r_s + desaturationLevel * (luma - r_s);
            g_d = g_s + desaturationLevel * (luma - g_s);
            b_d = b_s + desaturationLevel * (luma - b_s);
        } else {
            r_d = r_s;
            g_d = g_s;
            b_d = b_s;
        }

        // 3. Apply Split Toning (Cool Shadows, Warm Highlights)
        let r_final = r_d;
        let g_final = g_d;
        let b_final = b_d;

        if (coolShadowAmount > 0 || warmHighlightAmount > 0) {
            const luma_for_split = (0.299 * r_d + 0.587 * g_d + 0.114 * b_d) / 255.0; // Normalized luma [0,1]

            // Calculate influence of shadow and highlight tint
            // Shadow influence is strongest for luma=0, fades to 0 at luma=0.5
            const shadow_influence = Math.max(0, 1.0 - luma_for_split * 2.0);
            // Highlight influence is 0 until luma=0.5, then strongest for luma=1
            const highlight_influence = Math.max(0, (luma_for_split - 0.5) * 2.0);

            if (coolShadowAmount > 0 && shadow_influence > 0) {
                // Add blueish/cyanish tint to shadows
                b_final += shadow_influence * coolShadowAmount;
                r_final -= shadow_influence * coolShadowAmount * 0.3; // Reduce red slightly
                g_final += shadow_influence * coolShadowAmount * 0.1; // Add a touch of green for cyan
            }

            if (warmHighlightAmount > 0 && highlight_influence > 0) {
                // Add warm (orangish/yellowish) tint to highlights
                r_final += highlight_influence * warmHighlightAmount;
                g_final += highlight_influence * warmHighlightAmount * 0.7; // Make it yellowish-orange
                b_final -= highlight_influence * warmHighlightAmount * 0.3; // Reduce blue slightly
            }
        }

        // 4. Clamp values
        data[i]   = Math.max(0, Math.min(255, Math.round(r_final)));
        data[i+1] = Math.max(0, Math.min(255, Math.round(g_final)));
        data[i+2] = Math.max(0, Math.min(255, Math.round(b_final)));
        data[i+3] = alpha; // Preserve original alpha
    }

    ctx.putImageData(imageData, 0, 0);
    return canvas;
}