Unrecognizable TV Channel Image Generator

function processImage(originalImg, noiseIntensity = 0.75, rgbShift = 10, glitchBands = 8) {
    // Typecast parameters to numbers to handle potential string inputs gracefully
    noiseIntensity = Number(noiseIntensity);
    rgbShift = Number(rgbShift);
    glitchBands = Number(glitchBands);

    const canvas = document.createElement('canvas');
    const width = originalImg.width;
    const height = originalImg.height;
    canvas.width = width;
    canvas.height = height;
    
    // Draw the original image onto the canvas
    const ctx = canvas.getContext('2d');
    ctx.drawImage(originalImg, 0, 0);
    
    // Extract pixel data
    const imgData = ctx.getImageData(0, 0, width, height);
    const data = imgData.data;
    const outputData = new Uint8ClampedArray(data.length);

    // Generate random horizontal glitch bands to simulate lost tracking
    const glitches = [];
    for (let i = 0; i < glitchBands; i++) {
        let yStart = Math.floor(Math.random() * height);
        let h = Math.floor(Math.random() * (height * 0.15)); // Glitch covers up to 15% height max
        glitches.push({
            minY: yStart,
            maxY: yStart + h,
            shift: Math.floor((Math.random() - 0.5) * (width * 0.3)) // Random horizontal offset limit
        });
    }

    const width4 = width * 4;
    
    // Process pixel-by-pixel
    for (let y = 0; y < height; y++) {
        let currentShift = 0;
        
        // Apply shift from random glitch bands
        for (let i = 0; i < glitches.length; i++) {
            let g = glitches[i];
            if (y >= g.minY && y <= g.maxY) {
                currentShift = g.shift;
                break; // Only apply the first intersecting glitch for overlapping bands
            }
        }

        // Add wavy analog tracking distortion (rolling sine wave type offset)
        currentShift += Math.floor(Math.sin(y * 0.03) * 8);

        // Add VHS-style VCR head switching noise heavily at the bottom 5% of the frame
        if (y > height * 0.95) {
            currentShift += Math.floor((Math.random() - 0.5) * (width * 0.05));
        }

        for (let x = 0; x < width; x++) {
            // Calculate coordinates for RGB separation (chromatic aberration)
            let rX = (x + currentShift + rgbShift) % width;
            let gX = (x + currentShift) % width;
            let bX = (x + currentShift - rgbShift) % width;

            // Handle JavaScript's negative modulo result for wrapping correctly
            if (rX < 0) rX += width;
            if (gX < 0) gX += width;
            if (bX < 0) bX += width;

            const rIdx = y * width4 + rX * 4;
            const gIdx = y * width4 + gX * 4;
            const bIdx = y * width4 + bX * 4;
            const outIdx = y * width4 + x * 4;

            let r = data[rIdx];
            let g = data[gIdx + 1];
            let b = data[bIdx + 2];
            let a = data[gIdx + 3];

            // Mix the pixel with TV static 'snow'
            const noise = Math.random() * 255;
            r = r * (1 - noiseIntensity) + noise * noiseIntensity;
            g = g * (1 - noiseIntensity) + noise * noiseIntensity;
            b = b * (1 - noiseIntensity) + noise * noiseIntensity;

            // Desaturate slightly to mimic a weak/unrecognizable color signal
            const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
            const desat = 0.5;
            r = r * (1 - desat) + luminance * desat;
            g = g * (1 - desat) + luminance * desat;
            b = b * (1 - desat) + luminance * desat;

            // Apply CRT scanlines effect (darken alternating lines)
            if (y % 2 === 0) {
                r *= 0.7;
                g *= 0.7;
                b *= 0.7;
            }

            // Assign computed values to the output
            outputData[outIdx] = r;
            outputData[outIdx + 1] = g;
            outputData[outIdx + 2] = b;
            outputData[outIdx + 3] = a;
        }
    }

    // Overwrite the original pixel data with our distorted output
    imgData.data.set(outputData);
    ctx.putImageData(imgData, 0, 0);

    return canvas;
}