tests/rsSupportMode/src/main/rs/wbalance.rs

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "ip.rsh"
//#pragma rs_fp_relaxed

static int histR[256] = {0}, histG[256] = {0}, histB[256] = {0};

rs_allocation histogramSource;
uint32_t histogramHeight;
uint32_t histogramWidth;

static float scaleR;
static float scaleG;
static float scaleB;

static uchar4 estimateWhite() {

    for (int i = 0; i < 256; i++) {
        histR[i] = 0; histG[i] = 0; histB[i] = 0;
    }

    for (uint32_t i = 0; i < histogramHeight; i++) {
        for (uint32_t j = 0; j < histogramWidth; j++) {
            uchar4 in = rsGetElementAt_uchar4(histogramSource, j, i);
            histR[in.r]++;
            histG[in.g]++;
            histB[in.b]++;
        }
    }

    int min_r = -1, min_g = -1, min_b = -1;
    int max_r =  0, max_g =  0, max_b =  0;
    int sum_r =  0, sum_g =  0, sum_b =  0;

    for (int i = 1; i < 255; i++) {
        int r = histR[i];
        int g = histG[i];
        int b = histB[i];
        sum_r += r;
        sum_g += g;
        sum_b += b;

        if (r>0){
            if (min_r < 0) min_r = i;
            max_r = i;
        }
        if (g>0){
            if (min_g < 0) min_g = i;
            max_g = i;
        }
        if (b>0){
            if (min_b < 0) min_b = i;
            max_b = i;
        }
    }

    int sum15r = 0, sum15g = 0, sum15b = 0;
    int count15r = 0, count15g = 0, count15b = 0;
    int tmp_r = 0, tmp_g = 0, tmp_b = 0;

    for (int i = 254; i >0; i--) {
        int r = histR[i];
        int g = histG[i];
        int b = histB[i];
        tmp_r += r;
        tmp_g += g;
        tmp_b += b;

        if ((tmp_r > sum_r/20) && (tmp_r < sum_r/5)) {
            sum15r += r*i;
            count15r += r;
        }
        if ((tmp_g > sum_g/20) && (tmp_g < sum_g/5)) {
            sum15g += g*i;
            count15g += g;
        }
        if ((tmp_b > sum_b/20) && (tmp_b < sum_b/5)) {
            sum15b += b*i;
            count15b += b;
        }

    }

    uchar4 out;

    if ((count15r>0) && (count15g>0) && (count15b>0) ){
        out.r = sum15r/count15r;
        out.g = sum15g/count15g;
        out.b = sum15b/count15b;
    }else {
        out.r = out.g = out.b = 255;
    }

    return out;

}

void prepareWhiteBalance() {
    uchar4 estimation = estimateWhite();
    int minimum = min(estimation.r, min(estimation.g, estimation.b));
    int maximum = max(estimation.r, max(estimation.g, estimation.b));
    float avg = (minimum + maximum) / 2.f;

    scaleR =  avg/estimation.r;
    scaleG =  avg/estimation.g;
    scaleB =  avg/estimation.b;

}

static unsigned char contrastClamp(int c)
{
    int N = 255;
    c &= ~(c >> 31);
    c -= N;
    c &= (c >> 31);
    c += N;
    return  (unsigned char) c;
}

void whiteBalanceKernel(const uchar4 *in, uchar4 *out) {
    float Rc =  in->r*scaleR;
    float Gc =  in->g*scaleG;
    float Bc =  in->b*scaleB;

    out->r = contrastClamp(Rc);
    out->g = contrastClamp(Gc);
    out->b = contrastClamp(Bc);
}