feat support fast base64 (9fe332c8) · Commits · tqcq air / sled · GitLab

src/sled/strings/base64.cc

+57 −6

Original line number	Diff line number	Diff line
		@@ -5,8 +5,13 @@
		#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 {
		static constexpr int kBufferSize = 4096;
		const char kBase64Chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		std::array<int, 1 << (8 * sizeof(char))> kInvBase64Chars;
		// static int kInvBase64Chars[(1 << sizeof(char))];
		@@ -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
		* 2 -> 4 -> (8 - value_bits - 2)
		* 4 -> 2 -> (8 - value_bits - 2)
		**/
		// value_bits
		// 2 -> 4 -> (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

+1 −1

Original line number	Diff line number	Diff line
		@@ -39,5 +39,5 @@ Base64Decode(picobench::state &state)
		}
		}

		PICOBENCH(Base64Encode);
		PICOBENCH(Base64Decode);
		PICOBENCH(Base64Encode);

src/sled/strings/base64_decode.inc

0 → 100644

+85 −0

Original line number	Diff line number	Diff line
		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 → 100644

+120 −0

Original line number	Diff line number	Diff line
		/*
		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

+1 −0

Original line number	Diff line number	Diff line
		@@ -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)));