docs: public static LinkedBuffer encode(final byte[] input, int inOffset, int inLen,
              final WriteSession session, final LinkedBuffer lb) throws IOException
      {
          int outputSize = ((inLen + 2) / 3) * 4;
          session.size += outputSize;
  
          final int available = lb.buffer.length - lb.offset;
          if (outputSize > available)
          {
              int chunks = available / 4;
              if (chunks == 0)
              {
                  // available size is less than 4
                  if (outputSize > session.nextBufferSize)
                  {
                      final byte[] encoded = new byte[outputSize];
                      encode(input, inOffset, inLen, encoded, 0);
                      // return a fresh buffer.
                      return new LinkedBuffer(session.nextBufferSize,
                              new LinkedBuffer(encoded, 0, outputSize, lb));
                  }
  
                  final byte[] encoded = new byte[session.nextBufferSize];
                  encode(input, inOffset, inLen, encoded, 0);
                  // continue with the existing byte array of the previous buffer
                  return new LinkedBuffer(encoded, 0, outputSize, lb);
              }
  
              int inBefore = inOffset;
              final byte[] buffer = lb.buffer;
              int offset = lb.offset;
              byte b0, b1, b2;
  
              // process available
              while (chunks-- > 0)
              {
                  b0 = input[inOffset++];
                  b1 = input[inOffset++];
                  b2 = input[inOffset++];
                  buffer[offset++] = nibble2code[(b0 >>> 2) & 0x3f];
                  buffer[offset++] = nibble2code[(b0 << 4) & 0x3f | (b1 >>> 4) & 0x0f];
                  buffer[offset++] = nibble2code[(b1 << 2) & 0x3f | (b2 >>> 6) & 0x03];
                  buffer[offset++] = nibble2code[b2 & 077];
              }
  
              inLen -= (inOffset - inBefore);
  
              outputSize -= (offset - lb.offset);
  
              lb.offset = offset;
  
              if (outputSize > session.nextBufferSize)
              {
                  final byte[] encoded = new byte[outputSize];
                  encode(input, inOffset, inLen, encoded, 0);
                  // return a fresh buffer.
                  return new LinkedBuffer(session.nextBufferSize,
                          new LinkedBuffer(encoded, 0, outputSize, lb));
              }
  
              final byte[] encoded = new byte[session.nextBufferSize];
              encode(input, inOffset, inLen, encoded, 0);
              // continue with the existing byte array of the previous buffer
              return new LinkedBuffer(encoded, 0, outputSize, lb);
          }
  
          encode(input, inOffset, inLen, lb.buffer, lb.offset);
          lb.offset += outputSize;
  
          return lb;
      }