apps/autoexp/autoexpos.cgi.c

Go to the documentation of this file.

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

//#include "autoexpos.h"
#include <asm/elphel/autoexp.h>
#include <asm/elphel/c313a.h>


#define AE_DEVICE AUTOEXP_DEV_NAME
#define QRY_MAXPARAMS 64

char  copyQuery [4096];
const char *uri;
const char *method;
const char *query;
int driver;
struct autoexp_t aestate;
int erroroper;

struct key_value {
        char *key;
        char *value;
};

struct key_value gparams[QRY_MAXPARAMS+1];

int unescape(char *, int);
int hexdigit(char);
char * paramValue(struct key_value *, char *);
int parseQuery(struct key_value *, char *);
void makeXML(void);
void setAEParams(void);
void getAEParams(void);
void fillAEStruct(void);

int i_val = -1;
static unsigned long rval = 0;
static unsigned long gval = 0;
static unsigned long bval = 0;
static unsigned long rval_or = 0;
static unsigned long gval_or = 0;
static unsigned long bval_or = 0;
int i_perc = -1;
static unsigned long rperc = 0;
static unsigned long gperc = 0;
static unsigned long bperc = 0;
static unsigned long rperc_or = 0;
static unsigned long gperc_or = 0;
static unsigned long bperc_or = 0;
static unsigned long rall = 0;
static unsigned long gall = 0;
static unsigned long ball = 0;

static struct autoexp_log_t ae_log_b[LOG_C];
static int ae_log_c = 0;

int main (int argc, char *argv[]) {
        int i;
        struct stat buf;
        void *_map;
        char *_index;
        unsigned long *_h;
        unsigned short *_g;
//      int _query = 0;
   char * _query = 0;

        method = getenv("REQUEST_METHOD");
        _query = getenv("QUERY_STRING");
        uri = getenv("REQUEST_URI");

        i = (_query) ? strlen (_query) : 0;
//      fprintf(stderr,"querry length=%d\n", i);

        if(i > (sizeof(copyQuery) - 1))
                i = sizeof(copyQuery) - 1;
        if(i > 0)
                strncpy(copyQuery, _query, i);
        copyQuery[i] = 0;
        unescape(copyQuery, sizeof(copyQuery));

        if(method == NULL) {
                /* Not a CGI! */
                printf("This program should be run as a CGI from the web server!\n");
                exit(1);
        }

        parseQuery(gparams, copyQuery);
        fillAEStruct();
        if(stat(AE_DEVICE, &buf) == -1)
                driver = -1;
        else {
                driver = open(AE_DEVICE, O_RDWR);
                if(driver) {
                        if(atoi(paramValue(gparams, "reg")) == 1)
                                setAEParams();
                        else
                                getAEParams();
                        /* try for analyze histogramm... */
                        if((_index = paramValue(gparams, "ival")) != NULL) {
                                i_val = atoi(_index);
                                if(i_val < 0)
                                        i_val = 0;
                                if(i_val > 255)
                                        i_val = 255;
                        }
                        if((_index = paramValue(gparams, "iperc")) != NULL) {
                                i_perc = atoi(_index);
                                if(i_perc < 0)
                                        i_perc = 0;
                                if(i_perc > 255)
                                        i_perc = 255;
                        }
                        if((_index = paramValue(gparams, "log")) != NULL) {
                                ae_log_c = atoi(_index);
                                if(ae_log_c > 0) {
                                        if(ae_log_c > LOG_C)
                                                ae_log_c = LOG_C;
                                        if((ae_log_c = ioctl(driver, _IO(IOC_AUTOEXP_GET_LOG, ae_log_c & 0xFF), (void *)&ae_log_b)) < 0)
                                                ae_log_c = -1;
                                } else {
                                        ae_log_c = 0;
                                }
                        }
                        if(_query != 0) {
                                if((_map = mmap(NULL, TABLES_LEN, PROT_READ, MAP_FIXED | MAP_SHARED, driver, 0)) != MAP_FAILED) {
                                        _h = (unsigned long *)_map;
                                        _g = (unsigned short *)(_map + 256 * 4 * 4 + 256 * 4 * 2 + 256 * 2);
                                        if(i_val != -1) {
                                                rval = _h[i_val];
                                                gval = _h[i_val + 256] + _h[i_val + 512];
                                                gval /= 2;
                                                bval = _h[i_val + 768];
                                                i_val = _g[i_val] >> 8;
                                                rval_or = _h[i_val];
                                                gval_or = _h[i_val + 256] + _h[i_val + 512];
                                                gval_or /= 2;
                                                bval_or = _h[i_val + 768];
                                        }
                                        if(i_perc != -1) {
                                                for(i = 0; i < 256; i++) {
                                                        rall += _h[i];
                                                        gall += _h[i + 256] + _h[i + 512];
                                                        ball += _h[i + 768];
                                                        if(i <= i_perc) {
                                                                rperc += _h[i];
                                                                gperc += _h[i + 256] + _h[i + 512];
                                                                bperc += _h[i + 768];
                                                        }
                                                }
                                                gperc /= 2;
                                                gall /= 2;
                                                i_perc = _g[i_perc] >> 8;
                                                for(i = 0; i <= i_perc; i++) {
                                                        rperc_or += _h[i];
                                                        gperc_or += _h[i + 256] + _h[i + 512];
                                                        bperc_or += _h[i + 768];
                                                }
                                                gperc_or /= 2;
                                        }
                                        munmap(_map, TABLES_LEN);
                                }
                                /* check for log */
                        }
                        /* --==-- */
                        close(driver);
                }
        }
        makeXML();

//  exit(0);
        return 0;
}

