Изучаем структуру zip архива и пишем миниатюрную реализацию архиватора

D2

D2

Администратор
Регистрация
19 Фев 2025
Сообщения
4,380
Реакции
0
Автор H2SO4
Источник https://xss.is/threads/120756/

zip-files-win-10.jpg



0. INTRO
Всем привет, в этой статье хочу показать из чего состоит zip-архив, наглядно продемонстрировать внутреннюю структуру и написать простую реализацию архиватора на си в виде header-only library.
Релизовывать будем именно миниатюрный, минимально возможный вариант архиватора, который будет соотвествовать спецификации. В нем будет поддержка имен файлов в utf-8, возможность указывать комментарий к архиву, не будет зависимости от библиотеки zlib, а сам код будет кросс-платформенным.
В статье я буду ссылаться на спецификацию формата zip: .ZIP File Format Specification

1. Структура zip-файла.
ZIP-файл это бинарный файл который можно условно поделить на 3 блока. В первом блоке содержатся сжатые данные, во втором содержатся описания данных и смещения на данные в первом блоке, в третьем содержатся количество файлов и смещение на второй блок. Давайте определим 3 важные структуры, которые нам в дальнейшем помогут разобраться:
Local file header:
local file header signature 4 bytes (0x04034b50)
version needed to extract 2 bytes
general purpose bit flag 2 bytes
compression method 2 bytes
last mod file time 2 bytes
last mod file date 2 bytes
crc-32 4 bytes
compressed size 4 bytes
uncompressed size 4 bytes
file name length 2 bytes
extra field length 2 bytes


Central directory record:
central file header signature 4 bytes (0x02014b50)
version made by 2 bytes
version needed to extract 2 bytes
general purpose bit flag 2 bytes
compression method 2 bytes
last mod file time 2 bytes
last mod file date 2 bytes
crc-32 4 bytes
compressed size 4 bytes
uncompressed size 4 bytes
file name length 2 bytes
extra field length 2 bytes
file comment length 2 bytes
disk number start 2 bytes
internal file attributes 2 bytes
external file attributes 4 bytes
relative offset of local header 4 bytes

End of central directory record:
end of central dir signature 4 bytes (0x06054b50)
number of this disk 2 bytes
number of the disk with the
start of the central directory 2 bytes
total number of entries in the
central directory on this disk 2 bytes
total number of entries in
the central directory 2 bytes
size of the central directory 4 bytes
offset of start of central
directory with respect to
the starting disk number 4 bytes
.ZIP file comment length 2 bytes
Нажмите, чтобы раскрыть...
Нажмите для раскрытия...

Сразу же обозначим их на языке C:
C: Скопировать в буфер обмена
Код: 
#pragma pack(push, 1)
struct LocalFileHeader
{
    uint32_t signature;
    uint16_t versionToExtract;
    uint16_t generalPurposeBitFlag;
    uint16_t compressionMethod;
    uint16_t modificationTime;
    uint16_t modificationDate;
    uint32_t crc32;
    uint32_t compressedSize;
    uint32_t uncompressedSize;
    uint16_t filenameLength;
    uint16_t extraFieldLength;

};
#pragma pack(pop)

#pragma pack(push, 1)
struct CentralDirectoryFileHeader
{
    uint32_t signature;
    uint16_t versionMadeBy;
    uint16_t versionToExtract;
    uint16_t generalPurposeBitFlag;
    uint16_t compressionMethod;
    uint16_t modificationTime;
    uint16_t modificationDate;
    uint32_t crc32;
    uint32_t compressedSize;
    uint32_t uncompressedSize;
    uint16_t filenameLength;
    uint16_t extraFieldLength;
    uint16_t fileCommentLength;
    uint16_t diskNumber;
    uint16_t internalFileAttributes;
    uint32_t externalFileAttributes;
    uint32_t localFileHeaderOffset;

};
#pragma pack(pop)

#pragma pack(push, 1)
struct EndOfCentralDirectory
{
    uint32_t signature;
    uint16_t diskNumber;
    uint16_t startDiskNumber;
    uint16_t numberCentralDirectoryRecord;
    uint16_t totalCentralDirectoryRecord;
    uint32_t sizeOfCentralDirectory;
    uint32_t centralDirectoryOffset;
    uint16_t commentLength;

};
#pragma pack(pop)

И константы:
C: Скопировать в буфер обмена
Код: 
#define ZIP_LOCAL_HEADER   0x04034b50
#define ZIP_CENTRAL_HEADER   0x02014b50
#define ZIP_END_CENTRAL_HEADER   0x06054b50

Давайте посмотрим как будет выглядеть zip-архив, в котором будет только один файл text.txt.
Создадим файл 'text.txt' с текстом 'xss.is' и упакуем в архив 'zip1.zip'

Bash: Скопировать в буфер обмена
echo xss.is > text.txt & zip -X -m zip1.zip text.txt

Теперь посмотрим на файл в hex-редакторе:
1.png



Сразу же бросается в глаза повторяющиеся последовательности PK, это как-раз сигнатуры стрктур, которые определеные выше.
В самом начале файла мы видим байты '50 4B 03 04' - это сигнатура структуры LocalFileHeader. Давайте выделим всю структуру (30 байт):
2.png


Далее мы видим вполне читаемый текст: text.txtxss.is+'\n'. Это ничто иное как имя файла + тело файла.
3.png


Продолжаем двигаться по файлу: теперь перед нами структура CentralDirectoryFileHeader длиной 46 байт
4.png


И следом опять имя файла, но уже без данных:
5.png


Завершает файл структура EndOfCentralDirectory длиной 22 байта:
6.png


Теперь мы имеем общее представление того, как выглядит zip-архив содержащий один файл изнутри:
[LocalFileHeader]+[FILE_NAME]+[FILE_DATA]+[CentralDirectoryFileHeader]+[FILE_NAME]+[EndOfCentralDirectory]

Забегая на перед скажу, что если файлов в архиве будет несколько, архив будет выглядеть так:
[LocalFileHeader]+[FILE_NAME_0]+[FILE_DATA_0]+
[LocalFileHeader]+[FILE_NAME_1]+[FILE_DATA_1]+
[LocalFileHeader]+[FILE_NAME_2]+[FILE_DATA_2]+

[CentralDirectoryFileHeader]+[FILE_NAME_0]+
[CentralDirectoryFileHeader]+[FILE_NAME_1]+
[CentralDirectoryFileHeader]+[FILE_NAME_2]+

[EndOfCentralDirectory]

Внимательный читатель обратит внимание на то, что данные из файла у нас почему-то представлены в чистом виде, хотя по-идее они должны быть сжаты и выглядеть как 'кракозябры'. Дело в том, что сам файл у нас маленький, и если такой файл сжать, то как ни странно, занимать он будет больше места, чем несжатый. По этому архиватор решил файл не сжимать, а положить в архив как есть, указав на это в структурах LocalFileHeader и CentralDirectoryFileHeader, о чем я расскажу далее.

2. Разбираемся со структурами.
Так как мы собрались писать свой мини-архиватор, нам нужно чуть лучше разобраться со структурами LocalFileHeader, CentralDirectoryFileHeader и EndOfCentralDirectory и как их заполнять. Начнем с первой:

