apps/ccam/imageaccess.c

Go to the documentation of this file.

/*
 * modified for model 313
 * imageaccess.c
 *
 */
#include <fcntl.h>  /*open*/
#include <unistd.h> /* close */
#include <string.h>


#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>           /* mmap */

#include "imageaccess.h"
#define D(x)


//   MD(fprintf(stderr,"width- %d, height %d, quality - %d, contrast - %d, color - %d, orient - %d, depth - %d\r\n", ImageWidth,ImageHeight, Quality, Contrast, Color, bayerOrient, Depth));

/*
struct pixel_buffers {
  int                     data_fd;      // frame read pseudo-file file descriptor
  unsigned char   rgb[MAX_IMAGE_WIDTH*3];       // r-g-b-r-g-b... bayer-decoded data
  int                     imageWidth;
  int                     imageHeight;
  unsigned char * this; // pointer to current line of 8-bit data (to decoded data or DMA line (if 8-bit)
  unsigned char * prev; // pointer to previous line
  unsigned char * next;
  int                     depth;        //  only 8/not 8 (16) bits/pixel
  int                     shft;         //      0-5 - software "gain"
  int                     color;        // 0 -mono, 1 - rgb, 2 - pseudo color
  unsigned long   BayerRows[3][( MAX_IMAGE_WIDTH >> 2) +4];      // not used in 8-bit, 0-shift mode
  int                     BayerOrient; // pixel at 0/0: 0 - R, 1 G(R), 2 - G(B), 3 - B
  int                     bufferedRows[3]; // row numbers currently available in BayerRows[0], [1] and [2]
  unsigned long   palette[256]; // lsb -b, next - g, next - r
};

*/
//local functions declarations


unsigned char* convert8to8 ( int data_fd,   // image data file descriptor
                      unsigned long * row8Bit,
                      int rowNumber,
                                          int ImageWidth,
                      int Contrast);

unsigned char* convert16to8 ( int data_fd,   // image data file descriptor
                      unsigned long * row8Bit,
                      int rowNumber,
                                          int ImageWidth,
                      int Contrast);
int initPalette     (struct pixel_buffers * pbp,
                                         const char * pseudo
                                         );

int initPalette     (struct pixel_buffers * pbp,
                                         const char * pseudo
                                         ) {
  int i,l;
  int c, c0, p,p0,p1,k,d;
  int  r,g,b;
  char pseudo_dflt[]="0W";
  const char * cp= pseudo;
  c0=0;p0=0; // just to make compiler happy ;-)
  if ((!cp) || (strlen(cp)==0)) return 0;
  pbp->color=2; // overwrite
  if (strlen(cp) < 2) {
    pseudo_dflt[1]=cp[0];
        cp=(const char *) pseudo_dflt; 
  }
  l=strlen(cp); // length of pseudo color string
  for (i=0; i<l;i++) {
    p1=(i*255)/(l-1);
    switch (cp[i] ) {
      case '0': case 'k': case 'K':  {c=0;break;}
      case '1': case 'r': case 'R':  {c=1;break;}
      case '2': case 'g': case 'G':  {c=2;break;}
      case '3': case 'y': case 'Y':  {c=3;break;}
      case '4': case 'b': case 'B':  {c=4;break;}
      case '5': case 'm': case 'M':  {c=5;break;}
      case '6': case 'c': case 'C':  {c=6;break;}
      case '7': case 'w': case 'W':  {c=7;break;}
      default:                 {c=1;break;}
    }
        if (i>0) {
         k=0xff0000/(p1-p0);
D(fprintf(stderr,"p0=%x p1=%x k=%x\r\n",p0,p1,k));
         for (p=0;p<=(p1-p0);p++) { // will set each break point twice
           d=(p*k)>>16;
           if ((c^c0) & 1) {
             r= (c&1)?d:255-d;
           } else {     // if ((c^c0) & 1)
             r= (c&1)?255:0;
           } // if ((c^c0) & 1)

           if ((c^c0) & 2) {
             g= (c&2)?d:255-d;
           } else {     // if ((c^c0) & 1)
             g= (c&2)?255:0;
           } // if ((c^c0) & 1)

           if ((c^c0) & 4) {
             b= (c&4)?d:255-d;
           } else {     // if ((c^c0) & 1)
             b= (c&4)?255:0;
           } // if ((c^c0) & 1)
D(fprintf(stderr,"c=%x r=%x g=%x b=%x\r\n",c,r,g,b));
//         pbp->palette[p+p0]=r | (g<<8) | (b<<16);
           pbp->palette[p+p0]=b | (g<<8) | (r<<16);
         }
        } // if (i>0) {

        c0=c;
        p0=p1;
  }
D(for (i=0;i<256;i++) fprintf(stderr,"%03x: %08x\r\n",i,pbp->palette[i]));
  return 1;
}
unsigned long * getPalette (struct pixel_buffers * pbp) {return ((pbp->color)==2)?pbp->palette:NULL; } 