int unescape (char * s, int l) {
  int i=0;
  int j=0;
  while ((i<l) && s[i]) {
    if ((s[i]=='%') && (i<(l-2)) && s[i+1]){ // behavior from Mozilla
      s[j++]=(hexdigit(s[i+1])<<4) | hexdigit(s[i+2]);
      i+=3;
    } else s[j++]=s[i++];
  }
  if (i<l) s[j]=0;
  return j;
}

int hexdigit (char c) {
  int i;
  i=c-'0';
  if ((i>=0) && (i<10)) return i;
  i=c-'a'+10;
  if ((i>=10) && (i<16)) return i;
  i=c-'A'+10;
  if ((i>=10) && (i<16)) return i;
  return 0;     // could be -1??
}

char * paramValue(struct key_value * params, char * skey) { // returns pointer to parameter value, NULL if not defined
  int i=0;
  if (skey)
   while ((i<QRY_MAXPARAMS) && (params[i].key)) {
    if (strcmp(skey,params[i].key)==0) return   params[i].value;

    i++;
   }
  return NULL;
}

int parseQuery(struct key_value * params, char * qry) {
  char * cp;
  int l=0;
  cp=strtok(qry,"=");
  while ((cp) && (l<QRY_MAXPARAMS)) {
    params[l].key=cp;
    cp=strtok(NULL,"&");
    params[l++].value=cp;
    if (cp) cp=strtok(NULL,"=");
  }
 params[l].key=NULL;
 return l;
}

