C++ > max_devbase32

static const char base32_alphabet[32] = {
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
  'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
  'Y', 'Z', '2', '3', '4', '5', '6', '7'
};

size_t
base32_encode(char *dst, size_t size, const void *data, size_t len)
{
  size_t i = 0;
  const U8 *p = (const U8*)data;
  const char *end = &dst[size];
  char *q = dst;

  do {
    size_t j, k;
    U8 x[5];
    char s[8];

    switch (len - i) {
    case 4: k = 7; break;
    case 3: k = 5; break;
    case 2: k = 3; break;
    case 1: k = 2; break;
    default:
      k = 8;
    }

    for (j = 0; j < 5; j++)
      x[j] = i < len ? p[i++] : 0;

/*
  +-------+-----------+--------+
  | target| source    | source |
  | byte  | bits      | byte   |
  +-------+-----------+--------+
  |     0 | 7 6 5 4 3 | 0      |
  |     1 | 2 1 0 7 6 | 0-1    |
  |     2 | 5 4 3 2 1 | 1      |
  |     3 | 0 7 6 5 4 | 1-2    |
  |     4 | 3 2 1 0 7 | 2-3    |
  |     5 | 6 5 4 3 2 | 3      |
  |     6 | 1 0 7 6 5 | 3-4    |
  |     7 | 4 3 2 1 0 | 4      |
  +-------+-----------+--------+
 
*/
   
    s[0] =  (x[0] >> 3);
    s[1] = ((x[0] & 0x07) << 2) | (x[1] >> 6);
    s[2] =  (x[1] >> 1) & 0x1f;
    s[3] = ((x[1] & 0x01) << 4) | (x[2] >> 4);
    s[4] = ((x[2] & 0x0f) << 1) | (x[3] >> 7);
    s[5] =  (x[3] >> 2) & 0x1f;
    s[6] = ((x[3] & 0x03) << 3) | (x[4] >> 5);
    s[7] =   x[4] & 0x1f;

    for (j = 0; j < k && q != end; j++)
      *q++ = base32_alphabet[(U8) s[j]];

  } while (i < len);

  return q - dst;
}



static inline int
ascii_toupper(int c)
{
  return c >= 97 && c <= 122 ? c - 32 : c;
}

static inline int
ascii_tolower(int c)
{
  return c >= 65 && c <= 90 ? c + 32 : c;
}


static char base32_map[(unsigned char) -1];

size_t
base32_decode(char *dst, size_t size, const void *data, size_t len)
{
  const char *end = &dst[size];
  const unsigned char *p = data;
  char *q = dst;
  size_t i;
  unsigned max_pad = 3;

  if (0 == base32_map[0]) {
    for (i = 0; i < LL_ARRAY_SIZE(base32_map); i++) {
      const char *x;
     
      x = memchr(base32_alphabet, ascii_toupper(i), sizeof base32_alphabet);
      base32_map[i] = x ? (x - base32_alphabet) : (unsigned char) -1;
    }
  }
 
  for (i = 0; i < len && max_pad > 0; i++) {
    unsigned char c;
    char s[8];
    size_t j;

    c = p[i];
    if ('=' == c) {
      max_pad--;
      c = 0;
    } else {
      c = base32_map[c];
      if ((unsigned char) -1 == c) {
        return -1;
      }
    }

    j = i % LL_ARRAY_SIZE(s);
    s[j] = c;

    if (7 == j) {
      char b[5];

      b[0] = ((s[0] << 3) & 0xf8) | ((s[1] >> 2) & 0x07);
      b[1] = ((s[1] & 0x03) << 6) | ((s[2] & 0x1f) << 1) | ((s[3] >> 4) & 1);
      b[2] = ((s[3] & 0x0f) << 4) | ((s[4] >> 1) & 0x0f);
      b[3] = ((s[4] & 1) << 7) | ((s[5] & 0x1f) << 2) | ((s[6] >> 3) & 0x03);
      b[4] = ((s[6] & 0x07) << 5) | (s[7] & 0x1f);

      for (j = 0; j < LL_ARRAY_SIZE(b); j++) {
        if (q != end)
          *q = b[j];
        q++;
      }
    }
  }

  return q - dst;
}
*/


std::string LLBase32::encode(const U8* input, size_t input_size)
{
        std::string output;
        if (input)
        {
               
                size_t input_chunks = (input_size + 4) / 5;
                size_t output_size = input_chunks * 8;

                output.resize(output_size);

                size_t encoded = base32_encode(&output[0], output_size, input, input_size);

                llinfos << "encoded " << encoded << " into buffer of size "
                        << output_size << llendl;
        }
        return output;
}