LocalFileHeader:
  • signature: сигнатура структуры, всегда должна быть 0x04034b50
  • versionToExtract: минимальная версия версия спецификации, которая будет поддерживать распаковку файла. В нашем тестовом архиве это поле указано как 10, что соответствует версии спецификации 1.0. Если бы наш файл в архиве был сжатым, то тут было бы 20.
  • general purpose bit flag: 2 байта, 16 бит, которые используются для информирования о различных типов сжатия, шифрования и т.д. Для реализации минимального архиватора нам нужно знать только про 11ый бит, взведя который мы укажем на то, что имена файлов закодированы в UTF-8.
  • compression method: уже интереснее - метод сжатия. В нашем архиве это поле равно 0. Если бы данные были сжаты алгоритмом deflate, то было бы 8.
  • last mod file time и last mod file date: время и дата модификации файла в формате MS-DOS. Можно смело забивать нулями.
  • crc-32: хэш-сумма НЕсжатого файла.
  • compressedSize и uncompressedSize: размер сжатого и несжатого файла в байтах. В нашем архиве эти поля одинаковы, но если файл был сжат, то compressedSize был бы меньше.
  • filenameLength: длина имени файла в байтах (не в символах)
  • extra field length: длина дополнительных полей для более поздних спецификаций, нам этого не надо, поставим 0
CentralDirectoryFileHeader:
Большинство полей дублируются, часть нам не нужны, остальные такие:
  • central file header signature: сигнатура структуры, всегда должна быть 0x02014b50
  • version made by: поле, которое описывает сразу два значения. Впервом байте кодируется версия спецификации, которой был упакован наш файл, а во втором вид файловой системы, на которой был файл. Например: 0 - MS-DOS, 3 - UNIX, 10 - Windows NTFS, 19 - OS X. Это нужно чтобы сохранить атрибуты файлов. Но для нашей мини-реализации атрибуты нам не нужны, по этому просто будем записывать сюда значения 63 и 3 (831 в виде uint16_t)
  • relative offset of local header: смещение на структуру LocalFileHeader, в нашем случае от начала файла.
В дублирующиеся поля нужно будет записать такие же значение, что и в LocalFileHeader, остальные можно занулить

EndOfCentralDirectory:
  • end of central dir signature: сигнатура структуры, всегда должна быть 0x06054b50
  • start of the central directory: смещение, опять же в нашем случае от начала файла, на первый CentralDirectoryFileHeader.
  • total number of entries in the central directory on this disk и total number of entries in the central directory: сюда запишем суммарное количество файлов в архиве
  • size of the central directory: суммарный размер central directory, того условного второго блока, в котором структуры CentralDirectoryFileHeader и имена файлов.
  • .ZIP file comment length: длина комментария zip-архива. После этой структуры можно написать любой текст, и в это поле указать его длину. Комментарий отобразится окне архиватора.

3. Сжатие данных
Стандартным вариантом сжатия для zip-архивов является метод Deflate. По мере развития формата также добавлялись алгоритмы Deflate64, PKWARE DCL Implode, BZIP2, LZMA и PPMd+.
В нашей реализации мы будем использовать Deflate. Писать самим алгоритм сжатия дело долгое, по этому мы просто позаимствуем его отсюда: https://github.com/vurtun/lib/blob/master/sdefl.h

Как сжать данные? Просто передаем в функцию нужные параметры:

C: Скопировать в буфер обмена
extern int sdeflate(struct sdefl *s, void *out, const void *in, int n, int lvl)

sdefl *s - структура, необходимая для работы алгоритма
void *out - буфер, куда запишутся сжатые данные. Нам нужно выделить под него память
void *in - указатель на сжимаемые данные
int n - размер данных
int lvl - уровень сжатия
Функция возвращает размер сжатых данных.

А как узнать, сколько выделить памяти под сжатые данные? Для этого есть функция sdefl_bound, в которую нужно передать размер входного буфера. Она вернет максимальный потенциально-возможный размер сжатых данных в байтах.
В итоге сжимать входной буфер мы будем такой функцией:

C: Скопировать в буфер обмена
Код: 
void* compress_buffer(const void *buffer, uint32_t size, uint32_t *destLen)
{
    static struct sdefl sdefl;
    void* cbuffer = malloc(sdefl_bound(size));
    *destLen = sdeflate(&sdefl, cbuffer, buffer, size, SDEFL_LVL_DEF);
    return cbuffer;
}

4. Пишем архиватор
Теперь у нас перед глазами есть картина того как нужно формировать zip-архив.
Давайте составим алгоритм действий для архива, состоящего из одного файла:

  1. Выделяем какой-нибудь общий буфер, общий для всего архива, куда будем писать данные.
  2. Считаем crc32-хеш входного файла.
  3. Сжимаем файл алгоритмом Deflate.
  4. Заполняем структуру LocalFileHeader.
  5. Записываем LocalFileHeader в буфер.
  6. Записывем имя файла в буфер.
  7. Записываем сжатые данные в буфер.
  8. Заполняем и записывем в буфер структуру CentralDirectoryFileHeader.
  9. Опять записывем имя файла в буфер.
  10. Заполняем и записывем в буфер структуру EndOfCentralDirectory.

Для того чтобы записывать в архив много файлов, удобнее выделить два буфера:
В первый буфер мы будем записывать [LocalFileHeader_N]+[FILE_NAME_N]+[FILE_DATA_N]
Во второй [CentralDirectoryFileHeader_N]+[FILE_NAME_N]

При этом не забывая подсчитывать количество добавленных в архив файлов.
Перед тем как сохранить архив на диск, или отправить его куда-нибудь по сети, нужно будет перенести даннные из второго буфера в первый и дописать туда же заполненную структуру EndOfCentralDirectory.

Приступим к реализации

Объявим структуру в которой будем хранить всё нужное для нашего архива:
C: Скопировать в буфер обмена
Код: 
typedef struct pico_zip
{
    uint16_t filesCount;
    void* buffer;
    void* cdfh_buffer;

    uint32_t buffer_size;
    uint32_t cdfh_buffer_size;
    bool isFinalized;
} pico_zip;


Функция инициализации. Выделяет память под нашу структуру pico_zip и возвращает указатель

C: Скопировать в буфер обмена
Код: 
pico_zip * pico_zip_init()
{
    pico_zip * p_zip = (pico_zip *) malloc(sizeof(pico_zip));
    memset(p_zip, 0, sizeof(pico_zip));
    p_zip->filesCount = 0;
    p_zip->isFinalized = false;

    return p_zip;
};

Вспомогательная функция append_buffer. Принимает два буфера с их размерами. Добавляет данные из второго буфера в первый.
C: Скопировать в буфер обмена
Код: 
void * append_buffer(void **buffer, uint32_t *size, const void *in_buffer, uint32_t in_size)
{
    void * tmp = realloc(*buffer, *size + in_size);
    memcpy((char *)tmp+*size, in_buffer, in_size);
    *size += in_size;
    *buffer = tmp;
    return tmp;
};


Функция pico_zip_pack. Это, собственно, то ради чего мы все здесь собрались.
Передаем в нее имя файла, сам файл и его размер, она все посчитает и запишет куда надо.
Имя файла в кодировке UTF-8, можно использовать "/" в имени, для создания каталогов в архиве, например "dir/subdir/file.txt"

