EncodeToBase64.h

//  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                encode to base 64
//  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                           by santiago v lombeyda
//                                            cacr-caltech (c) 2004
//
//  base 64 encoders are very simple. all they do
//  is take 6 bits at a time and translate them into
//  an 8 bit char corresponding to letters A-Z a-z + /.
//  total 64 bit ascii characters. the only issue is
//  when the number of bits is not a multiple of 6. so,
//  you simple do it 3 binary characters at a time into
//  four chars, and if you do not have enough, you simply
//  stuff 8 or 16 0 bits (1 or 2 chars) to add up to the
//  wanted 24 bits that will become 32 bits (4 chars).
//
//  this implementation, takes advantage of the first and
//  last bits to quickly encode them using one of 2 lookup
//  char conversion tables. the middle two 6 bits are treated
//  the usual way, converting them into 2 zero bits and then
//  the lookup 6.
//
//  (is a memory lookup faster than 3 bit operations? maybe not)
//  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

static const char* TABLE_BYTE_3_B64 ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ ";

static const char* TABLE_BYTE_0_B64 ="AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSSTTTTUUUUVVVVWWWWXXXXYYYYZZZZaaaabbbbccccddddeeeeffffgggghhhhiiiijjjjkkkkllllmmmmnnnnooooppppqqqqrrrrssssttttuuuuvvvvwwwwxxxxyyyyzzzz0000111122223333444455556666777788889999++++//// ";

# define encodeCHARToBase64(c) (((c)<=25)?(c+'A'):(\
                                ((c)<=51)?(c+'a'-26):(\
                                ((c)<=61)?(c+'0'-52):(\
                                ((c)==61)?'+':'/'))))

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                     isBigEndian
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bool isBigEndian() {
# define IS_BIG_ENDIAN    2
# define IS_LITTLE_ENDIAN 1
  static int checkedEndianess=0;
  if (checkedEndianess==0) {
    const int i=1;
    char *c=(char *)&i;
    if (c[sizeof(int)-1]==0) checkedEndianess=IS_LITTLE_ENDIAN;
    else checkedEndianess=IS_BIG_ENDIAN;
  }
  return (checkedEndianess==IS_BIG_ENDIAN);
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                  isLittleEndian
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bool isLittleEndian() {
  return !isBigEndian();
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                   encodeToBase64
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//void encodeToBase64(unsigned char *in3Bytes, unsigned char *out4Bytes) {
//   if (in3Bytes==NULL || out4Bytes==NULL) return;
//   out4Bytes[0]=TABLE_BYTE_0_B64[in3Bytes[0]];
//   out4Bytes[1]=TABLE_BYTE_3_B64[((in3Bytes[0]&0x03)<<4)+
//                                 ((in3Bytes[1]&0xf0)>>4)];
//   out4Bytes[2]=TABLE_BYTE_3_B64[((in3Bytes[1]&0x0f)<<2)+
//                                 ((in3Bytes[2]&0xc0)>>6)];
//   out4Bytes[3]=TABLE_BYTE_3_B64[in3Bytes[2]];
//}

inline void encodeToBase64(unsigned char *in3Bytes, unsigned char *out4Bytes) {
   static int i;
   if (in3Bytes==NULL || out4Bytes==NULL) return;
   *(out4Bytes++)=TABLE_BYTE_0_B64[*in3Bytes];
     i= ( *(in3Bytes++)&0x03)<<4;
     i|=((*(in3Bytes)&0xf0)>>4);
   *(out4Bytes++)=TABLE_BYTE_3_B64[i];
     i= ( *(in3Bytes++)&0x0f)<<2;
     i|=((*(in3Bytes)&0xc0)>>6);
   *(out4Bytes++)=TABLE_BYTE_3_B64[i];
   *(out4Bytes++)=TABLE_BYTE_3_B64[*in3Bytes];
}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                   encodeToBase64
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
inline int encodeToBase64(unsigned int n, unsigned char *inBytes, unsigned char *outBytes) {
  static unsigned int m;
  static unsigned int i, j;
  if (inBytes==NULL || outBytes==NULL || n<=0) return 0;
  m=n-(n%3);
  for ( i=j=0; i<m; i+=3, j+=4)  encodeToBase64(inBytes+i,outBytes+j);
  if (m!=n) {
   char unsigned lastchars[3] = {0,0,0};
   lastchars[0]=inBytes[i];
   if ((n-m)==2) lastchars[1]=inBytes[i+1];
   encodeToBase64(lastchars,outBytes+j);
   outBytes[j+3]='=';
   if ((n-m)==1) outBytes[j+2]='=';
   j+=4;
  }
  return j;
}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                runEncodeToBase64
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
inline int runEncodeToBase64(int n, unsigned char *inBytes, unsigned char *outBytes, bool flushBuffer=false) {
  static int cachedChars=0;
  static unsigned char charCache[3];
  int l=0;

  // there are cached leftovers
  if (cachedChars>0) {
    // fill more
    if (n>0) { charCache[cachedChars++]=*inBytes; inBytes++; n--; }
    if (cachedChars<3 && n>0) { charCache[cachedChars++]=*inBytes; inBytes++; n--; }
    // if filled
    if (cachedChars==3 || flushBuffer) {
     l=encodeToBase64(cachedChars,charCache,outBytes);
     outBytes+=l;
     cachedChars=0;
    }
  }
  if (n==0) return l;

  int m=n-n%3;
  if (flushBuffer || n==m) {
     l+=encodeToBase64(n,inBytes,outBytes);
     return l;
  }
  // cache left overs
  charCache[cachedChars++]=inBytes[m];
  if (m+1<n) charCache[cachedChars++]=inBytes[m+1];
  l+=encodeToBase64(m,inBytes,outBytes);
   return l;
}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                   flip N bytes
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#define flip2Bytes(str) {char c=str[1];str[1]=str[0];str[0]=c;}
#define flip4Bytes(str) {char c=str[3];str[3]=str[0];str[0]=c; c=str[1];str[1]=str[2];str[2]=c;}
#define flip8Bytes(str) {char c=str[7];str[7]=str[0];str[0]=c; \
                              c=str[6];str[6]=str[1];str[1]=c; \
                              c=str[5];str[5]=str[2];str[2]=c; \
                              c=str[4];str[4]=str[3];str[3]=c; }
#define flipNBytes(n,str) {for (int _flip_i=n/2;_flip_i<n;_flip_i++) \
                             {char c=str[_flip_i];str[_flip_i]=str[n-1-_flip_i];str[n-1-_flip_i]=c;}};

