/home/fwph/code/wurde/rde/utils/rleCoding.cpp

Go to the documentation of this file.

#include <RobotTypes.H>
#include <ImageSource.H>

namespace WURDE {
       /*
         RLE Encodes an array of unsigned chars in place.  In order to speed things up, you can
         pass in a pointer to a buffer (at least as large as the original data) that is just
         used as garbage space.

         Note, if the encoding does not produce a shorter array, then the
         original array is returned, and the function returns the length of the array.
         
         If the encoding does produce a shorter array, then the RLE encoded array is returned and
         the function returns the length of the encoded array.
       */
       long GCM_rleEncodeGreyLow(unsigned char *data, const long rows, const long cols) {
              long i, j;
              unsigned char curRun, curVal;
              unsigned char *source = data;
              unsigned char *target = data;
              long count = 0;
              
              count = 0;
              for(i=0;i<rows*cols;) {
                     
                     // grab the current pixel as the current run exemplar
                     curVal = source[i++] >> 3;

                     // the current run starts out as 1
                     curRun = 0;
                     for(j=0;j<7 && i<rows*cols;j++) {
                            if((source[i] >> 3) == curVal) {
                                   curRun++;
                                   i++;
                            }
                            else
                                   break;
                     }

                     target[count++] = (curRun << 5) | curVal;
              }

              return(count);
       }


       /*
         Decodes from the source to the target memory 

         The target memory must be large enough to hold the whole image
       */
       int GCM_rleDecodeGreyLow(unsigned char *source, const long rleSize, unsigned char *target) {
              long i, j;
              unsigned long k;
              unsigned int curRun;
              unsigned char curVal;

              for(i=0,j=0;i<rleSize;i++) {

                     // get the current run/value information
                     curRun = (source[i] >> 5) + 1;
                     curVal = (source[i]) << 3;
    
                     // fill it out in the temporary image
                     for(k=0;k<curRun;k++,j++)
                            target[j] = curVal;
              }

              return(0);
       }


       /*
         Middle quality encoding of greyscale images.
  
         Each 8-bit value is 2-bits of run information and 6 bits of value
       */
       long GCM_rleEncodeGreyMed(unsigned char *data, const long rows, const long cols) {
              long i, j;
              unsigned char curRun, curVal;
              unsigned char *source = data;
              unsigned char *target = data;
              long count = 0;

              count = 0;
              for(i=0;i<rows*cols;) {

                     // grab the current pixel as the current run exemplar
                     curVal = source[i++] >> 2;

                     // the current run starts out as 1
                     curRun = 0;
                     for(j=0;j<3 && i<rows*cols;j++) {
                            if((source[i] >> 2) == curVal) {
                                   curRun++;
                                   i++;
                            }
                            else
                                   break;
                     }

                     target[count++] = (curRun << 6) | curVal;
              }

              return(count);
       }


       /*
         Decodes a medium quality RLE image from the source to the target
       */
       int GCM_rleDecodeGreyMed(unsigned char *source, const long rleSize, unsigned char *target) {
              long i, j;
              unsigned long k;
              unsigned int curRun;
              unsigned char curVal;

              for(i=0,j=0;i<rleSize;i++) {

                     // get the current run/value information
                     curRun = (source[i] >> 6) + 1;
                     curVal = (source[i]) << 2;
    
                     // fill it out in the temporary image
                     for(k=0;k<curRun;k++,j++)
                            target[j] = curVal;
              }

              return(0);
       }

       /*
         Low quality encoding of color images.
  
         Each similar run of 3-byte pixels is encoded into a 2-byte value 

         4-bits of run information, followed by a 4/4/4 R/G/B color value

         This code works on the array in place
       */
       long GCM_rleEncodePixLow(unsigned char *data, const long rows, const long cols) {
              long a,i;
              unsigned short curRun, curVal;
              unsigned char *source = data;
              unsigned char *target = data;
              long count = 0;

              count = 0;
              for(i=0;i<rows*cols*3;) {

                     // grab the current pixel as the current run exemplar
                     curVal = ((source[i] & 0x00F0) << 4) | ((source[i+1] & 0x00F0)) | ((source[i+2] & 0x00F0) >> 4);
                     a = i;
                     i += 3;

                     // max value for curRun is 15
                     for(curRun=0;curRun<15 && i<rows*cols*3;curRun++,i+=3) {
                            if(curVal != (((source[i] & 0x00F0) << 4) | ((source[i+1] & 0x00F0)) | ((source[i+2] & 0x00F0) >> 4)))
                                   break;
                     }

                     target[count++] = (curRun << 4) | ((source[a] & 0xF0) >> 4);
                     target[count++] = (source[a+1] & 0xF0) | ((source[a+2] & 0xF0) >> 4);
              }

              return(count); // number of bytes
       }


       /*
         Decodes a low quality color RLE image from the source to the target memory.
       */
       int GCM_rleDecodePixLow(unsigned char *data, const long rleSize, unsigned char *target) {
              long i, j;
              short curRun;
              unsigned char curVal[3];
              unsigned char *source = (unsigned char *)data;

              for(i=0,j=0;i<rleSize;i+=2) {

                     // get the current run/value information
                     curRun = ((source[i] & 0xF0) >> 4);
                     curVal[0] = (source[i] & 0x0F) << 4;
                     curVal[1] = (source[i+1] & 0xF0);
                     curVal[2] = (source[i+1] & 0x0F) << 4;

                     // fill it out in the temporary image
                     for(;curRun>=0;curRun--,j+=3) {
                            target[j+0] = curVal[0];
                            target[j+1] = curVal[1];
                            target[j+2] = curVal[2];
                     }
              }

              return(0);
       }


       /*
         Medium quality encoding of color images.
  
         Each 3-byte pixel value is encoded into a 2-byte value (short) value

         No run information, color is a 5/6/5 R/G/B color value

         This code works on the array in place
       */
       long GCM_rleEncodePixMed(unsigned char *data, const long rows, const long cols) {
              long i;
              unsigned char *source = data;
              unsigned char *target = (unsigned char *)data;
              long count = 0;

              for(i=0,count=0;i<rows*cols*3;i+=3) {

                     // first byte gets 5 bits of red, and 3 bits of green
                     target[count++] = (source[i] & 0xF8) | (source[i+1] >> 5);

                     // second byte gets 3 bits of green and 5 bits of blue
                     target[count++] = ((source[i+1] & 0xFC) << 3) | (source[i+2] >> 3);
              }

              return(count); // number of bytes
       }


       /*
         Decodes a medium quality color image

         Copies from the source to the target
       */
       int GCM_rleDecodePixMed(unsigned char *data, const long rleSize, unsigned char *target) {
              long i, j;
              unsigned char *source = (unsigned char *)data;

              // rleSize/2 because rleSize is number of bytes
              for(i=0,j=0;i<rleSize;i+=2,j+=3) {
                     // unpack the colors
                     target[j+0] = (source[i] & 0xF8);
                     target[j+1] = ((source[i] & 0x07) << 5) | ((source[i+1] & 0xE0) >> 3);
                     target[j+2] = (source[i+1] & 0x1F) << 3; 
              }

              return(0);
       }

}

---