A>int hueFromRGB(char r,char g,char b);
A>int saturationFromRGB(char r,char g,char b);
A>int lightnessFromRGB(char r,char g,char b);
A>

A>char redFromHSL(int h,int s,int l);
A>char greenFromHSL(int h,int s,int l);
A>char blueFromHSL(int h,int s,int l);
A>

const int hlsmax   = 252;            // best if divisible by 6
const int rgbmax   = 255;
const BYTE undefhue = BYTE(hlsmax * 2 / 3);    // hue is undefined if saturation izs zero

static
int
__fastcall
normby(
    int value,
    int norm
    )
{
    return (value + norm / 2) / norm;
}

static
int
__stdcall
huetorgb(
    int p1,
    int p2,
    int hue
    )
{
    if (hue < 0)
        hue += hlsmax;
    if (hue > hlsmax)
        hue -= hlsmax;
 
    if (hue < hlsmax / 6)
        return p1 + normby((p2 - p1) * hue, hlsmax / 6);
    if (hue < hlsmax / 2)
        return p2;
    if (hue < 2 * hlsmax / 3)
        return p1 + normby((p2 - p1) * (2 * hlsmax / 3 - hue), hlsmax / 6);

    return p1;
}

void 
__stdcall
rgbtohls(
    IN COLORREF rgb,
    OUT BYTE * ph,
    OUT BYTE * pl,
    OUT BYTE * ps
    )
{
    _ASSERTE(_CrtIsValidPointer(ph, sizeof(BYTE), 1));
    _ASSERTE(_CrtIsValidPointer(pl, sizeof(BYTE), 1));
    _ASSERTE(_CrtIsValidPointer(ps, sizeof(BYTE), 1));

    int h, l, s;

    // unpack R, G and B coordinates
    int r = GetRValue(rgb);
    int g = GetGValue(rgb);
    int b = GetBValue(rgb);

    // calculate luminance
    int mx = max(max(r, g), b);
    int mn = min(min(r, g), b);
    
    int ms = mx + mn;
    int md = mx - mn;

    l = normby(ms * hlsmax, 2 * rgbmax);

    if (md == 0)
    {
        // achromatic case
        s = 0;
        h = undefhue;
    }
    else
    {
        // saturation
        s = normby(md * hlsmax, (l <= hlsmax / 2) ? ms : 2 * rgbmax - ms);

        // hue
        int rd = normby((mx - r) * (hlsmax / 6), md);
        int gd = normby((mx - g) * (hlsmax / 6), md);
        int bd = normby((mx - b) * (hlsmax / 6), md);
    
        if (r == mx)
            h = bd - gd;
        else if (g == mx)
            h = hlsmax / 3 + rd - bd;
        else
            h = 2 * hlsmax / 3 + gd - rd;

        if (h < 0)
            h += hlsmax;
        if (h > hlsmax)
            h -= hlsmax;
    }

    *ph = (BYTE)h;
    *pl = (BYTE)l;
    *ps = (BYTE)s;
}
 
COLORREF
__stdcall
hlstorgb(
    IN BYTE h,
    IN BYTE l,
    IN BYTE s
    )
{
    int r, g, b;

    if (s == 0)
    {
        // achromatic case
        r = g = b = l * rgbmax / hlsmax;
    }
    else
    {
        int p2 = (l <= hlsmax / 2) ? normby(l * (hlsmax + s), hlsmax)
                                   : l + s - normby(l * s, hlsmax);
        int p1 = 2 * l - p2;

        r = normby(huetorgb(p1, p2, h + hlsmax/3) * rgbmax, hlsmax);
        g = normby(huetorgb(p1, p2, h) * rgbmax, hlsmax);
        b = normby(huetorgb(p1, p2, h - hlsmax/3) * rgbmax, hlsmax);
    }
 
    return RGB(r, g, b);
}

int hueFromRGB(char r,char g,char b);
int saturationFromRGB(char r,char g,char b);
int lightnessFromRGB(char r,char g,char b);

char redFromHSL(int h,int s,int l);
char greenFromHSL(int h,int s,int l);
char blueFromHSL(int h,int s,int l);