feat support fast base64

src/sled/strings/base64.cc

@@ -5,9 +5,14 @@
 #include <fmt/format.h>
 #include <sstream>
 #include <string.h>
+extern "C" {
+#include "sled/strings/base64_decode.inc"
+#include "sled/strings/base64_encode.inc"
+}
 
 namespace sled {
-const char kBase64Chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static constexpr int kBufferSize = 4096;
+const char kBase64Chars[]        = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 std::array<int, 1 << (8 * sizeof(char))> kInvBase64Chars;
 // static int kInvBase64Chars[(1 << sizeof(char))];
 static OnceFlag once_flag;
@@ -39,6 +44,30 @@ std::string
 Base64::Encode(const uint8_t *ptr, size_t len)
 
 {
+    if (len == 0) { return std::string(); }
+    std::string result((len + 2) / 3 * 4, '0');
+    size_t write_idx = 0;
+
+    base64_encodestate state;
+    base64_init_encodestate(&state);
+
+    // char code[kBufferSize];
+    int plainlength = 0;
+    int codelength  = 0;
+    char *code      = const_cast<char *>(result.data()) + write_idx;
+    do {
+        plainlength = std::min(kBufferSize, static_cast<int>(len));
+        codelength  = base64_encode_block(reinterpret_cast<const char *>(ptr), plainlength, code, &state);
+        code += codelength;
+        len -= plainlength;
+        ptr += plainlength;
+    } while (len > 0 && plainlength > 0);
+
+    codelength = base64_encode_blockend(code, &state);
+
+    return result;
+
+    /*
     // std::stringstream ss;
     auto encoded_length = EncodedLength(len);
     std::string result(encoded_length, 0);
@@ -58,11 +87,10 @@ Base64::Encode(const uint8_t *ptr, size_t len)
         --len;
     }
 
-    /**
+    // value_bits
-     * value_bits      
+    // 2           ->  4  -> (8 - value_bits - 2)
-     * 2           ->  4  -> (8 - value_bits - 2)
+    // 4           ->  2  -> (8 - value_bits - 2)
-     * 4           ->  2  -> (8 - value_bits - 2)
+    //
-     **/
     if (value_bits > 0) {
         result[write_idx++] = kBase64Chars[(value << (6 - value_bits)) & 0x3F];
         // ss << kBase64Chars[((value << 8) >> (value_bits + 2)) & 0x3F];
@@ -72,11 +100,33 @@ Base64::Encode(const uint8_t *ptr, size_t len)
 
     // return ss.str();
     return result;
+    */
 }
 
 StatusOr<std::string>
 Base64::Decode(const uint8_t *ptr, size_t len)
 {
+    if (len == 0) { return std::string(); }
+
+    base64_decodestate state;
+    base64_init_decodestate(&state);
+
+    std::stringstream ss;
+    char plaintext[kBufferSize];
+    int codelength  = 0;
+    int plainlength = 0;
+    do {
+        codelength  = std::min(kBufferSize, static_cast<int>(len));
+        plainlength = base64_decode_block(reinterpret_cast<const char *>(ptr), codelength, plaintext, &state);
+        ss.write(plaintext, plainlength);
+
+        ptr += codelength;
+        len -= codelength;
+    } while (len > 0 && codelength > 0);
+
+    return ss.str();
+    /*
+
     CallOnce(once_flag, [&] {
         std::fill(kInvBase64Chars.begin(), kInvBase64Chars.end(), -1);
         for (int i = 0; kBase64Chars[i]; i++) { kInvBase64Chars[kBase64Chars[i]] = i; }
@@ -112,6 +162,7 @@ Base64::Decode(const uint8_t *ptr, size_t len)
     while (write_idx < data.size()) data.pop_back();
 
     return make_status_or<std::string>(data);
+    */
 }
 
 }// namespace sled

src/sled/strings/base64_bench.cc

@@ -39,5 +39,5 @@ Base64Decode(picobench::state &state)
     }
 }
 
-PICOBENCH(Base64Encode);
 PICOBENCH(Base64Decode);
+PICOBENCH(Base64Encode);

src/sled/strings/base64_decode.inc