C: Скопировать в буфер обмена
Код: 
int pico_zip_pack(pico_zip * p_zip, const char *filename, const void *buffer, uint32_t size)
{
    uint32_t compressedSize = 0;
    void* cbuffer = compress_buffer(buffer, size, &compressedSize);
    if (cbuffer == NULL) return 1;


    struct LocalFileHeader lfh;
    struct CentralDirectoryFileHeader cdfh;
    memset(&lfh, 0, sizeof(lfh));
    memset(&cdfh, 0, sizeof(cdfh));

    lfh.signature = ZIP_LOCAL_HEADER;
    cdfh.signature = ZIP_CENTRAL_HEADER;
    lfh.versionToExtract = ZIP_VER_TO_EXTRACT;

    lfh.crc32 = crc32((unsigned char *)buffer, size);
    lfh.compressionMethod = Z_DEFLATED;
    lfh.compressedSize = compressedSize;
    lfh.uncompressedSize = size;
    lfh.filenameLength = strlen(filename);
    lfh.generalPurposeBitFlag = 1 << 11;

    cdfh.versionToExtract = lfh.versionToExtract;
    cdfh.versionMadeBy = ZIP_VER_MADE_BY;
    cdfh.compressedSize =lfh.compressedSize;
    cdfh.uncompressedSize = lfh.uncompressedSize;
    cdfh.compressionMethod = lfh.compressionMethod;
    cdfh.crc32 = lfh.crc32;
    cdfh.filenameLength = lfh.filenameLength;
    cdfh.generalPurposeBitFlag = lfh.generalPurposeBitFlag;
    cdfh.localFileHeaderOffset = p_zip->buffer_size;


    append_buffer(&p_zip->buffer, &p_zip->buffer_size, &lfh, sizeof(lfh));
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, (void* )filename, strlen(filename));
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, cbuffer, compressedSize);
    p_zip->filesCount++;
 
    append_buffer(&p_zip->cdfh_buffer, &p_zip->cdfh_buffer_size, &cdfh, sizeof(cdfh));
    append_buffer(&p_zip->cdfh_buffer, &p_zip->cdfh_buffer_size, (void* )filename, strlen(filename));
 
    free(cbuffer);
    return 0;
};


Функция pico_zip_finalize. Её нужно вызвать перед тем как мы закончим работу с архивом. Она соединит все наши буферы в один и сформирует EndOfCentralDirectory.
Так же в нее можно передать комментарий для архива
C: Скопировать в буфер обмена
Код: 
int pico_zip_finalize(pico_zip * p_zip, const char *comment){
    struct EndOfCentralDirectory eocd;
    memset(&eocd, 0, sizeof(eocd));
    eocd.signature = ZIP_END_CENTRAL_HEADER;
    eocd.centralDirectoryOffset = p_zip -> buffer_size;
    eocd.numberCentralDirectoryRecord = p_zip -> filesCount;
    eocd.totalCentralDirectoryRecord = p_zip -> filesCount;
    eocd.sizeOfCentralDirectory = p_zip -> cdfh_buffer_size;
    eocd.commentLength=strlen(comment);
 
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, p_zip->cdfh_buffer, p_zip->cdfh_buffer_size);
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, (void*)&eocd, sizeof(eocd));
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, (void*)comment, eocd.commentLength);
    p_zip -> isFinalized = true;
    return 0;
};


Ну и после того как закончили с архивом не забудем освободить память функцией pico_zip_free
C: Скопировать в буфер обмена
Код: 
int pico_zip_free(pico_zip * p_zip){
    free(p_zip -> cdfh_buffer);
    free(p_zip -> buffer);
    p_zip -> filesCount = 0;
    p_zip -> buffer_size = 0;
    p_zip -> cdfh_buffer_size = 0;
    p_zip -> isFinalized = false;
};


Теперь осталось объединить исходный код библиотеки sdefl.h с нашим кодом и у нас получится итоговая header-only library.

Пример использования:

C: Скопировать в буфер обмена
Код: 
#include <stdio.h>
#include <stdlib.h>
#include "pico_zip.h"


int main(int argc, char *argv[])
{
    char * data = "Hello from XSS.IS";
    char * data1 = "AAAAAAAAAAAAAAAAA";
    pico_zip * zip = pico_zip_init();
    pico_zip_pack(zip, "xss.is.txt", (void *)data, strlen(data));
    pico_zip_pack(zip, "йцукен/こんにちは.txt", (void *)data1, strlen(data1));
    pico_zip_finalize(zip, "Comment-48949d91d9ew19ewf");
 
    FILE *output = NULL;
    output = fopen("output.zip", "wb");
    fwrite(zip->buffer, zip->buffer_size, 1, output);
    fclose(output);
 
    pico_zip_free(zip);
    return 0;
}

Компилируем, исполняем, смотрим:
7.png


Bash: Скопировать в буфер обмена
unzip -l output.zip

Bash: Скопировать в буфер обмена
Код: 
Archive:  output.zip
Comment-48949d91d9ew19ewf
  Length      Date    Time    Name
---------  ---------- -----   ----
       17  1980-00-00 00:00   xss.is.txt
       17  1980-00-00 00:00   йцукен/こんにちは.txt
---------                     -------
       34                     2 files

В полученом архиве мы можем заметить интересный момент, как строка 'Hello from XSS.IS' в сжатом виде заняла на 5 байтов больше места чем несжатая. При этом 'AAAAAAAAAAAAAAAAA' сжалась (но всего на 2 байта).
По правильному это лучше обрабатывать и записывать в архив то, что занимает меньше места, но это мы оставим на совести читателей.


5. Итог.

В этой статье мы узнали внутренности zip-архива и научились самостоятельно архивировать файлы с помощью собственной библиотеки. Библиотека получилась миниатюрная, меньше 1000 строк, где ~70 процентов занимает алгоритм сжатия, а код для архивации оставшиеся ~30 процентов. Полный исходный код прикреплен ниже.

Спойлер: pico_zip.h
C: Скопировать в буфер обмена
Код: 
#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>

////////////////
//from https://github.com/vurtun/lib/blob/master/sdefl.h