void makeXML() {
        int i;

  printf("%s","Content-Type: text/xml\n");
  printf("%s","Pragma: no-cache\n\n"); // 2 new lines!
  printf("%s\n", "<?xml version='1.0' encoding='ISO8859-1'?>");
  printf("%s\n", "<AUTOEXPOSURESETTINGS>");
  printf("\t<DRIVERPRESENT>%i</DRIVERPRESENT>\n", (driver==-1 ? 0 : 1));
  printf("\t<ERROR>%i</ERROR>\n", (erroroper==-1 ? 1 : 0));
  printf("\t<AEONOFF>%li</AEONOFF>\n", aestate.on);
  printf("\t<WIDTH>%li</WIDTH>\n", aestate.width);
  printf("\t<HEIGHT>%li</HEIGHT>\n", aestate.height);
  printf("\t<LEFT>%li</LEFT>\n", aestate.left);
  printf("\t<TOP>%li</TOP>\n", aestate.top);
  printf("\t<EXPMAX>%li</EXPMAX>\n", aestate.exp_max);
  printf("\t<EXPOSURE>%li</EXPOSURE>\n", aestate.exp);
  printf("\t<OVEREXPMAX>%li</OVEREXPMAX>\n", aestate.overexp_max);
  printf("\t<SKIP_PMIN>%.2f</SKIP_PMIN>\n", ((float)aestate.skip_pmin) / 100.0);
  printf("\t<SKIP_PMAX>%.2f</SKIP_PMAX>\n", ((float)aestate.skip_pmax) / 100.0);
  printf("\t<SKIP_T>%.1f</SKIP_T>\n", ((float)aestate.skip_t) / 10.0);
//  printf("\t<OVEREXP>%li</OVEREXP>\n", aestate.overexp);
  printf("\t<OVEREXP>%li</OVEREXP>\n", 0L);
        if(i_val != -1) {
                printf("\t<RVAL>%lu</RVAL>\n", rval);
                printf("\t<GVAL>%lu</GVAL>\n", gval);
                printf("\t<BVAL>%lu</BVAL>\n", bval);
                printf("\t<RVAL_OR>%lu</RVAL_OR>\n", rval_or);
                printf("\t<GVAL_OR>%lu</GVAL_OR>\n", gval_or);
                printf("\t<BVAL_OR>%lu</BVAL_OR>\n", bval_or);
        }
        if(i_perc != -1) {
                printf("\t<RPERC>%.2f</RPERC>\n", ((double)rperc * 100) / rall);
                printf("\t<GPERC>%.2f</GPERC>\n", ((double)gperc * 100) / gall);
                printf("\t<BPERC>%.2f</BPERC>\n", ((double)bperc * 100) / ball);
                printf("\t<RPERC_OR>%.2f</RPERC_OR>\n", ((double)rperc_or * 100) / rall);
                printf("\t<GPERC_OR>%.2f</GPERC_OR>\n", ((double)gperc_or * 100) / gall);
                printf("\t<BPERC_OR>%.2f</BPERC_OR>\n", ((double)bperc_or * 100) / ball);
        }
        printf("\t<PERCENT>%.2f</PERCENT>\n", ((double)aestate.s_percent) / 100.0);
        printf("\t<INDEX>%lu</INDEX>\n", aestate.s_index);
        if(ae_log_c > 0) {
                for(i = 0; i < ae_log_c; i++) {
                        printf("\t<LOG>time == %ld:%ld; t_value == %.1f; t_scale == %.2f; n_index == %ld; n_percent == %.2f, s_index == %ld, s_percent == %.2f</LOG>",
                                ae_log_b[i].tv_sec, ae_log_b[i].tv_usec, 
                                ((float)ae_log_b[i].t_value) / 10.0, ((float)ae_log_b[i].t_scale / 0x10000), 
                                ae_log_b[i].n_index, ((float)ae_log_b[i].n_percent) / 100.0,
                                ae_log_b[i].s_index, ((float)ae_log_b[i].s_percent) / 100.0);
                }
        }
        if(ae_log_c == -1)
                printf("\t<LOG>can't read log</LOG>\n");
  printf("%s\n", "</AUTOEXPOSURESETTINGS>");
}

