apps/autoexp/autoexp.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <sys/mman.h>

#include <asm/elphel/hist.h>
#include <asm/elphel/autoexp.h>
#include <asm/elphel/c313a.h>
#include <syslog.h>

#define MAX_OVEREXP     5000    /* 50% */
#define MAX_WIDTH       100
#define MAX_HEIGHT      100
#define MIN_WIDTH       5
#define MIN_HEIGHT      5
#define MAX_LEFT        100
#define MAX_TOP         100
#define MAX_S_INDEX     255
#define MAX_S_PERCENT   10000

#define PMAX_MAX        9000
#define PMAX_MIN        5000

struct autoexp_t state = {
        .s_index = 0,
        .s_percent = 0,
        .exp = 100,
        .skip_pmin = 500,
        .skip_pmax = 5000,
        .skip_t = 2,
};


struct autoexp_t autoexp_set;
struct autoexp_log_t autoexp_log;

/* start exposure value */
//unsigned long current_exp = 100;

#define HIST_SIZE       (256 * 4 * 4 + 256 * 2)
unsigned short *gamma;

float hist_analyze(unsigned long *t, unsigned long sq);
float hist_analyze_percent(unsigned long *t, unsigned long sq);
void hist_stat();

int skip_first_frames = 0;

int main(void) {
        int fd;
        void *map;
//      int i, j;
        unsigned long *m;
//      unsigned long s;
        unsigned long sq;
        float d;
        float s;
        int r;
        struct autoexp_t autoexp_buf;
        int flag = 0;

float pmin_low = state.skip_pmin;
        pmin_low /= 100.0;
        pmin_low /= 100.0;
float pmin_high = 1.0 + pmin_low;
        pmin_low = 1.0 - pmin_low;
float d_prev = 0;
//float t_skip = state.skip_t;
int prev_change_max = 0;
int stable_flag = 0;
int f = 0;
float pmax_low = state.skip_pmax;
        pmax_low /= 100.0;
        pmax_low /= 100.0;
float pmax_high = 1.0 + pmax_low;
        pmax_low = 1.0 - pmax_low;
int prev_perc_min = 0;

openlog("autoexp", 0, 0);

        fd = open(DEV_HIST_NAME, O_RDWR);
        if(fd <= 0) {
                printf("Aiee! can't open %s - may be device busy or not exist...\r\n", DEV_HIST_NAME);
                return -1;
        }

        /* process cycle */
        while(1) {
                r = ioctl(fd, _IO(IOC_HIST_GET, 0x00), &autoexp_buf);
                if(r == REZ_HIST_CONF) {
//syslog(LOG_ALERT, "REZ_HIST_CONF\r\n");
                        if(autoexp_buf.exp_max != HIST_NOT_CHANGE) {
                                state.exp_max = autoexp_buf.exp_max;
//printf("HIST_CONF: state.exp_max = %lu\r\n", state.exp_max);
                        }
                        if(autoexp_buf.overexp_max != HIST_NOT_CHANGE) {
                                state.overexp_max = autoexp_buf.overexp_max;
                                if(state.overexp_max > MAX_OVEREXP)
                                        state.overexp_max = MAX_OVEREXP;
                        }
                        if(autoexp_buf.s_index != HIST_NOT_CHANGE) {
                                state.s_index = autoexp_buf.s_index;
                                if(state.s_index > MAX_S_INDEX)
                                        state.s_index = MAX_S_INDEX;
//syslog(LOG_ALERT, "state.s_index == %d\r\n", state.s_index);
                        }
                        if(autoexp_buf.s_percent != HIST_NOT_CHANGE) {
                                state.s_percent = autoexp_buf.s_percent;
                                if(state.s_percent > MAX_S_PERCENT)
                                        state.s_percent = MAX_S_PERCENT;
//syslog(LOG_ALERT, "state.s_percent == %d\r\n", state.s_percent);
                        }
                        if(autoexp_buf.skip_pmin != HIST_NOT_CHANGE) {
                                state.skip_pmin = autoexp_buf.skip_pmin;
//syslog(LOG_ALERT, "state.skip_pmin == %d\r\n", state.skip_pmin);
                                pmin_low = state.skip_pmin;
                                pmin_low /= 100.0;
                                pmin_low /= 100.0;
                                pmin_high = 1.0 + pmin_low;
                                pmin_low = 1.0 - pmin_low;
                        }
                        if(autoexp_buf.skip_pmax != HIST_NOT_CHANGE) {
                                state.skip_pmax = autoexp_buf.skip_pmax;
                                if(state.skip_pmax > PMAX_MAX)
                                        state.skip_pmax = PMAX_MAX;
                                if(state.skip_pmax < PMAX_MIN)
                                        state.skip_pmax = PMAX_MIN;
//syslog(LOG_ALERT, "state.skip_pmax == %d\r\n", state.skip_pmax);
                                pmax_low = state.skip_pmax;
                                pmax_low /= 100.0;
                                pmax_low /= 100.0;
                                pmax_high = 1.0 + pmax_low;
                                pmax_low = 1.0 - pmax_low;
                        }
                        if(autoexp_buf.skip_t != HIST_NOT_CHANGE) {
                                state.skip_t = autoexp_buf.skip_t;
//syslog(LOG_ALERT, "state.skip_t == %d\r\n", state.skip_t);
                        }
                        if(autoexp_buf.width != HIST_NOT_CHANGE) {
                                state.width = autoexp_buf.width;
                                if(state.width > MAX_WIDTH)
                                        state.width = MAX_WIDTH;
                                if(state.width < MIN_WIDTH)
                                        state.width = MIN_WIDTH;
                                flag = 1;
                        }
                        if(autoexp_buf.height != HIST_NOT_CHANGE) {
                                state.height= autoexp_buf.height;
                                if(state.height > MAX_HEIGHT)
                                        state.height = MAX_HEIGHT;
                                if(state.height < MIN_HEIGHT)
                                        state.height = MIN_HEIGHT;
                                flag = 1;
                        }
                        if(autoexp_buf.left != HIST_NOT_CHANGE) {
                                state.left= autoexp_buf.left;
                                if(state.left > MAX_LEFT)
                                        state.left = MAX_LEFT;
                                flag = 1;
                        }
                        if(autoexp_buf.top != HIST_NOT_CHANGE) {
                                state.top= autoexp_buf.top;
                                if(state.top > MAX_TOP)
                                        state.top = MAX_TOP;
                                flag = 1;
                        }
                        if(flag) {
                                flag = 0;
                                autoexp_set.width = state.width;
                                autoexp_set.height = state.height;
                                autoexp_set.left = state.left;
                                autoexp_set.top = state.top;
                                autoexp_set.exp = 0;
                                
                                ioctl(fd, _IO(IOC_HIST_SET, 0x00), &autoexp_set);
                        }
                        continue;
                }
                /* analyze histogramm */
                map = mmap(NULL, TABLES_LEN, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, fd, 0);
                gamma = (unsigned short *)(map + 256 * 4 * 4);
//syslog(LOG_ALERT, "HIST_SIZE == %d; 0 == 0x%04X, 1 == 0x%04X, 254 == 0x%04X, 255 == 0x%04X\r\n", HIST_SIZE, gamma[0], gamma[1], gamma[254], gamma[255]);
//syslog(LOG_ALERT, "map == 0x%08X, gamma == 0x%08X\r\n", map, gamma);
                m = (unsigned long *)map;
                /* summ of all 4 tables... */
//              sq = autoexp_buf.width * autoexp_buf.height;
//              sq = autoexp_set.width * autoexp_set.height;
                sq = state.width * state.height;
//              if(autoexp_buf.exp != HIST_NOT_CHANGE)
//                      state.exp = autoexp_buf.exp;
//printf("width == %lu\r\n", autoexp_buf.width);
//printf("height == %lu\r\n", autoexp_buf.height);
                if(sq == 0) {
                        munmap(map, HIST_SIZE);
                        continue;
                }
                if(state.s_index == 0 || state.s_percent == 0)
                        d = hist_analyze(m, sq);
                else
                        d = hist_analyze_percent(m, sq);
                munmap(map, HIST_SIZE);
                s = d;
                flag = 0;
                if(d == 1.0) {
                        d = state.exp;
//                      if(state.exp > state.exp_max) {
                        if(d > state.exp_max) {
//                              state.exp = autoexp_set.exp = state.exp_max;
                                d = state.exp_max;
                                flag = 1;
                        }
                } else {
                        flag = 1;
                        d *= state.exp;
                        if(d > state.exp_max)
                                d = state.exp_max;
                        if(d < 1)
                                d = 1;
//                      state.exp = autoexp_set.exp = d;
                }
                /* send log message in driver */
                if(flag == 1) {
                        if(state.s_index != 0 && state.s_percent != 0) {
//                              stable_flag = 1;
                                /* check percent delta */
                                f = 0;
                                if(s <= pmin_high && s >= pmin_low) {
                                        if(prev_perc_min)
                                                f = 0;
                                        else
                                                f = 1;
                                        prev_perc_min = 1;
                                } else {
                                        prev_perc_min = 0;
                                        f = 1;
                                }
//                              if(s > pmin_high || s < pmin_low) {
                                if(f) {
                                        /* check value delta */
                                        if(abs(d_prev - d) > state.skip_t) {
//                                              f = 0;
                                                /* check max step */
                                                if(s > pmax_high || s < pmax_low) {
                                                        if(prev_change_max) {
                                                                f = 1;
                                                        } else {
                                                                f = 0;
                                                        }
                                                        prev_change_max = 1;
                                                } else {
                                                        f = 1;
                                                        prev_change_max = 0;
                                                }
                                                if(f) {
                                                        stable_flag = 0;
                                                        d_prev = d;
                                                        state.exp = autoexp_set.exp = d;
                                                        ioctl(fd, _IO(IOC_HIST_SET, 0x00), &autoexp_set);
                                                        autoexp_log.s_index = state.s_index;
                                                        autoexp_log.s_percent = state.s_percent;
                                                        autoexp_log.t_scale = s * 0x10000;
                                                        autoexp_log.t_value = state.exp;
                                                        ioctl(fd, _IO(IOC_HIST_SET_LOG, 0x00), &autoexp_log);
                                                } else {
                                                        stable_flag = 1;
                                                }
                                        }
                                }
                        } else {
                                d_prev = d;
                                state.exp = autoexp_set.exp = d;
                                ioctl(fd, _IO(IOC_HIST_SET, 0x00), &autoexp_set);
                        }
                }
                /* set changes */
        }

        close(fd);
        return 0;
}