/*# Small Deflate
`sdefl` is a small bare bone lossless compression library in ANSI C (ISO C90)
which implements the Deflate (RFC 1951) compressed data format specification standard.
It is mainly tuned to get as much speed and compression ratio from as little code
as needed to keep the implementation as concise as possible.

## Features
- Portable single header and source file duo written in ANSI C (ISO C90)
- Dual license with either MIT or public domain
- Small implementation
    - Deflate: 525 LoC
    - Inflate: 320 LoC
- Webassembly:
    - Deflate ~3.7 KB (~2.2KB compressed)
    - Inflate ~3.6 KB (~2.2KB compressed)

## Usage:
This file behaves differently depending on what symbols you define
before including it.

Header-File mode:
If you do not define `SDEFL_IMPLEMENTATION` before including this file, it
will operate in header only mode. In this mode it declares all used structs
and the API of the library without including the implementation of the library.

Implementation mode:
If you define `SDEFL_IMPLEMENTATION` before including this file, it will
compile the implementation . Make sure that you only include
this file implementation in *one* C or C++ file to prevent collisions.

### Benchmark

| Compressor name         | Compression| Decompress.| Compr. size | Ratio |
| ------------------------| -----------| -----------| ----------- | ----- |
| miniz 1.0 -1            |   122 MB/s |   208 MB/s |    48510028 | 48.51 |
| miniz 1.0 -6            |    27 MB/s |   260 MB/s |    36513697 | 36.51 |
| miniz 1.0 -9            |    23 MB/s |   261 MB/s |    36460101 | 36.46 |
| zlib 1.2.11 -1          |    72 MB/s |   307 MB/s |    42298774 | 42.30 |
| zlib 1.2.11 -6          |    24 MB/s |   313 MB/s |    36548921 | 36.55 |
| zlib 1.2.11 -9          |    20 MB/s |   314 MB/s |    36475792 | 36.48 |
| sdefl 1.0 -0            |   127 MB/s |   355 MB/s |    40004116 | 39.88 |
| sdefl 1.0 -1            |   111 MB/s |   413 MB/s |    38940674 | 38.82 |
| sdefl 1.0 -5            |    45 MB/s |   436 MB/s |    36577183 | 36.46 |
| sdefl 1.0 -7            |    38 MB/s |   432 MB/s |    36523781 | 36.41 |
| libdeflate 1.3 -1       |   147 MB/s |   667 MB/s |    39597378 | 39.60 |
| libdeflate 1.3 -6       |    69 MB/s |   689 MB/s |    36648318 | 36.65 |
| libdeflate 1.3 -9       |    13 MB/s |   672 MB/s |    35197141 | 35.20 |
| libdeflate 1.3 -12      |  8.13 MB/s |   670 MB/s |    35100568 | 35.10 |

### Compression
Results on the [Silesia compression corpus](http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia):

| File    |   Original | `sdefl 0`    | `sdefl 5`  | `sdefl 7`   |
| --------| -----------| -------------| ---------- | ------------|
| dickens | 10.192.446 | 4,260,187    |  3,845,261 |   3,833,657 |
| mozilla | 51.220.480 | 20,774,706   | 19,607,009 |  19,565,867 |
| mr      |  9.970.564 | 3,860,531    |  3,673,460 |   3,665,627 |
| nci     | 33.553.445 | 4,030,283    |  3,094,526 |   3,006,075 |
| ooffice |  6.152.192 | 3,320,063    |  3,186,373 |   3,183,815 |
| osdb    | 10.085.684 | 3,919,646    |  3,649,510 |   3,649,477 |
| reymont |  6.627.202 | 2,263,378    |  1,857,588 |   1,827,237 |
| samba   | 21.606.400 | 6,121,797    |  5,462,670 |   5,450,762 |
| sao     |  7.251.944 | 5,612,421    |  5,485,380 |   5,481,765 |
| webster | 41.458.703 | 13,972,648   | 12,059,432 |  11,991,421 |
| xml     |  5.345.280 | 886,620      |    674,009 |     662,141 |
| x-ray   |  8.474.240 | 6,304,655    |  6,244,779 |   6,244,779 |

## License
```
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2020-2023 Micha Mettke
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
```
*/

#ifdef __cplusplus
extern "C" {
#endif

#define SDEFL_MAX_OFF   (1 << 15)
#define SDEFL_WIN_SIZ   SDEFL_MAX_OFF
#define SDEFL_WIN_MSK   (SDEFL_WIN_SIZ-1)

#define SDEFL_HASH_BITS 15
#define SDEFL_HASH_SIZ  (1 << SDEFL_HASH_BITS)
#define SDEFL_HASH_MSK  (SDEFL_HASH_SIZ-1)

#define SDEFL_MIN_MATCH 4
#define SDEFL_BLK_MAX   (256*1024)
#define SDEFL_SEQ_SIZ   ((SDEFL_BLK_MAX+2)/3)

#define SDEFL_SYM_MAX   (288)
#define SDEFL_OFF_MAX   (32)
#define SDEFL_PRE_MAX   (19)

#define SDEFL_LVL_MIN   0
#define SDEFL_LVL_DEF   5
#define SDEFL_LVL_MAX   8

struct sdefl_freq {
  unsigned lit[SDEFL_SYM_MAX];
  unsigned off[SDEFL_OFF_MAX];
};
struct sdefl_code_words {
  unsigned lit[SDEFL_SYM_MAX];
  unsigned off[SDEFL_OFF_MAX];
};
struct sdefl_lens {
  unsigned char lit[SDEFL_SYM_MAX];
  unsigned char off[SDEFL_OFF_MAX];
};
struct sdefl_codes {
  struct sdefl_code_words word;
  struct sdefl_lens len;
};
struct sdefl_seqt {
  int off, len;
};
struct sdefl {
  int bits, bitcnt;
  int tbl[SDEFL_HASH_SIZ];
  int prv[SDEFL_WIN_SIZ];

  int seq_cnt;
  struct sdefl_seqt seq[SDEFL_SEQ_SIZ];
  struct sdefl_freq freq;
  struct sdefl_codes cod;
};
extern int sdefl_bound(int in_len);
extern int sdeflate(struct sdefl *s, void *o, const void *i, int n, int lvl);

#ifdef __cplusplus
}
#endif




#define CHAR_BIT 8
#define SDEFL_NIL               (-1)
#define SDEFL_MAX_MATCH         258
#define SDEFL_MAX_CODE_LEN      (15)
#define SDEFL_SYM_BITS          (10u)
#define SDEFL_SYM_MSK           ((1u << SDEFL_SYM_BITS)-1u)
#define SDEFL_RAW_BLK_SIZE      (65535)
#define SDEFL_LIT_LEN_CODES     (14)
#define SDEFL_OFF_CODES         (15)
#define SDEFL_PRE_CODES         (7)
#define SDEFL_CNT_NUM(n)        ((((n)+3u/4u)+3u)&~3u)
#define SDEFL_EOB               (256)

#define sdefl_npow2(n) (1 << (sdefl_ilog2((n)-1) + 1))
#define sdefl_div_round_up(n,d) (((n)+((d)-1))/(d))

