The Sinclair QL Forum

Code: Select all

unsigned short RGB8ToQLiFS(unsigned int RGB8, int x, int y) {
    char r, b, g, newR, newG, newB;
    short rCorr, bCorr, gCorr;
    int newCol;

    static colourCorr nextLinCorr [259], thisLinCorr [259];
    //static colourCorr nextPixCorr;
    static colourCorr *oldErrors;
    static colourCorr *newErrors;

    if ((x > 250) || (x < 0)) return 0;
    if ((y > 250) || (y < 0)) return 0;

    // Initialize if we start a new picture
    if ((x == 0) && (y == 0)) {
        memset (nextLinCorr, 0, sizeof (nextLinCorr));
        memset (thisLinCorr, 0, sizeof (thisLinCorr));
        oldErrors = &(nextLinCorr [1]); // Catches out of bounds at start and end of a line
        newErrors = &(thisLinCorr [1]);
    } else if (x == 0) // Initialize if we start a new line (alternate the two arrays)
    {
        colourCorr *tmp = oldErrors;
        oldErrors = newErrors;
        newErrors = tmp;
        memset(newErrors - sizeof (colourCorr), 0, sizeof(nextLinCorr)); // clear new
        //memset(&nextPixCorr, 0, sizeof (colourCorr));
    }

    // Convert color parts to 0-7
    r = (((RGB8 & red_mask)) >> red_shift);
    g = (((RGB8 & green_mask)) >> green_shift);
    b = (RGB8 & blue_mask);

    // Add the correction values
    r += (oldErrors [x + 1].RCorr / 16);
    g += (oldErrors [x + 1].GCorr / 16);
    b += (oldErrors [x + 1].BCorr / 16);

    // Now find the colour errors (in original colour space) that occur when we map the colour values
    newR = (r > 3) ? 7 : 0; 
    newG = (g > 3) ? 7 : 0; 
    newB = (b > 3) ? 7 : 0; 

    rCorr = r - newR; 
    gCorr = g - newG;
    bCorr = b - newB;

    //printf ()

    // And apply the correction Values to the correction array
    // (note correction array is shifted one to the right!)
    oldErrors [x + 2].RCorr += 7 * rCorr;
    newErrors [x + 2].RCorr += 1 * rCorr;
    newErrors [x + 1].RCorr += 5 * rCorr;
    newErrors [x + 0].RCorr += 3 * rCorr;
    oldErrors [x + 2].GCorr += 7 * gCorr;
    newErrors [x + 2].GCorr += 1 * gCorr;
    newErrors [x + 1].GCorr += 5 * gCorr;
    newErrors [x + 0].GCorr += 3 * gCorr;
    oldErrors [x + 2].BCorr += 7 * bCorr;
    newErrors [x + 2].BCorr += 1 * bCorr;
    newErrors [x + 1].BCorr += 5 * bCorr;
    newErrors [x + 0].BCorr += 3 * bCorr;

    // simply fumble the three bits into one number 0-7
    return (((newB != 0)) | ((newR != 0) << 1) | ((newG != 0) << 2));
}