Подскажите символьный паккер, лучше чем base64

[Aetae]

А вообще гуглили по теме?
Вот например интересный топик http://forum.ixbt.com/topic.cgi?id=26:41000

[Deff]

Вот например интересный топик http://forum.ixbt.com/topic.cgi?id=26:41000

Ну про LWZ - я говорил - стадартный LWZ -кодирует инфу в байт, что не подходит - нун попробовать модифицировать его в кодировку base85 или base64

[Deff]

Дзен-трансгуманист,
Да вроде получаецо: трансформируем в base 64, затем в LWZ по основанию 64, *щас упираюсь(точнее отложено) совместить без перехода в скрипте базе 64 в символьный вид(оставить чисто числовым массивом и тогда и lwz переделать на вход не символов, а массива цифр
Cжатие на длином тексте порядка двух
на коротком 1.4 (хотя тут на коротких наверно разброс поди

[Deff]

Дзен-трансгуманист,
Гы тут суть чтобы свести именно LWZ по модулю 64, а не повторная трансформация через base64
Используемый base64

<script>
/**
*
*  Base64 encode / decode
*  [url]http://www.webtoolkit.info/[/url]
*
**/

var Base64 = {

	// private property
	_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",

	// public method for encoding
	encode : function (input) {
		var output = "";
		var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
		var i = 0;

		input = Base64._utf8_encode(input);

		while (i < input.length) {

			chr1 = input.charCodeAt(i++);
			chr2 = input.charCodeAt(i++);
			chr3 = input.charCodeAt(i++);

			enc1 = chr1 >> 2;
			enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
			enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
			enc4 = chr3 & 63;

			if (isNaN(chr2)) {
				enc3 = enc4 = 64;
			} else if (isNaN(chr3)) {
				enc4 = 64;
			}

			output = output +
			this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
			this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);

		}

		return output;
	},

	// public method for decoding
	decode : function (input) {
		var output = "";
		var chr1, chr2, chr3;
		var enc1, enc2, enc3, enc4;
		var i = 0;

		input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

		while (i < input.length) {

			enc1 = this._keyStr.indexOf(input.charAt(i++));
			enc2 = this._keyStr.indexOf(input.charAt(i++));
			enc3 = this._keyStr.indexOf(input.charAt(i++));
			enc4 = this._keyStr.indexOf(input.charAt(i++));

			chr1 = (enc1 << 2) | (enc2 >> 4);
			chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
			chr3 = ((enc3 & 3) << 6) | enc4;

			output = output + String.fromCharCode(chr1);

			if (enc3 != 64) {
				output = output + String.fromCharCode(chr2);
			}
			if (enc4 != 64) {
				output = output + String.fromCharCode(chr3);
			}

		}

		output = Base64._utf8_decode(output);

		return output;

	},

	// private method for UTF-8 encoding
	_utf8_encode : function (string) {
		string = string.replace(/\r\n/g,"\n");
		var utftext = "";

		for (var n = 0; n < string.length; n++) {

			var c = string.charCodeAt(n);

			if (c < 128) {
				utftext += String.fromCharCode(c);
			}
			else if((c > 127) && (c < 2048)) {
				utftext += String.fromCharCode((c >> 6) | 192);
				utftext += String.fromCharCode((c & 63) | 128);
			}
			else {
				utftext += String.fromCharCode((c >> 12) | 224);
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
				utftext += String.fromCharCode((c & 63) | 128);
			}

		}

		return utftext;
	},

	// private method for UTF-8 decoding
	_utf8_decode : function (utftext) {
		var string = "";
		var i = 0;
		var c = c1 = c2 = 0;

		while ( i < utftext.length ) {

			c = utftext.charCodeAt(i);

			if (c < 128) {
				string += String.fromCharCode(c);
				i++;
			}
			else if((c > 191) && (c < 224)) {
				c2 = utftext.charCodeAt(i+1);
				string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
				i += 2;
			}
			else {
				c2 = utftext.charCodeAt(i+1);
				c3 = utftext.charCodeAt(i+2);
				string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
				i += 3;
			}

		}

		return string;
	}

}
</script>

LZW

<script type="text/javascript">
// LZW-compress a string
function lzw_encode(s) {
    var dict = {};
    var data = (s + "").split("");
    var out = [];
    var currChar;
    var phrase = data[0];
*!*
    var code = 256;
*/!*
    for (var i=1; i<data.length; i++) {
        currChar=data[i];
        if (dict[phrase + currChar] != null) {
            phrase += currChar;
        }
        else {
            out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
            dict[phrase + currChar] = code;
            code++;
            phrase=currChar;
        }
    }
    out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
    for (var i=0; i<out.length; i++) {
        out[i] = String.fromCharCode(out[i]);
    }
    return out.join("");
}

// Decompress an LZW-encoded string
function lzw_decode(s) {
    var dict = {};
    var data = (s + "").split("");
    var currChar = data[0];
    var oldPhrase = currChar;
    var out = [currChar];
    var code = 256;
    var phrase;
    for (var i=1; i<data.length; i++) {
        var currCode = data[i].charCodeAt(0);
        if (currCode < 256) {
            phrase = data[i];
        }
        else {
           phrase = dict[currCode] ? dict[currCode] : (oldPhrase + currChar);
        }
        out.push(phrase);
        currChar = phrase.charAt(0);
        dict[code] = oldPhrase + currChar;
        code++;
        oldPhrase = phrase;
    }
    return out.join("");
}
</script>

Вообщем везде , где 256
Для этого Выход первичного base64 и вход LWZ нужно переделать под цифровой массив 0-63 - дабы не создавать лишней конверсии

[Deff]

Да, это LZW, но он превращает одну строку в другую. То есть из юникода получается снова юникод. Зачем поднимать избыточность данных?

Это байтовый пакер, суть в том, что последующие фразы кодируюца двумя символами, при достижении двух -тремя - и т.д, основание - не суть... Код рабочий...*Давно рабочий

Да, это LZW, но он превращает одну строку в другую. То есть из юникода получается снова юникод. Зачем поднимать избыточность данных?

Суть в том, чтобы переделать из байтового, в 64 вход и выход!
Ну я почти добил(неделю назад, - *осталось переработать кривоватый собственный код, в чём собственно и траблы(трансформирующий выше приведенное) - общее сжатие из длинной исходной строки с последующим base64 + LWZ c основанием 64 порядка 70% , что вполне хватает для достижения нужного, но пока это для длинных строк(насколько ухудшается для более коротких, длинной в 2000 в 2500 пока, - это в полной мере не тестировал...
Скорости длинных строк - приличные, страница - менее секунды

Пока нет возможности добить до красоты кода, озадачили иной работой

[Deff]

По отношению к кодам UTF-8 сжатие ощутимо лучше, чем по отношению к Base64.

у LWZ -при равных входной-выходной разрядности данных - на длинных строках сжатие порядка двух - независимо от входной разрядности,
это чисто за счёт статистики строки при нормальном распределении.(естественно при большей выходной разрядности, чем входной (*реально входная у нас 64 или 2 в 6 cтепени) - сжатие лучше, но последущее выкривлениее 256 в base 64 убьёт эту всю выгоду!

[Deff]

Зависимо. Я пробовал 1-битную. Получилось хуже всего.

Ну это естественно, словарик то растёт, но при своём утверждении я его в расчет не брал - говоря о достаточно длинных тестах, где практически верно утверждение про двойку(В своих тестах тестировал кодирование/декодирование HTML страницы

[Deff]

Мои текущие цифры таковы.

На самом деле входная последовательность(не считая точек и пробелов) двух байтовая и итоговый Вами продемонстрированный выход практически устраивает, не хватает тестов на реальной входной длине в 2000 2500 байт

Усложнять код не желательно, поскольку межфреймовый обмен может включать в себя и передачу длинных текстовых файлов, что оставляет пожелания достаточно высокой скорости кодирования декодирования

[Deff]

Дзен-трансгуманист, +
Забавно (Но мну все таки ограничится LWZ - c выходом base64 (Да и по Вашим графикам - интересующий диапазон символьной длины дает прогресс ужатия при LZWR весьма небольшой, а поскольку процесс использования будет скорее всего циклическим и
с высокой скоростью - важна скорость кодирования/декодирования;

[Deff]

"Исходный текст → URF → LZW → Base64"

- имхо такая цепочка уже реализована - пока меня - не устраивает

Из всего Вышепредложенного интерес остается к данной реализации:

UTF-8 → LZW → Base64: 32979 39864 2587 128719 507 (символов ASCII)

интересен итоговый рабочий код - сравнить со своими наработками.