static int
sdefl_ilog2(int n) {
  if (!n) return 0;
#ifdef _MSC_VER
  unsigned long msbp = 0;
  _BitScanReverse(&msbp, (unsigned long)n);
  return (int)msbp;
#elif defined(__GNUC__) || defined(__clang__)
  return (int)sizeof(unsigned long) * CHAR_BIT - 1 - __builtin_clzl((unsigned long)n);
#else
  #define lt(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
  static const char tbl[256] = {
    0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,lt(4), lt(5), lt(5), lt(6), lt(6), lt(6), lt(6),
    lt(7), lt(7), lt(7), lt(7), lt(7), lt(7), lt(7), lt(7)};
  int tt, t;
  if ((tt = (n >> 16))) {
    return (t = (tt >> 8)) ? 24 + tbl[t] : 16 + tbl[tt];
  } else {
    return (t = (n >> 8)) ? 8 + tbl[t] : tbl[n];
  }
  #undef lt
#endif
}
static unsigned
sdefl_uload32(const void *p) {
  /* hopefully will be optimized to an unaligned read */
  unsigned n = 0;
  memcpy(&n, p, sizeof(n));
  return n;
}
static unsigned
sdefl_hash32(const void *p) {
  unsigned n = sdefl_uload32(p);
  return (n * 0x9E377989) >> (32 - SDEFL_HASH_BITS);
}
static void
sdefl_put(unsigned char **dst, struct sdefl *s, int code, int bitcnt) {
  s->bits |= (code << s->bitcnt);
  s->bitcnt += bitcnt;
  while (s->bitcnt >= 8) {
    unsigned char *tar = *dst;
    *tar = (unsigned char)(s->bits & 0xFF);
    s->bits >>= 8;
    s->bitcnt -= 8;
    *dst = *dst + 1;
  }
}
static void
sdefl_heap_sub(unsigned A[], unsigned len, unsigned sub) {
  unsigned c, p = sub;
  unsigned v = A[sub];
  while ((c = p << 1) <= len) {
    if (c < len && A[c + 1] > A[c]) c++;
    if (v >= A[c]) break;
    A[p] = A[c], p = c;
  }
  A[p] = v;
}
static void
sdefl_heap_array(unsigned *A, unsigned len) {
  unsigned sub;
  for (sub = len >> 1; sub >= 1; sub--)
    sdefl_heap_sub(A, len, sub);
}
static void
sdefl_heap_sort(unsigned *A, unsigned n) {
  A--;
  sdefl_heap_array(A, n);
  while (n >= 2) {
    unsigned tmp = A[n];
    A[n--] = A[1];
    A[1] = tmp;
    sdefl_heap_sub(A, n, 1);
  }
}
static unsigned
sdefl_sort_sym(unsigned sym_cnt, unsigned *freqs,
               unsigned char *lens, unsigned *sym_out) {
  unsigned cnts[SDEFL_CNT_NUM(SDEFL_SYM_MAX)] = {0};
  unsigned cnt_num = SDEFL_CNT_NUM(sym_cnt);
  unsigned used_sym = 0;
  unsigned sym, i;
  for (sym = 0; sym < sym_cnt; sym++)
    cnts[freqs[sym] < cnt_num-1 ? freqs[sym]: cnt_num-1]++;
  for (i = 1; i < cnt_num; i++) {
    unsigned cnt = cnts[i];
    cnts[i] = used_sym;
    used_sym += cnt;
  }
  for (sym = 0; sym < sym_cnt; sym++) {
    unsigned freq = freqs[sym];
    if (freq) {
        unsigned idx = freq < cnt_num-1 ? freq : cnt_num-1;
        sym_out[cnts[idx]++] = sym | (freq << SDEFL_SYM_BITS);
    } else lens[sym] = 0;
  }
  sdefl_heap_sort(sym_out + cnts[cnt_num-2], cnts[cnt_num-1] - cnts[cnt_num-2]);
  return used_sym;
}
static void
sdefl_build_tree(unsigned *A, unsigned sym_cnt) {
  unsigned i = 0, b = 0, e = 0;
  do {
    unsigned m, n, freq_shift;
    if (i != sym_cnt && (b == e || (A[i] >> SDEFL_SYM_BITS) <= (A[b] >> SDEFL_SYM_BITS)))
      m = i++;
    else m = b++;
    if (i != sym_cnt && (b == e || (A[i] >> SDEFL_SYM_BITS) <= (A[b] >> SDEFL_SYM_BITS)))
      n = i++;
    else n = b++;

    freq_shift = (A[m] & ~SDEFL_SYM_MSK) + (A[n] & ~SDEFL_SYM_MSK);
    A[m] = (A[m] & SDEFL_SYM_MSK) | (e << SDEFL_SYM_BITS);
    A[n] = (A[n] & SDEFL_SYM_MSK) | (e << SDEFL_SYM_BITS);
    A[e] = (A[e] & SDEFL_SYM_MSK) | freq_shift;
  } while (sym_cnt - ++e > 1);
}
static void
sdefl_gen_len_cnt(unsigned *A, unsigned root, unsigned *len_cnt,
                  unsigned max_code_len) {
  int n;
  unsigned i;
  for (i = 0; i <= max_code_len; i++)
    len_cnt[i] = 0;
  len_cnt[1] = 2;

  A[root] &= SDEFL_SYM_MSK;
  for (n = (int)root - 1; n >= 0; n--) {
    unsigned p = A[n] >> SDEFL_SYM_BITS;
    unsigned pdepth = A[p] >> SDEFL_SYM_BITS;
    unsigned depth = pdepth + 1;
    unsigned len = depth;

    A[n] = (A[n] & SDEFL_SYM_MSK) | (depth << SDEFL_SYM_BITS);
    if (len >= max_code_len) {
      len = max_code_len;
      do len--; while (!len_cnt[len]);
    }
    len_cnt[len]--;
    len_cnt[len+1] += 2;
  }
}
static void
sdefl_gen_codes(unsigned *A, unsigned char *lens, const unsigned *len_cnt,
                unsigned max_code_word_len, unsigned sym_cnt) {
  unsigned i, sym, len, nxt[SDEFL_MAX_CODE_LEN + 1];
  for (i = 0, len = max_code_word_len; len >= 1; len--) {
    unsigned cnt = len_cnt[len];
    while (cnt--) lens[A[i++] & SDEFL_SYM_MSK] = (unsigned char)len;
  }
  nxt[0] = nxt[1] = 0;
  for (len = 2; len <= max_code_word_len; len++)
    nxt[len] = (nxt[len-1] + len_cnt[len-1]) << 1;
  for (sym = 0; sym < sym_cnt; sym++)
    A[sym] = nxt[lens[sym]]++;
}
static unsigned
sdefl_rev(unsigned c, unsigned char n) {
  c = ((c & 0x5555) << 1) | ((c & 0xAAAA) >> 1);
  c = ((c & 0x3333) << 2) | ((c & 0xCCCC) >> 2);
  c = ((c & 0x0F0F) << 4) | ((c & 0xF0F0) >> 4);
  c = ((c & 0x00FF) << 8) | ((c & 0xFF00) >> 8);
  return c >> (16-n);
}
static void
sdefl_huff(unsigned char *lens, unsigned *codes, unsigned *freqs,
           unsigned num_syms, unsigned max_code_len) {
  unsigned c, *A = codes;
  unsigned len_cnt[SDEFL_MAX_CODE_LEN + 1];
  unsigned used_syms = sdefl_sort_sym(num_syms, freqs, lens, A);
  if (!used_syms) return;
  if (used_syms == 1) {
    unsigned s = A[0] & SDEFL_SYM_MSK;
    unsigned i = s ? s : 1;
    codes[0] = 0, lens[0] = 1;
    codes[i] = 1, lens[i] = 1;
    return;
  }
  sdefl_build_tree(A, used_syms);
  sdefl_gen_len_cnt(A, used_syms-2, len_cnt, max_code_len);
  sdefl_gen_codes(A, lens, len_cnt, max_code_len, num_syms);
  for (c = 0; c < num_syms; c++) {
    codes[c] = sdefl_rev(codes[c], lens[c]);
  }
}
struct sdefl_symcnt {
  int items;
  int lit;
  int off;
};
static void
sdefl_precode(struct sdefl_symcnt *cnt, unsigned *freqs, unsigned *items,
              const unsigned char *litlen, const unsigned char *offlen) {
  unsigned *at = items;
  unsigned run_start = 0;

  unsigned total = 0;
  unsigned char lens[SDEFL_SYM_MAX + SDEFL_OFF_MAX];
  for (cnt->lit = SDEFL_SYM_MAX; cnt->lit > 257; cnt->lit--)
    if (litlen[cnt->lit - 1]) break;
  for (cnt->off = SDEFL_OFF_MAX; cnt->off > 1; cnt->off--)
    if (offlen[cnt->off - 1]) break;

  total = (unsigned)(cnt->lit + cnt->off);
  memcpy(lens, litlen, sizeof(unsigned char) * (size_t)cnt->lit);
  memcpy(lens + cnt->lit, offlen, sizeof(unsigned char) * (size_t)cnt->off);
  do {
    unsigned len = lens[run_start];
    unsigned run_end = run_start;
    do run_end++; while (run_end != total && len == lens[run_end]);
    if (!len) {
      while ((run_end - run_start) >= 11) {
        unsigned n = (run_end - run_start) - 11;
        unsigned xbits =  n < 0x7f ? n : 0x7f;
        freqs[18]++;
        *at++ = 18u | (xbits << 5u);
        run_start += 11 + xbits;
      }
      if ((run_end - run_start) >= 3) {
        unsigned n = (run_end - run_start) - 3;
        unsigned xbits =  n < 0x7 ? n : 0x7;
        freqs[17]++;
        *at++ = 17u | (xbits << 5u);
        run_start += 3 + xbits;
      }
    } else if ((run_end - run_start) >= 4) {
      freqs[len]++;
      *at++ = len;
      run_start++;
      do {
        unsigned xbits = (run_end - run_start) - 3;
        xbits = xbits < 0x03 ? xbits : 0x03;
        *at++ = 16 | (xbits << 5);
        run_start += 3 + xbits;
        freqs[16]++;
      } while ((run_end - run_start) >= 3);
    }
    while (run_start != run_end) {
      freqs[len]++;
      *at++ = len;
      run_start++;
    }
  } while (run_start != total);
  cnt->items = (int)(at - items);
}
struct sdefl_match_codest {
  int ls, lc;
  int dc, dx;
};
static void
sdefl_match_codes(struct sdefl_match_codest *cod, int dist, int len) {
  static const short dxmax[] = {0,6,12,24,48,96,192,384,768,1536,3072,6144,12288,24576};
  static const unsigned char lslot[258+1] = {
    0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12,
    12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
    16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18,
    18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20,
    20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
    21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
    22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
    23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25,
    25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
    25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26,
    26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
    26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
    27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
    27, 27, 28
  };
  assert(len <= 258);
  assert(dist <= 32768);
  cod->ls = lslot[len];
  cod->lc = 257 + cod->ls;
  assert(cod->lc <= 285);

  cod->dx = sdefl_ilog2(sdefl_npow2(dist) >> 2);
  cod->dc = cod->dx ? ((cod->dx + 1) << 1) + (dist > dxmax[cod->dx]) : dist-1;
}
enum sdefl_blk_type {
  SDEFL_BLK_UCOMPR,
  SDEFL_BLK_DYN
};
static enum sdefl_blk_type
sdefl_blk_type(const struct sdefl *s, int blk_len, int pre_item_len,
               const unsigned *pre_freq, const unsigned char *pre_len) {
  static const unsigned char x_pre_bits[] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
  static const unsigned char x_len_bits[] = {0,0,0,0,0,0,0,0, 1,1,1,1,2,2,2,2,
    3,3,3,3,4,4,4,4, 5,5,5,5,0};
  static const unsigned char x_off_bits[] = {0,0,0,0,1,1,2,2, 3,3,4,4,5,5,6,6,
    7,7,8,8,9,9,10,10, 11,11,12,12,13,13};

  int dyn_cost = 0;
  int fix_cost = 0;
  int sym = 0;

  dyn_cost += 5 + 5 + 4 + (3 * pre_item_len);
  for (sym = 0; sym < SDEFL_PRE_MAX; sym++)
    dyn_cost += pre_freq[sym] * (x_pre_bits[sym] + pre_len[sym]);
  for (sym = 0; sym < 256; sym++)
    dyn_cost += s->freq.lit[sym] * s->cod.len.lit[sym];
  dyn_cost += s->cod.len.lit[SDEFL_EOB];
  for (sym = 257; sym < 286; sym++)
    dyn_cost += s->freq.lit[sym] * (x_len_bits[sym - 257] + s->cod.len.lit[sym]);
  for (sym = 0; sym < 30; sym++)
    dyn_cost += s->freq.off[sym] * (x_off_bits[sym] + s->cod.len.off[sym]);

  fix_cost += 8*(5 * sdefl_div_round_up(blk_len, SDEFL_RAW_BLK_SIZE) + blk_len + 1 + 2);
  return (dyn_cost < fix_cost) ? SDEFL_BLK_DYN : SDEFL_BLK_UCOMPR;
}
static void
sdefl_put16(unsigned char **dst, unsigned short x) {
  unsigned char *val = *dst;
  val[0] = (unsigned char)(x & 0xff);
  val[1] = (unsigned char)(x >> 8);
  *dst = val + 2;
}
static void
sdefl_match(unsigned char **dst, struct sdefl *s, int dist, int len) {
  static const char lxn[] = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
  static const short lmin[] = {3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,
      51,59,67,83,99,115,131,163,195,227,258};
  static const short dmin[] = {1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,
      385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577};

  struct sdefl_match_codest cod;
  sdefl_match_codes(&cod, dist, len);
  sdefl_put(dst, s, (int)s->cod.word.lit[cod.lc], s->cod.len.lit[cod.lc]);
  sdefl_put(dst, s, len - lmin[cod.ls], lxn[cod.ls]);
  sdefl_put(dst, s, (int)s->cod.word.off[cod.dc], s->cod.len.off[cod.dc]);
  sdefl_put(dst, s, dist - dmin[cod.dc], cod.dx);
}
static void
sdefl_flush(unsigned char **dst, struct sdefl *s, int is_last,
            const unsigned char *in, int blk_begin, int blk_end) {
  int blk_len = blk_end - blk_begin;
  int j, i = 0, item_cnt = 0;
  struct sdefl_symcnt symcnt = {0};
  unsigned codes[SDEFL_PRE_MAX];
  unsigned char lens[SDEFL_PRE_MAX];
  unsigned freqs[SDEFL_PRE_MAX] = {0};
  unsigned items[SDEFL_SYM_MAX + SDEFL_OFF_MAX];
  static const unsigned char perm[SDEFL_PRE_MAX] = {16,17,18,0,8,7,9,6,10,5,11,
      4,12,3,13,2,14,1,15};

  /* calculate huffman codes */
  s->freq.lit[SDEFL_EOB]++;
  sdefl_huff(s->cod.len.lit, s->cod.word.lit, s->freq.lit, SDEFL_SYM_MAX, SDEFL_LIT_LEN_CODES);
  sdefl_huff(s->cod.len.off, s->cod.word.off, s->freq.off, SDEFL_OFF_MAX, SDEFL_OFF_CODES);
  sdefl_precode(&symcnt, freqs, items, s->cod.len.lit, s->cod.len.off);
  sdefl_huff(lens, codes, freqs, SDEFL_PRE_MAX, SDEFL_PRE_CODES);
  for (item_cnt = SDEFL_PRE_MAX; item_cnt > 4; item_cnt--) {
    if (lens[perm[item_cnt - 1]]){
      break;
    }
  }
  /* write block */
  switch (sdefl_blk_type(s, blk_len, item_cnt, freqs, lens)) {
  case SDEFL_BLK_UCOMPR: {
    /* uncompressed blocks */
    int n = sdefl_div_round_up(blk_len, SDEFL_RAW_BLK_SIZE);
    for (i = 0; i < n; ++i) {
      int fin = is_last && (i + 1 == n);
      int amount = blk_len < SDEFL_RAW_BLK_SIZE ? blk_len : SDEFL_RAW_BLK_SIZE;
      sdefl_put(dst, s, !!fin, 1); /* block */
      sdefl_put(dst, s, 0x00, 2); /* stored block */
      if (s->bitcnt) {
        sdefl_put(dst, s, 0x00, 8 - s->bitcnt);
      }
      assert(s->bitcnt == 0);
      sdefl_put16(dst, (unsigned short)amount);
      sdefl_put16(dst, ~(unsigned short)amount);
      memcpy(*dst, in + blk_begin + i * SDEFL_RAW_BLK_SIZE, amount);
      *dst = *dst + amount;
      blk_len -= amount;
    }
  } break;
  case SDEFL_BLK_DYN: {
    /* dynamic huffman block */
    sdefl_put(dst, s, !!is_last, 1); /* block */
    sdefl_put(dst, s, 0x02, 2); /* dynamic huffman */
    sdefl_put(dst, s, symcnt.lit - 257, 5);
    sdefl_put(dst, s, symcnt.off - 1, 5);
    sdefl_put(dst, s, item_cnt - 4, 4);
    for (i = 0; i < item_cnt; ++i) {
      sdefl_put(dst, s, lens[perm[i]], 3);
    }
    for (i = 0; i < symcnt.items; ++i) {
      unsigned sym = items[i] & 0x1F;
      sdefl_put(dst, s, (int)codes[sym], lens[sym]);
      if (sym < 16) continue;
      if (sym == 16) sdefl_put(dst, s, items[i] >> 5, 2);
      else if(sym == 17) sdefl_put(dst, s, items[i] >> 5, 3);
      else sdefl_put(dst, s, items[i] >> 5, 7);
    }
    /* block sequences */
    for (i = 0; i < s->seq_cnt; ++i) {
      if (s->seq[i].off >= 0) {
        for (j = 0; j < s->seq[i].len; ++j) {
          int c = in[s->seq[i].off + j];
          sdefl_put(dst, s, (int)s->cod.word.lit[c], s->cod.len.lit[c]);
        }
      } else {
        sdefl_match(dst, s, -s->seq[i].off, s->seq[i].len);
      }
    }
    sdefl_put(dst, s, (int)(s)->cod.word.lit[SDEFL_EOB], (s)->cod.len.lit[SDEFL_EOB]);
  } break;}
  memset(&s->freq, 0, sizeof(s->freq));
  s->seq_cnt = 0;
}
static void
sdefl_seq(struct sdefl *s, int off, int len) {
  assert(s->seq_cnt + 2 < SDEFL_SEQ_SIZ);
  s->seq[s->seq_cnt].off = off;
  s->seq[s->seq_cnt].len = len;
  s->seq_cnt++;
}
static void
sdefl_reg_match(struct sdefl *s, int off, int len) {
  struct sdefl_match_codest cod;
  sdefl_match_codes(&cod, off, len);

  assert(cod.lc < SDEFL_SYM_MAX);
  assert(cod.dc < SDEFL_OFF_MAX);

  s->freq.lit[cod.lc]++;
  s->freq.off[cod.dc]++;
}
struct sdefl_match {
  int off;
  int len;
};
static void
sdefl_fnd(struct sdefl_match *m, const struct sdefl *s, int chain_len,
          int max_match, const unsigned char *in, int p, int e) {
  int i = s->tbl[sdefl_hash32(in + p)];
  int limit = ((p - SDEFL_WIN_SIZ) < SDEFL_NIL) ? SDEFL_NIL : (p-SDEFL_WIN_SIZ);

  assert(p < e);
  assert(p + max_match <= e);
  while (i > limit) {
    assert(i + m->len < e);
    assert(p + m->len < e);
    assert(i + SDEFL_MIN_MATCH < e);
    assert(p + SDEFL_MIN_MATCH < e);

    if (in[i + m->len] == in[p + m->len] &&
      (sdefl_uload32(&in[i]) == sdefl_uload32(&in[p]))) {
      int n = SDEFL_MIN_MATCH;
      while (n < max_match && in[i + n] == in[p + n]) {
        assert(i + n < e);
        assert(p + n < e);
        n++;
      }
      if (n > m->len) {
        m->len = n, m->off = p - i;
        if (n == max_match)
          break;
      }
    }
    if (!(--chain_len)) break;
    i = s->prv[i & SDEFL_WIN_MSK];
  }
}
static int
sdefl_compr(struct sdefl *s, unsigned char *out, const unsigned char *in,
            int in_len, int lvl) {
  unsigned char *q = out;
  static const unsigned char pref[] = {8,10,14,24,30,48,65,96,130};
  int max_chain = (lvl < 8) ? (1 << (lvl + 1)): (1 << 13);
  int n, i = 0, litlen = 0;
  for (n = 0; n < SDEFL_HASH_SIZ; ++n) {
    s->tbl[n] = SDEFL_NIL;
  }
  do {int blk_begin = i;
    int blk_end = ((i + SDEFL_BLK_MAX) < in_len) ? (i + SDEFL_BLK_MAX) : in_len;
    while (i < blk_end) {
      struct sdefl_match m = {0};
      int left = blk_end - i;
      int max_match = (left > SDEFL_MAX_MATCH) ? SDEFL_MAX_MATCH : left;
      int nice_match = pref[lvl] < max_match ? pref[lvl] : max_match;
      int run = 1, inc = 1, run_inc = 0;
      if (max_match > SDEFL_MIN_MATCH) {
        sdefl_fnd(&m, s, max_chain, max_match, in, i, in_len);
      }
      if (lvl >= 5 && m.len >= SDEFL_MIN_MATCH && m.len + 1 < nice_match){
        struct sdefl_match m2 = {0};
        sdefl_fnd(&m2, s, max_chain, m.len + 1, in, i + 1, in_len);
        m.len = (m2.len > m.len) ? 0 : m.len;
      }
      if (m.len >= SDEFL_MIN_MATCH) {
        if (litlen) {
          sdefl_seq(s, i - litlen, litlen);
          litlen = 0;
        }
        sdefl_seq(s, -m.off, m.len);
        sdefl_reg_match(s, m.off, m.len);
        if (lvl < 2 && m.len >= nice_match) {
          inc = m.len;
        } else {
          run = m.len;
        }
      } else {
        s->freq.lit[in[i]]++;
        litlen++;
      }
      run_inc = run * inc;
      if (in_len - (i + run_inc) > SDEFL_MIN_MATCH) {
        while (run-- > 0) {
          unsigned h = sdefl_hash32(&in[i]);
          s->prv[i&SDEFL_WIN_MSK] = s->tbl[h];
          s->tbl[h] = i, i += inc;
          assert(i <= blk_end);
        }
      } else {
        i += run_inc;
        assert(i <= blk_end);
      }
    }
    if (litlen) {
      sdefl_seq(s, i - litlen, litlen);
      litlen = 0;
    }
    sdefl_flush(&q, s, blk_end == in_len, in, blk_begin, blk_end);
  } while (i < in_len);
  if (s->bitcnt) {
    sdefl_put(&q, s, 0x00, 8 - s->bitcnt);
  }
  assert(s->bitcnt == 0);
  return (int)(q - out);
}
extern int
sdeflate(struct sdefl *s, void *out, const void *in, int n, int lvl) {
  s->bits = s->bitcnt = 0;
  return sdefl_compr(s, (unsigned char*)out, (const unsigned char*)in, n, lvl);
}