static unsigned long inline _sum(unsigned long *t, int i) {
        return (t[i + 256 * 0] + t[i + 256 * 1] + t[i + 256 * 2] + t[i + 256 * 3]);
}

float normalize_gamma(int indx) {
        float r = 255.0;
        unsigned short g;
        int low;
        low = gamma[0] >> 8;

        g = gamma[indx];
        r = g & 0xFF;
        r /= 256.0;
        r += g >> 8;
        r -= low;
        r *= 256.0 / (256.0 - (float)low);
        return r;
//      return indx;
}

float hist_analyze(unsigned long *t, unsigned long sq) {
        unsigned long s = 0;
        float r = 1.0;
        int i;
        float over;
        unsigned long l_255;
        unsigned long s_255;
        unsigned long s_254;
        unsigned long s_253;
        unsigned long sc;
        int flag;

        sq = 0;
        for(i = 0; i < 1024; i++) {
                sq += t[i];
        }
        /* normalize */
        over = state.overexp_max;
        over /= 100.0;
        over /= 100.0;
        over *= sq;
        l_255 = over;
        
        s_255 = _sum(t, 255);
        s_254 = _sum(t, 254) + s_255;
        s_253 = _sum(t, 253) + s_254;
        
        r = 1.0;
        if(s_255 >= l_255) {
                // overexposure...
                r = s_255;
                r /= (l_255 / 8);
                r = (255.0 - r) / 255.0;
                if(r < 0.5)
                        r = 0.5;
                goto out;
        }
        if(s_254 < l_255) {
                sc = 0;
                flag = 0;
                for(i = 255; i > 120; i--) {
                        s = _sum(t, i);
                        sc += s;
                        if(sc >= l_255) {
                                flag = 1;
                                r = normalize_gamma(i + 1);
//                              r = 254.0 / r;
                                r = 252.0 / r;
                                if(r < 1.0)
                                        r = 1.0;
                                break;
                        }
                }
                if(flag == 0)
                        r = 2.0;
                if(r <= 1.02 && r > 1.0)
                        r = 1.0;
        }
out:
//syslog(LOG_ALERT, "r = %.2f\r\n", r);
        return r;
}