void flipBytes(int size, int n, unsigned char *data) {
  if (size==2)      for (int i=0; i<n; i++, data+=2)    {flip2Bytes(data);}
  else if (size==4) for (int i=0; i<n; i++, data+=4)    {flip4Bytes(data);}
  else if (size==8) for (int i=0; i<n; i++, data+=8)    {flip8Bytes(data);}
  else              for (int i=0; i<n; i++, data+=size) {flipNBytes(size,data);}
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                              buffered f write
// size_t fwrite(const  void  *ptr,  size_t  size,  size_t  nmemb,  FILE *stream);
// size_t bufferedfwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream, bool flush=false);
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# define BUFFERED_FWRITE_BUFFER_SIZE 4194304

inline size_t bufferedfwrite(const void *ptr, size_t size, size_t nmemb, std::ostream& stream, bool flush=false) {

  static unsigned long idx=0;
  static unsigned long ntowrite;
  static unsigned long ntocopy;
  static unsigned char * buffer=NULL;

  if (buffer==NULL) {
    buffer=(unsigned char *)malloc(BUFFERED_FWRITE_BUFFER_SIZE);
    if (buffer==NULL) {
      std::cerr<<"Could not allocate binary write buffer of size " << BUFFERED_FWRITE_BUFFER_SIZE << std::endl;
      exit(1);
    }
  }

  if (size==0 || nmemb==0) return 0;

  ntowrite=size*nmemb;

  if (idx==0 && flush)
    //return fwrite(ptr,size,nmemb,stream);
    return ((stream.write((char *)ptr,ntowrite)).fail()?0:ntowrite);


  if (ntowrite>=BUFFERED_FWRITE_BUFFER_SIZE*2) {
    //fwrite(buffer,1,idx,stream);
    stream.write((char *)buffer,idx);
    //fwrite(ptr,1,ntowrite,stream);
    stream.write((char *)ptr,ntowrite);
    ntowrite+=idx;
    idx=0;
    return ntowrite;
  }

  if (idx+ntowrite>BUFFERED_FWRITE_BUFFER_SIZE)
    ntocopy=BUFFERED_FWRITE_BUFFER_SIZE-idx;
  else
    ntocopy=ntowrite;

  memcpy(buffer+idx,ptr,ntocopy);
  idx+=ntocopy;

  if (flush || idx>=BUFFERED_FWRITE_BUFFER_SIZE) {
    //assert(idx<=BUFFERED_FWRITE_BUFFER_SIZE);
    //fwrite(buffer,1,idx,stream);
    stream.write((char *)buffer,idx);
    // if there was more data than buffer space
    if (ntocopy<ntowrite) {
      idx=0;
      if (flush)
         //return fwrite((unsigned char*)(ptr)+ntocopy,1,ntowrite-ntocopy,stream)+BUFFERED_FWRITE_BUFFER_SIZE;
         return ((stream.write((char *)(unsigned char*)(ptr)+ntocopy,ntowrite-ntocopy)).fail()?
                   0:ntowrite-ntocopy+BUFFERED_FWRITE_BUFFER_SIZE);
      idx=ntowrite-ntocopy;
      memcpy(buffer,(unsigned char*)(ptr)+ntocopy,idx);
      return BUFFERED_FWRITE_BUFFER_SIZE;
    }
    ntowrite=idx;
    idx=0;
    return ntowrite;
  }
  return 0;
}


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                                                                                           ENCODE TO BASE 64 AND WRITE
// this function is supposed to be called with nice, LONG binary buffers, thus using just
// one big loop.
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
inline bool encodeToBase64AndWrite(unsigned char *ptr, long n, std::ostream& stream, bool flush=false) {
  static unsigned char * buffer=NULL;
  static unsigned int    nbuffered=0;
  static unsigned char * bufferptr=NULL;
  static unsigned char * bufferend=NULL;

  static unsigned char   charsbuffered[4];
  static unsigned int    ncharsbuffered=0;

  static unsigned int    v;

  //if (DEBUG) std::cerr<<"writing " << n <<" encoded chars " << std::endl;

  if (n==0 && ncharsbuffered==0 && nbuffered==0) return true;

  if (buffer==NULL) {
    buffer=(unsigned char *)malloc(BUFFERED_FWRITE_BUFFER_SIZE+4);
    if (buffer==NULL) {
      std::cerr<<"Could not allocate binary write buffer of size " << BUFFERED_FWRITE_BUFFER_SIZE << std::endl;
      exit(1);
    }
    bufferptr=buffer;
    bufferend=buffer+BUFFERED_FWRITE_BUFFER_SIZE;
  }

  // enough charsbuffered plus new to go into big output buffer
  if (ncharsbuffered>0 && (n+ncharsbuffered)>2) {
    charsbuffered[ncharsbuffered++]=*(ptr++);
     n--;
     if (ncharsbuffered<3) {
       charsbuffered[ncharsbuffered++]=*(ptr++);
       n--;
     }
     encodeToBase64(charsbuffered, bufferptr);
     nbuffered+=4;
     bufferptr+=4;
     ncharsbuffered=0;
  }
  while (n>2) {
    while (n>2 && bufferptr<bufferend) {
     *(bufferptr++)=TABLE_BYTE_0_B64[*ptr];
       v= ( *(ptr++)&0x03)<<4;
       v|=((*(ptr)&0xf0)>>4);
     *(bufferptr++)=TABLE_BYTE_3_B64[v];
       v= ( *(ptr++)&0x0f)<<2;
       v|=((*(ptr)&0xc0)>>6);
     *(bufferptr++)=TABLE_BYTE_3_B64[v];
     *(bufferptr++)=TABLE_BYTE_3_B64[*(ptr++)];
     nbuffered+=4;
     n-=3;
    }
    if (n>0 && n<3) {
      //asssert(ncharsbuffered==0);
      if (flush) {
        nbuffered+=encodeToBase64(n, ptr, bufferptr);
        ptr+=n;
        n=0;
      } else {
        charsbuffered[ncharsbuffered++]=*(ptr++);
        n--;
        if (n>0) {
          charsbuffered[ncharsbuffered++]=*(ptr++);
          n--;
        }
      }
      //assert(n==0);
    }
    if (bufferptr>=bufferend || flush) {
      if (stream.write((const char *)buffer,nbuffered).fail()) return false;
      bufferptr=buffer;
      nbuffered=0;
    }
  }
  if (n>0) {
    charsbuffered[ncharsbuffered++]=*(ptr++);
    n--;
    if (n>0) {
     charsbuffered[ncharsbuffered++]=*(ptr++);
     n--;
    }
  }

  //assert(n==0)

  if (ncharsbuffered>0 && flush) {
    nbuffered+=encodeToBase64(ncharsbuffered, charsbuffered, bufferptr);
    ncharsbuffered=0;
  }
  if (bufferptr>=bufferend || flush) {
    if (stream.write((const char *)buffer,nbuffered).fail()) return false;
    bufferptr=buffer;
    nbuffered=0;
  }
  // if (DEBUG) std::cerr<<"++ wrote " << nbuffered <<"/" << n << "/" << ncharsbuffered << " encoded chars " << std::endl;

  return true;
}

---