/*
  int                     color;        // 0 -mono, 1 - rgb, 2 - pseudo color
  unsigned long   palette[256]; // lsb -b, next - g, next - r

*/

int initPixelBuffers(struct pixel_buffers * pbp,
                                        const char * dmaFileName,
                                        int     width, // should be obtained from imageParamsR[P_ACTUAL_WIDTH]
                                        int height, // should be obtained from imageParamsR[P_ACTUAL_HEIGHT]
                                        int contrast,
                                        int colorMode,  // 0- b/w, 1 - color
                                        int bayer,      // 0..3 color under 0:0
                                        int     pixelDepth,             // 10,8,4
                                        const char * pseudo
                                        ) {
    int i; //, ppl;
   MD(fprintf(stderr,"dmaFileName- %s,width - %d, height %d, contrast - %d, colorMode - %d, bayer - %d, pixelDepth - %d\r\n",dmaFileName,width,height,contrast,colorMode,bayer,pixelDepth));

//
        pbp->data_fd=-1; // not initialized 
        switch (pixelDepth) {
         case 10:
         case 8:
         case 4: {pbp->depth=pixelDepth; break;}
         default: return -1; // bad depth
        }
 MD(fprintf(stderr,"\r\n"));

        if ((contrast >=0) && (contrast <6)) pbp->shft=contrast;
        else return -1;     // bad contrast
 MD(fprintf(stderr,"\r\n"));
        pbp->color=(colorMode>0);
        pbp->BayerOrient=bayer & 3;
        for (i=0;i<3;i++) pbp->bufferedRows[i] =-1;     // none cached
        if ((width >0)  && (width  <= MAX_IMAGE_WIDTH))  pbp->imageWidth=width;
        else return -1;
 MD(fprintf(stderr,"\r\n"));
        if ((height >0) && (height <= MAX_IMAGE_HEIGHT)) pbp->imageHeight=height;
        else return -1;
 MD(fprintf(stderr,"\r\n"));

//try open dmaFileName
        if ((pbp->data_fd = open(dmaFileName, O_RDONLY))==-1) return -2; // file open error
 MD(fprintf(stderr,"\r\n"));
    initPalette ( pbp, pseudo);
    return 0; // all OK
}

void closePixelBuffers(struct pixel_buffers * pbp) {// just close data_fd;
  if (pbp->data_fd>=0) {
                close(pbp->data_fd);
                pbp->data_fd=-1;
  }
}