extern int
sdefl_bound(int len) {
  int max_blocks = 1 + sdefl_div_round_up(len, SDEFL_RAW_BLK_SIZE);
  int bound = 5 * max_blocks + len + 1 + 4 + 8;
  return bound;
}

//////////////


#define ZIP_LOCAL_HEADER   0x04034b50
#define ZIP_CENTRAL_HEADER   0x02014b50
#define ZIP_END_CENTRAL_HEADER   0x06054b50

#define ZIP_VER_MADE_BY   831
#define ZIP_VER_TO_EXTRACT   10

#define Z_DEFLATED   8


#pragma pack(push, 1)
struct LocalFileHeader
{
    uint32_t signature;
    uint16_t versionToExtract;
    uint16_t generalPurposeBitFlag;
    uint16_t compressionMethod;
    uint16_t modificationTime;
    uint16_t modificationDate;
    uint32_t crc32;
    uint32_t compressedSize;
    uint32_t uncompressedSize;
    uint16_t filenameLength;
    uint16_t extraFieldLength;

};
#pragma pack(pop)

#pragma pack(push, 1)
struct CentralDirectoryFileHeader
{
    uint32_t signature;
    uint16_t versionMadeBy;
    uint16_t versionToExtract;
    uint16_t generalPurposeBitFlag;
    uint16_t compressionMethod;
    uint16_t modificationTime;
    uint16_t modificationDate;
    uint32_t crc32;
    uint32_t compressedSize;
    uint32_t uncompressedSize;
    uint16_t filenameLength;
    uint16_t extraFieldLength;
    uint16_t fileCommentLength;
    uint16_t diskNumber;
    uint16_t internalFileAttributes;
    uint32_t externalFileAttributes;
    uint32_t localFileHeaderOffset;

};
#pragma pack(pop)