void fillAEStruct() {
  char *prm;
        /* -==- */
        if((prm = paramValue(gparams, "onoff")) != NULL) {
                aestate.on = atol(prm);
                if(aestate.on != 1)
                        aestate.on = 0;
        }
        else
                aestate.on = HIST_NOT_CHANGE;
        /* -==- */
        if((prm = paramValue(gparams, "width")) != NULL) {
                aestate.width = atol(prm);
                if(aestate.width < 5)
                        aestate.width = 5;
                if(aestate.width > 100)
                        aestate.width = 100;
        }
        else
                aestate.width = HIST_NOT_CHANGE;
 // if(aestate.width<1 || aestate.width>100) aestate.width=32;
        /* -==- */
        if((prm = paramValue(gparams, "height")) != NULL) {
                aestate.height = atol(prm);
                if(aestate.height < 5)
                        aestate.height = 5;
                if(aestate.height > 100)
                        aestate.height = 100;
        }
        else
                aestate.height = HIST_NOT_CHANGE;
//  if(aestate.height<1 || aestate.height>100) aestate.height=32;
        /* -==- */
        if((prm = paramValue(gparams, "left")) != NULL) {
                aestate.left = atol(prm);
                if(aestate.left < 0)
                        aestate.left = 0;
                if(aestate.left > 100)
                        aestate.left = 100;
        }
        else
                aestate.left = HIST_NOT_CHANGE;
//  if(aestate.left<1 || aestate.left>100 || aestate.left+aestate.width>100)
//    aestate.left=(100-aestate.width)/2;
        /* -==- */
        if((prm = paramValue(gparams, "top")) != NULL) {
                aestate.top = atol(prm);
                if(aestate.top < 0)
                        aestate.top = 0;
                if(aestate.top > 100)
                        aestate.top = 100;
        }
        else
                aestate.top = HIST_NOT_CHANGE;
        /* -==- */
//  if(aestate.top<1 || aestate.top>100 || aestate.top+aestate.height>100)
//    aestate.top=(100-aestate.height)/2;
        if((prm = paramValue(gparams, "expmax")) != NULL) {
                aestate.exp_max = atol(prm);
                if(aestate.exp_max < 20)
                        aestate.exp_max = 20;
                if(aestate.exp_max > 100000)
                        aestate.exp_max = 100000;
        }
        else
                aestate.exp_max = HIST_NOT_CHANGE;
//  if(aestate.exp_max<1) aestate.exp_max=4000;
//  if(aestate.exp_max<1) aestate.exp_max=4000;
        /* -==- */
        if((prm = paramValue(gparams, "oemax")) != NULL) {
                aestate.overexp_max = atol(prm);
                if(aestate.overexp_max < 1)
                        aestate.overexp_max = 10;
                if(aestate.overexp_max > 2500)
                        aestate.overexp_max = 2500;
        }
        else
                aestate.overexp_max = HIST_NOT_CHANGE;
        /* --==-- */
        if((prm = paramValue(gparams, "percent")) != NULL) {
                aestate.s_percent = atof(prm) * 100;
                if(aestate.s_percent < 0)
                        aestate.s_percent = 0;
                if(aestate.s_percent > 10000)
                        aestate.s_percent = 10000;
        }
        else
                aestate.s_percent = HIST_NOT_CHANGE;
        /* --==-- */
        if((prm = paramValue(gparams, "index")) != NULL) {
                aestate.s_index = atol(prm);
                if(aestate.s_index < 0)
                        aestate.s_index = 0;
                if(aestate.s_index > 255)
                        aestate.s_index = 255;
        }
        else
                aestate.s_index = HIST_NOT_CHANGE;
        /* --==-- */
        if((prm = paramValue(gparams, "skip_pmin")) != NULL) {
                aestate.skip_pmin = atof(prm) * 100;
                if(aestate.skip_pmin < 0)
                        aestate.skip_pmin = 1;
                if(aestate.skip_pmin > 1000)
                        aestate.skip_pmin = 1000;
        }
        else
                aestate.skip_pmin = HIST_NOT_CHANGE;
        if((prm = paramValue(gparams, "skip_pmax")) != NULL) {
                aestate.skip_pmax = atof(prm) * 100;
                if(aestate.skip_pmax < 4000)
                        aestate.skip_pmax = 4000;
                if(aestate.skip_pmax > 9000)
                        aestate.skip_pmax = 9000;
        }
        else
                aestate.skip_pmax = HIST_NOT_CHANGE;
        if((prm = paramValue(gparams, "skip_t")) != NULL) {
                aestate.skip_t = atof(prm) * 10;
                if(aestate.skip_t < 0)
                        aestate.skip_t = 0;
                if(aestate.skip_t > 50)
                        aestate.skip_t = 50;
        }
        else
                aestate.skip_t = HIST_NOT_CHANGE;
}

void setAEParams() {
  getAEParams();
  fillAEStruct();
  erroroper=ioctl(driver, _IO(IOC_AUTOEXP_SET, 0x00), &aestate);
}

void getAEParams() {  erroroper=ioctl(driver, _IO(IOC_AUTOEXP_GET, 0x00), &aestate);  }

---