/*
struct pixel_buffers {
  int                     data_fd;      // frame read pseudo-file file descriptor
  unsigned char   rgb[MAX_IMAGE_WIDTH*3];       // r-g-b-r-g-b... bayer-decoded data
  int                     imageWidth;
  int                     imageHeight;
  unsigned char * this; // pointer to current line of 8-bit data (to decoded data or DMA line (if 8-bit)
  unsigned char * prev; // pointer to previous line
  unsigned char * next;
  int                     depth;        //  only 8/not 8 (16) bits/pixel
  int                     shft;         //      0-5 - software "gain"
  int                     color;        // 0 -mono, 1 - rgb, 2 - pseudo color
  unsigned long   BayerRows[3][( MAX_IMAGE_WIDTH >> 2) +4];      // not used in 8-bit, 0-shift mode
  int                     BayerOrient; // pixel at 0/0: 0 - R, 1 G(R), 2 - G(B), 3 - B
  int                     bufferedRows[3]; // row numbers currently available in BayerRows[0], [1] and [2]
  unsigned long   palette[256]; // lsb -b, next - g, next - r
};
*/
// in color mode will not return rows 0 and last, will start at second pixel in each row 
unsigned char * getPixelRow(struct pixel_buffers * pbp, int row) {      //returns pointer to row data (mono or color depending on mode)
  int i,j;
  int curFilter;
  unsigned char * pr;
  unsigned long * pp;
  unsigned long d;
        if (pbp->data_fd <0) return NULL;

        if ((pbp->color)==1) {
          if ((row < 1) || (row >= (pbp->imageHeight-1))) return NULL;
// make this,prev,next
          if      ((row-1) == pbp->bufferedRows[0]) pbp->prev= (unsigned char *) pbp->BayerRows[0];
          else if ((row-1) == pbp->bufferedRows[1]) pbp->prev= (unsigned char *) pbp->BayerRows[1];
          else if ((row-1) == pbp->bufferedRows[2]) pbp->prev= (unsigned char *) pbp->BayerRows[2];
          else { // not in cache
            i=   (pbp->bufferedRows[0] > pbp->bufferedRows[1])? \
                      ((pbp->bufferedRows[2] > pbp->bufferedRows[1])? 1 : 2 ): \
                      ((pbp->bufferedRows[0] > pbp->bufferedRows[2])? 2 : 0 );
                  pbp->prev= getMonoRow(pbp, row-1, i);
                          pbp->bufferedRows[i]=row-1;
          }
          if      ((row  ) == pbp->bufferedRows[0]) pbp->this= (unsigned char *) pbp->BayerRows[0];
          else if ((row  ) == pbp->bufferedRows[1]) pbp->this= (unsigned char *) pbp->BayerRows[1];
          else if ((row  ) == pbp->bufferedRows[2]) pbp->this= (unsigned char *) pbp->BayerRows[2];
          else { // not in cache
            i=   (pbp->bufferedRows[0] > pbp->bufferedRows[1])? \
                      ((pbp->bufferedRows[2] > pbp->bufferedRows[1])? 1 : 2 ): \
                      ((pbp->bufferedRows[0] > pbp->bufferedRows[2])? 2 : 0 );
                  pbp->this= getMonoRow(pbp, row  , i);
                          pbp->bufferedRows[i]=row  ;
          }
          if      ((row+1) == pbp->bufferedRows[0]) pbp->next= (unsigned char *) pbp->BayerRows[0];
          else if ((row+1) == pbp->bufferedRows[1]) pbp->next= (unsigned char *) pbp->BayerRows[1];
          else if ((row+1) == pbp->bufferedRows[2]) pbp->next= (unsigned char *) pbp->BayerRows[2];
          else { // not in cache
            i=   (pbp->bufferedRows[0] > pbp->bufferedRows[1])? \
                      ((pbp->bufferedRows[2] > pbp->bufferedRows[1])? 1 : 2 ): \
                      ((pbp->bufferedRows[0] > pbp->bufferedRows[2])? 2 : 0 );
                  pbp->next= getMonoRow(pbp, row+1, i);
                          pbp->bufferedRows[i]=row+1;
          }
//  MD(fprintf(stderr,"row=%d bufferedRows[0..2] %d %d %d\r\n",row, pbp->bufferedRows[0],pbp->bufferedRows[1],pbp->bufferedRows[2]));
//  MD(fprintf(stderr,"prev,this,next %x %x %x\r\n",(int) pbp->prev, (int) pbp->this, (int) pbp->next));
          if ((!pbp->prev) || (!pbp->this) || (!pbp->next)) return NULL;

// calculate rgb using this, prev and next bayer rows
      curFilter=((pbp->BayerOrient ^ 1) ^ (row << 1)) & 3;       // filter number over the first pixel in a row
          j=0;
          for (i=1;i<(pbp->imageWidth-1);i++){ 
            switch (curFilter) {
             case 0: { // r
               pbp->rgb[j++]=       pbp->this[i];                                                          // R component
               pbp->rgb[j++]=((int) pbp->this[i+1]+pbp->this[i-1]+pbp->prev[i  ]+pbp->next[i  ]) >> 2; // G component
               pbp->rgb[j++]=((int) pbp->prev[i+1]+pbp->prev[i-1]+pbp->next[i+1]+pbp->next[i-1]) >> 2; // B component
           break;
             }
             case 1: { // g on r
               pbp->rgb[j++]=((int) pbp->this[i+1]+pbp->this[i-1]) >> 1;                          // R component
               pbp->rgb[j++]=       pbp->this[i  ];                                               // G component
               pbp->rgb[j++]=((int) pbp->prev[i  ]+pbp->next[i  ]) >> 1;                          // B component
               break;
             }
             case 2: { // g on b
               pbp->rgb[j++]=((int) pbp->prev[i  ]+pbp->next[i  ]) >> 1;                          // R component
               pbp->rgb[j++]=       pbp->this[i  ];                                               // G component
               pbp->rgb[j++]=((int) pbp->this[i+1]+pbp->this[i-1]) >> 1;                          // B component
               break;
             }
             case 3: { // b
               pbp->rgb[j++]=((int) pbp->prev[i+1]+pbp->prev[i-1]+pbp->next[i+1]+pbp->next[i-1]) >> 2; // R component
               pbp->rgb[j++]=((int) pbp->this[i+1]+pbp->this[i-1]+pbp->prev[i  ]+pbp->next[i  ]) >> 2; // G component
               pbp->rgb[j++]=       pbp->this[i];                                                // B component
               break;
             }
            }
          curFilter ^=1; // r-g-r-g... or g-b-g-b...

          }
//      MD(fprintf(stderr,"color calculated\r\n"));

      return (unsigned char*) pbp->rgb;
        } else if ((pbp->color)==2) {
// build pbp->rgb
//  unsigned char * pr;
//  unsigned long * pp;
       pr=getMonoRow(pbp, row, 0);
           pp=getPalette(pbp);
           j=0;
           for (i=0;i<(pbp->imageWidth);i++){
             d=pp[pr[i]];
//               pbp->rgb[j++]= (d         & 0xff);
//               pbp->rgb[j++]= ((d >>  8) & 0xff);
//               pbp->rgb[j++]= ((d >> 16) & 0xff);
// sequence changed to match bmp files (b-g-r)
                 pbp->rgb[j++]= ((d >> 16) & 0xff);
                 pbp->rgb[j++]= ((d >>  8) & 0xff);
                 pbp->rgb[j++]= (d         & 0xff);
           } 
       return (unsigned char*) pbp->rgb;
        } else return getMonoRow(pbp, row, 0); //if ((pbp->color)==1)
}