#pragma pack(push, 1)
struct EndOfCentralDirectory
{
    uint32_t signature;
    uint16_t diskNumber;
    uint16_t startDiskNumber;
    uint16_t numberCentralDirectoryRecord;
    uint16_t totalCentralDirectoryRecord;
    uint32_t sizeOfCentralDirectory;
    uint32_t centralDirectoryOffset;
    uint16_t commentLength;

};
#pragma pack(pop)


static uint32_t crc_32_tab[] = { /* CRC polynomial 0xedb88320 */
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
#define UPDC32(ch, crc) (crc_32_tab[((crc) ^ (ch)) & 0xff] ^ ((crc) >> 8))
uint32_t updateCRC32(unsigned char ch, uint32_t crc)
{
      return UPDC32(ch, crc);
}

uint32_t crc32(unsigned char *buf, size_t len)
{
      register uint32_t oldcrc32;

      oldcrc32 = 0xFFFFFFFF;

      for ( ; len; --len, ++buf)
      {
            oldcrc32 = UPDC32(*buf, oldcrc32);
      }

      return ~oldcrc32;
 
}


typedef struct pico_zip
{
    uint16_t filesCount;
    void* buffer;
    void* cdfh_buffer;

    uint32_t buffer_size;
    uint32_t cdfh_buffer_size;
    bool isFinalized;
} pico_zip;


pico_zip * pico_zip_init()
{
    pico_zip * p_zip = (pico_zip *) malloc(sizeof(pico_zip));
    memset(p_zip, 0, sizeof(pico_zip));
    p_zip->filesCount = 0;
    p_zip->isFinalized = false;

    return p_zip;
};


void * append_buffer(void **buffer, uint32_t *size, const void *in_buffer, uint32_t in_size)
{
    void * tmp = realloc(*buffer, *size + in_size);
    memcpy((char *)tmp+*size, in_buffer, in_size);
    *size += in_size;
    *buffer = tmp;
    return tmp;
};


void* compress_buffer(const void *buffer, uint32_t size, uint32_t *destLen)
{
    static struct sdefl sdefl;
    void* cbuffer = malloc(sdefl_bound(size));
    *destLen = sdeflate(&sdefl, cbuffer, buffer, size, SDEFL_LVL_DEF);
    return cbuffer;
}

int pico_zip_pack(pico_zip * p_zip, const char *filename, const void *buffer, uint32_t size)
{
    uint32_t compressedSize = 0;
    void* cbuffer = compress_buffer(buffer, size, &compressedSize);
    if (cbuffer == NULL) return 1;


    struct LocalFileHeader lfh;
    struct CentralDirectoryFileHeader cdfh;
    memset(&lfh, 0, sizeof(lfh));
    memset(&cdfh, 0, sizeof(cdfh));

    lfh.signature = ZIP_LOCAL_HEADER;
    cdfh.signature = ZIP_CENTRAL_HEADER;
    lfh.versionToExtract = ZIP_VER_TO_EXTRACT;

    lfh.crc32 = crc32((unsigned char *)buffer, size);
    lfh.compressionMethod = Z_DEFLATED;
    lfh.compressedSize = compressedSize;
    lfh.uncompressedSize = size;
    lfh.filenameLength = strlen(filename);
    lfh.generalPurposeBitFlag = 1 << 11;

    cdfh.versionToExtract = lfh.versionToExtract;
    cdfh.versionMadeBy = ZIP_VER_MADE_BY;
    cdfh.compressedSize =lfh.compressedSize;
    cdfh.uncompressedSize = lfh.uncompressedSize;
    cdfh.compressionMethod = lfh.compressionMethod;
    cdfh.crc32 = lfh.crc32;
    cdfh.filenameLength = lfh.filenameLength;
    cdfh.generalPurposeBitFlag = lfh.generalPurposeBitFlag;
    cdfh.localFileHeaderOffset = p_zip->buffer_size;


    append_buffer(&p_zip->buffer, &p_zip->buffer_size, &lfh, sizeof(lfh));
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, (void* )filename, strlen(filename));
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, cbuffer, compressedSize);
    p_zip->filesCount++;
 
    append_buffer(&p_zip->cdfh_buffer, &p_zip->cdfh_buffer_size, &cdfh, sizeof(cdfh));
    append_buffer(&p_zip->cdfh_buffer, &p_zip->cdfh_buffer_size, (void* )filename, strlen(filename));
 
    free(cbuffer);
    return 0;
};