float hist_analyze_percent(unsigned long *t, unsigned long sq) {
        unsigned long h[256];
        unsigned long long s;
        unsigned short *g;
        unsigned long value;
        float v;
        float p, _p;
        int i, j = 0;
        float r = 1.0;
//      static int c = 0;

        p = state.s_percent;
        p /= 100.0;
//      g = (unsigned short *)((void *)t + 256 * 4 * 4 + 256 * 4 * 2);
        g = (unsigned short *)((void *)t + 256 * 4 * 4);
        h[0] = t[0] + t[256] + t[512] + t[768];
        for(i = 1; i < 256; i++) {
                h[i] = h[i - 1] + t[i] + t[i + 256] + t[i + 512] + t[i + 768];
        }
        s = h[255];
//      i = g[state.s_index + 256] >> 8;
        i = g[state.s_index + 256] >> 8;
        v = h[i];
        v /= s;
        v *= 100.0; // current percent in interesting index
        _p = p;
        _p /= 100.0;
        _p *= s;
        value = _p; // needed sum in "ideal" index
//      i = g[state.s_index + 256] >> 8;
//if(c < 20)
//      syslog(LOG_ALERT, "in index (%d): v == %.2f, p == %.2f\r\n", i, v, p);
        autoexp_log.n_index = i;
        autoexp_log.n_percent = v * 100;
        if(v > p) {
                /* set up */
                for(j = 8; j < i; j++) {
                        if(h[j] >= value) {
                                r = g[j] & 0xFF;
                                r /= 256.0;
                                r += (g[j] >> 8);
                                r = ((float)state.s_index) / r;
                                autoexp_log.n_index = g[j] >> 8;
                                _p = h[j];
                                _p *= 100;
                                _p /= s;
                                _p *= 100;
                                autoexp_log.n_percent = _p;
//                              return r;
                                
                                goto ret;
                        }
                }
                r = 1.0;
        } else {
                /* set down */
                if(h[254] > value) {
                        /* find index and set it */
                        for(j = 254; j > i; j--) {
                                if(h[j] <= value) {
                                        r = g[j] & 0xFF;
                                        r /= 256.0;
                                        r += (g[j] >> 8);
                                        /* log data */
                                        autoexp_log.n_index = g[j] >> 8;
                                        _p = h[j];
                                        _p *= 100;
                                        _p /= s;
                                        _p *= 100;
                                        autoexp_log.n_percent = _p;
                                        r = ((float)state.s_index) / r;
                                        goto ret;
                                }
                        }
                        r = 1.0;
                } else {
                        autoexp_log.n_index = 255;
                        autoexp_log.n_percent = 10000;
                        r = v / p;
                }
        }

ret:
/*
        c++;
        if(c < 20)
                syslog(LOG_ALERT, "in index: v == %.2f, ret == %.2f\r\n", v, r);
        else
                c = 25;
*/
//      if(r != 1.0) {
//              syslog(LOG_ALERT, "in index: v == %.2f, p == %.2f, ret == %.2f, value == %d, h[%d] == %d, h[254] == %d\r\n", v, p, r, value, j, h[j], h[254]);
//      }
        if(r < 0.05)
                r = 0.05;
        return r;
}

---