unsigned char * getMonoRow(struct pixel_buffers * pbp, int row, int bufn) {
//  MD(fprintf(stderr,"bufn= %d, row=%d\r\n",bufn,row));

  if (pbp->data_fd < 0) return NULL;
  if ((bufn < 0) || (bufn >  2)) return NULL;
  if ((row  < 0) || (row  >= pbp->imageHeight)) return NULL;
  switch(pbp->depth){
    case  8: return convert8to8  (pbp->data_fd,pbp->BayerRows[bufn],row,pbp->imageWidth,pbp->shft);
    default: return convert16to8 (pbp->data_fd,pbp->BayerRows[bufn],row,pbp->imageWidth,pbp->shft);
  }
}



/*
 * Apply contrast to convert DMA 8-bit data to rows of 8-bit data
 */

unsigned char* convert8to8 ( int data_fd,   // image data file descriptor
                      unsigned long * row8Bit,
                      int rowNumber,
                                          int ImageWidth,
                      int Contrast) {
  int i,DMALongsPerRow;
  unsigned long dmask;

// read line from file
  lseek(data_fd,ImageWidth*rowNumber,0);
  read (data_fd,row8Bit,ImageWidth);
  if (Contrast>0) {
    DMALongsPerRow=(ImageWidth>>2)+ ((ImageWidth & 3)? 1:0);
    dmask=(0xff<<Contrast) & 0xff;
    dmask |= ((dmask)<<8) | ((dmask)<<16) | ((dmask)<<24);
    MD(fprintf(stderr,"row= %d, Contrast=%d, dmask=%lx\r\n",rowNumber,Contrast,dmask));
    for (i=0;i<DMALongsPerRow;i++)  row8Bit[i]=(row8Bit[i]<<Contrast) & dmask;
  }
  return (unsigned char*) row8Bit;
 }

unsigned char* convert16to8 ( int data_fd,   // image data file descriptor
                      unsigned long * row8Bit,
                      int rowNumber,
                                          int ImageWidth,
                      int Contrast) {
  int i,sr,sl;
  unsigned long lrow16[(MAX_IMAGE_WIDTH >>1 ) + 4] ; //+4??
  short *       row16= (short *) lrow16;
  unsigned char * brow8= (unsigned char *) row8Bit;
// read line from file
  lseek(data_fd,(ImageWidth*rowNumber)<<1,0);
  read (data_fd,row16,ImageWidth<<1);
  sr=2-Contrast;
  sl=Contrast-2;
  if (Contrast <= 2) for (i=0;i<ImageWidth;i++) brow8[i]= (row16[i]>>sr) & 0xff;
  else               for (i=0;i<ImageWidth;i++) brow8[i]= (row16[i]<<sl) & 0xff;
  return (unsigned char*) row8Bit;
 }

---