int pico_zip_finalize(pico_zip * p_zip, const char *comment){
    struct EndOfCentralDirectory eocd;
    memset(&eocd, 0, sizeof(eocd));
    eocd.signature = ZIP_END_CENTRAL_HEADER;
    eocd.centralDirectoryOffset = p_zip -> buffer_size;
    eocd.numberCentralDirectoryRecord = p_zip -> filesCount;
    eocd.totalCentralDirectoryRecord = p_zip -> filesCount;
    eocd.sizeOfCentralDirectory = p_zip -> cdfh_buffer_size;
    eocd.commentLength=strlen(comment);
 
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, p_zip->cdfh_buffer, p_zip->cdfh_buffer_size);
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, (void*)&eocd, sizeof(eocd));
    append_buffer(&p_zip->buffer, &p_zip->buffer_size, (void*)comment, eocd.commentLength);
    p_zip -> isFinalized = true;
    return 0;
};
  
int pico_zip_free(pico_zip * p_zip){
    free(p_zip -> cdfh_buffer);
    free(p_zip -> buffer);
    p_zip -> filesCount = 0;
    p_zip -> buffer_size = 0;
    p_zip -> cdfh_buffer_size = 0;
    p_zip -> isFinalized = false;
};
 
Войдите или зарегистрируйтесь для ответа.
Сверху Снизу