Создайте "чангсет" из двух байтов

Question

У меня есть некоторые двоичные данные. Я буду менять со временем, некоторые байты добавляются тут и там, некоторые меняются. В целом большая часть bytearray остается неизменной.

Есть ли какая-либо библиотека, предпочтительно Actionscript 3, которая генерирует "changeset" (есть ли лучшее название для этого?) Из двух байтовых массивов. Также следует разрешить мне применить набор изменений к байтовому массиву и вернуть полученный новый байтовый массив.

Имеет ли это смысл? Я не был уверен, как лучше сформулировать мою проблему.

РЕДАКТИРОВАТЬ для уточнения:

То, что я хочу, - это то, что только испускает изменения, таким образом делая "набор изменений" как можно меньше. Таким образом, если изменился только 1 КБ двоичного файла размером 1 МБ, набор изменений должен быть байтовым массивом размером около 1 КБ.

РЕДАКТИРОВАТЬ:

В основном мне нужна версия AS3 http://www.daemonology.net/bsdiff/ я думаю

Answer 1

Я не знаю какой-либо библиотеки AS3 для этого, но если я вас правильно понял, кодирование с нуля не так сложно и отнимает много времени, как вы думаете. Вот мой (наивный) подход к этому. Может быть, это уже соответствует вашим потребностям.

Пример вывода

Код

package {
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.utils.ByteArray;

    public class Main extends Sprite {

        public function Main():void {
            if (stage)
                init();
            else
                addEventListener(Event.ADDED_TO_STAGE, init);
        }


        private function createDiff(original:ByteArray, comparedTo:ByteArray):ByteArray {
            var diff:ByteArray = new ByteArray();
            var length:uint = Math.min(original.length, comparedTo.length);
            original.position = 0;
            comparedTo.position = 0;
            for (var i:int = 0; i < length; i++) {
                var byteOriginal:int = original.readByte();
                var byteComparedTo:int = comparedTo.readByte();
                if (byteOriginal != byteComparedTo) {
                    diff.writeByte(byteComparedTo - byteOriginal);
                }
                else {
                    diff.writeByte(0);
                }
            }
            diff.compress();
            return diff;
        }

        private function applyDiff(original:ByteArray, diff:ByteArray):ByteArray {
            var result:ByteArray = new ByteArray();
            diff.uncompress();
            original.position = 0;
            diff.position = 0;
            var length:uint = Math.min(original.length, diff.length);
            for (var i:uint = 0; i < length; i++) {
                var byteOriginal:int = original.readByte();
                var byteDiff:int = diff.readByte();
                result.writeByte(byteOriginal + byteDiff);
            }
            return result;
        }

        private function init(e:Event = null):void {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            // generate one random byte array and a slightly different variant
            var length:uint = 128;
            var a:ByteArray = new ByteArray();
            var b:ByteArray = new ByteArray();
            for (var i:int = 0; i < length; i++) {
                var value:int;
                value = 127 - Math.floor(Math.random() * 256);
                a.writeByte(value);
                if (value > 64) {
                    value = 127 - Math.floor(Math.random() * 256);
                }
                b.writeByte(value);
            }
            // create a diff and apply it to the original byte array for verification
            var diff:ByteArray = createDiff(a, b);
            var result:ByteArray = applyDiff(a, diff);
            // trace the byte arrays
            a.position = 0;
            b.position = 0;
            diff.position = 0;
            result.position = 0;
            var outputA:String = "";
            var outputB:String = "";
            var outputDiff:String = "";
            var outputResult:String = "";
            for (var k:int = 0; k < length; k++) {
                outputA += a.readByte() + "\t";
                outputB += b.readByte() + "\t";
                outputDiff += diff.readByte() + "\t";
                outputResult += result.readByte() + "\t";
            }
            trace("1st: \t" + outputA);
            trace("2nd: \t" + outputB);
            trace("diff:\t" + outputDiff);
            trace("test:\t" + outputResult);
        }

    }

}