@@ -0,0 +1,85 @@
+typedef enum { step_a, step_b, step_c, step_d } base64_decodestep;
+
+typedef struct {
+    base64_decodestep step;
+    char plainchar;
+} base64_decodestate;
+
+int
+base64_decode_value(char value_in)
+{
+    static const char decoding[]
+        = {62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1, -1, 0,  1,  2,  3,  4,
+           5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1,
+           26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
+    static const char decoding_size = sizeof(decoding);
+    value_in -= 43;
+    if (value_in < 0 || value_in > decoding_size) return -1;
+    return decoding[(int) value_in];
+}
+
+void
+base64_init_decodestate(base64_decodestate *state_in)
+{
+    state_in->step      = step_a;
+    state_in->plainchar = 0;
+}
+
+int
+base64_decode_block(const char *code_in, const int length_in, char *plaintext_out, base64_decodestate *state_in)
+{
+    const char *codechar = code_in;
+    char *plainchar      = plaintext_out;
+    char fragment;
+
+    *plainchar = state_in->plainchar;
+
+    switch (state_in->step) {
+        while (1) {
+        case step_a:
+            do {
+                if (codechar == code_in + length_in) {
+                    state_in->step      = step_a;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char) base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar = (fragment & 0x03f) << 2;
+        case step_b:
+            do {
+                if (codechar == code_in + length_in) {
+                    state_in->step      = step_b;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char) base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar++ |= (fragment & 0x030) >> 4;
+            *plainchar = (fragment & 0x00f) << 4;
+        case step_c:
+            do {
+                if (codechar == code_in + length_in) {
+                    state_in->step      = step_c;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char) base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar++ |= (fragment & 0x03c) >> 2;
+            *plainchar = (fragment & 0x003) << 6;
+        case step_d:
+            do {
+                if (codechar == code_in + length_in) {
+                    state_in->step      = step_d;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char) base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar++ |= (fragment & 0x03f);
+        }
+    }
+    /* control should not reach here */
+    return plainchar - plaintext_out;
+}

src/sled/strings/base64_encode.inc

@@ -0,0 +1,120 @@
+/*
+cencoder.c - c source to a base64 encoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+typedef enum
+{
+	step_A, step_B, step_C
+} base64_encodestep;
+
+typedef struct
+{
+	base64_encodestep step;
+	char result;
+	int stepcount;
+} base64_encodestate;
+
+const int CHARS_PER_LINE = 72;
+
+void base64_init_encodestate(base64_encodestate* state_in)
+{
+	state_in->step = step_A;
+	state_in->result = 0;
+	state_in->stepcount = 0;
+}
+
+char base64_encode_value(char value_in)
+{
+	static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	if (value_in > 63) return '=';
+	return encoding[(int)value_in];
+}
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
+{
+	const char* plainchar = plaintext_in;
+	const char* const plaintextend = plaintext_in + length_in;
+	char* codechar = code_out;
+	char result;
+	char fragment;
+	
+	result = state_in->result;
+	
+	switch (state_in->step)
+	{
+		while (1)
+		{
+	case step_A:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_A;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result = (fragment & 0x0fc) >> 2;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x003) << 4;
+	case step_B:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_B;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0f0) >> 4;
+			*codechar++ = base64_encode_value(result);
+			result = (fragment & 0x00f) << 2;
+	case step_C:
+			if (plainchar == plaintextend)
+			{
+				state_in->result = result;
+				state_in->step = step_C;
+				return codechar - code_out;
+			}
+			fragment = *plainchar++;
+			result |= (fragment & 0x0c0) >> 6;
+			*codechar++ = base64_encode_value(result);
+			result  = (fragment & 0x03f) >> 0;
+			*codechar++ = base64_encode_value(result);
+			
+			++(state_in->stepcount);
+			if (state_in->stepcount == CHARS_PER_LINE/4)
+			{
+				// *codechar++ = '\n';
+				state_in->stepcount = 0;
+			}
+		}
+	}
+	/* control should not reach here */
+	return codechar - code_out;
+}
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
+{
+	char* codechar = code_out;
+	
+	switch (state_in->step)
+	{
+	case step_B:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		*codechar++ = '=';
+		break;
+	case step_C:
+		*codechar++ = base64_encode_value(state_in->result);
+		*codechar++ = '=';
+		break;
+	case step_A:
+		break;
+	}
+	// *codechar++ = '\n';
+	
+	return codechar - code_out;
+}
+
+

src/sled/strings/base64_test.cc

@@ -31,6 +31,7 @@ TEST_SUITE("Base64")
         CHECK_EQ("aGVsbG8gd29ybGQK", sled::Base64::Encode("hello world\n"));
         CHECK_EQ("U2VuZCByZWluZm9yY2VtZW50cwo=", sled::Base64::Encode("Send reinforcements\n"));
         CHECK_EQ("", sled::Base64::Encode(""));
+        CHECK_EQ(sled::Base64::Encode(""), "");
         CHECK_EQ("IA==", sled::Base64::Encode(" "));
         CHECK_EQ("AA==", sled::Base64::Encode(std::string("\0", 1)));
         CHECK_EQ("AAA=", sled::Base64::Encode(std::string("\0\0", 2)));