#include "ldm.h"
#include "util.h"
-#define HASH_EVERY 7
+#define HASH_EVERY 1
-#define LDM_MEMORY_USAGE 20
+#define LDM_MEMORY_USAGE 16
#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
#define LDM_OFFSET_SIZE 4
-#define WINDOW_SIZE (1 << 24)
+#define WINDOW_SIZE (1 << 20)
#define MAX_WINDOW_SIZE 31
#define HASH_SIZE 4
#define LDM_HASH_LENGTH 4
#define RUN_BITS (8-ML_BITS)
#define RUN_MASK ((1U<<RUN_BITS)-1)
-#define LDM_ROLLING_HASH
+//#define LDM_ROLLING_HASH
//#define LDM_DEBUG
typedef uint8_t BYTE;
--- /dev/null
+# ################################################################
+# Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree. An additional grant
+# of patent rights can be found in the PATENTS file in the same directory.
+# ################################################################
+
+# This Makefile presumes libzstd is installed, using `sudo make install`
+
+CFLAGS ?= -O3
+DEBUGFLAGS = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
+ -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
+ -Wstrict-prototypes -Wundef -Wpointer-arith -Wformat-security \
+ -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
+ -Wredundant-decls
+CFLAGS += $(DEBUGFLAGS) $(MOREFLAGS)
+FLAGS = $(CPPFLAGS) $(CFLAGS)
+
+LDFLAGS += -lzstd
+
+.PHONY: default all clean
+
+default: all
+
+all: main-ldm
+
+
+#main : ldm.c main.c
+# $(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
+
+main-ldm : util.c ldm.c main-ldm.c
+ $(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
+
+clean:
+ @rm -f core *.o tmp* result* *.ldm *.ldm.dec \
+ main main-ldm
+ @echo Cleaning completed
+
--- /dev/null
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+
+
+#include "ldm.h"
+#include "util.h"
+
+#define HASH_EVERY 1
+
+#define LDM_MEMORY_USAGE 16
+#define LDM_HASHLOG (LDM_MEMORY_USAGE-2)
+#define LDM_HASHTABLESIZE (1 << (LDM_MEMORY_USAGE))
+#define LDM_HASHTABLESIZE_U32 ((LDM_HASHTABLESIZE) >> 2)
+#define LDM_HASH_SIZE_U32 (1 << (LDM_HASHLOG))
+
+#define LDM_OFFSET_SIZE 4
+
+#define WINDOW_SIZE (1 << 20)
+#define MAX_WINDOW_SIZE 31
+#define HASH_SIZE 4
+#define LDM_HASH_LENGTH 4
+#define MINMATCH 4
+
+#define ML_BITS 4
+#define ML_MASK ((1U<<ML_BITS)-1)
+#define RUN_BITS (8-ML_BITS)
+#define RUN_MASK ((1U<<RUN_BITS)-1)
+
+//#define LDM_ROLLING_HASH
+//#define LDM_DEBUG
+
+typedef uint8_t BYTE;
+typedef uint16_t U16;
+typedef uint32_t U32;
+typedef int32_t S32;
+typedef uint64_t U64;
+
+typedef uint32_t offset_t;
+typedef uint32_t hash_t;
+typedef signed char schar;
+
+typedef struct LDM_hashEntry {
+ offset_t offset;
+} LDM_hashEntry;
+
+typedef struct LDM_compressStats {
+ U32 numMatches;
+ U32 totalMatchLength;
+ U32 totalLiteralLength;
+ U64 totalOffset;
+} LDM_compressStats;
+
+static void LDM_printCompressStats(const LDM_compressStats *stats) {
+ printf("=====================\n");
+ printf("Compression statistics\n");
+ printf("Total number of matches: %u\n", stats->numMatches);
+ printf("Average match length: %.1f\n", ((double)stats->totalMatchLength) /
+ (double)stats->numMatches);
+ printf("Average literal length: %.1f\n",
+ ((double)stats->totalLiteralLength) / (double)stats->numMatches);
+ printf("Average offset length: %.1f\n",
+ ((double)stats->totalOffset) / (double)stats->numMatches);
+ printf("=====================\n");
+}
+
+typedef struct LDM_CCtx {
+ size_t isize; /* Input size */
+ size_t maxOSize; /* Maximum output size */
+
+ const BYTE *ibase; /* Base of input */
+ const BYTE *ip; /* Current input position */
+ const BYTE *iend; /* End of input */
+
+ // Maximum input position such that hashing at the position does not exceed
+ // end of input.
+ const BYTE *ihashLimit;
+
+ // Maximum input position such that finding a match of at least the minimum
+ // match length does not exceed end of input.
+ const BYTE *imatchLimit;
+
+ const BYTE *obase; /* Base of output */
+ BYTE *op; /* Output */
+
+ const BYTE *anchor; /* Anchor to start of current (match) block */
+
+ LDM_compressStats stats; /* Compression statistics */
+
+ LDM_hashEntry hashTable[LDM_HASHTABLESIZE_U32];
+
+ const BYTE *lastPosHashed; /* Last position hashed */
+ hash_t lastHash; /* Hash corresponding to lastPosHashed */
+ const BYTE *nextIp;
+ hash_t nextHash; /* Hash corresponding to nextIp */
+
+ unsigned step;
+} LDM_CCtx;
+
+#ifdef LDM_ROLLING_HASH
+/**
+ * Convert a sum computed from LDM_getRollingHash to a hash value in the range
+ * of the hash table.
+ */
+static hash_t LDM_sumToHash(U32 sum) {
+ return sum % (LDM_HASHTABLESIZE >> 2);
+// return sum & (LDM_HASHTABLESIZE - 1);
+}
+
+static U32 LDM_getRollingHash(const char *data, U32 len) {
+ U32 i;
+ U32 s1, s2;
+ const schar *buf = (const schar *)data;
+
+ s1 = s2 = 0;
+ for (i = 0; i < (len - 4); i += 4) {
+ s2 += (4 * (s1 + buf[i])) + (3 * buf[i + 1]) +
+ (2 * buf[i + 2]) + (buf[i + 3]);
+ s1 += buf[i] + buf[i + 1] + buf[i + 2] + buf[i + 3];
+ }
+ for(; i < len; i++) {
+ s1 += buf[i];
+ s2 += s1;
+ }
+ return (s1 & 0xffff) + (s2 << 16);
+}
+
+static hash_t LDM_hashPosition(const void * const p) {
+ return LDM_sumToHash(LDM_getRollingHash((const char *)p, LDM_HASH_LENGTH));
+}
+
+typedef struct LDM_sumStruct {
+ U16 s1, s2;
+} LDM_sumStruct;
+
+static void LDM_getRollingHashParts(U32 sum, LDM_sumStruct *sumStruct) {
+ sumStruct->s1 = sum & 0xffff;
+ sumStruct->s2 = sum >> 16;
+}
+
+#else
+static hash_t LDM_hash(U32 sequence) {
+ return ((sequence * 2654435761U) >> ((32)-LDM_HASHLOG));
+}
+
+static hash_t LDM_hashPosition(const void * const p) {
+ return LDM_hash(LDM_read32(p));
+}
+#endif
+
+/*
+static hash_t LDM_hash5(U64 sequence) {
+ static const U64 prime5bytes = 889523592379ULL;
+ static const U64 prime8bytes = 11400714785074694791ULL;
+ const U32 hashLog = LDM_HASHLOG;
+ if (LDM_isLittleEndian())
+ return (((sequence << 24) * prime5bytes) >> (64 - hashLog));
+ else
+ return (((sequence >> 24) * prime8bytes) >> (64 - hashLog));
+}
+*/
+
+static void LDM_putHashOfCurrentPositionFromHash(
+ LDM_CCtx *cctx, hash_t hash) {
+ if (((cctx->ip - cctx->ibase) & HASH_EVERY) != HASH_EVERY) {
+ return;
+ }
+ (cctx->hashTable)[hash] = (LDM_hashEntry){ (hash_t)(cctx->ip - cctx->ibase) };
+ cctx->lastPosHashed = cctx->ip;
+ cctx->lastHash = hash;
+}
+
+static void LDM_putHashOfCurrentPosition(LDM_CCtx *cctx) {
+ hash_t hash = LDM_hashPosition(cctx->ip);
+ LDM_putHashOfCurrentPositionFromHash(cctx, hash);
+}
+
+static const BYTE *LDM_get_position_on_hash(
+ hash_t h, void *tableBase, const BYTE *srcBase) {
+ const LDM_hashEntry * const hashTable = (LDM_hashEntry *)tableBase;
+ return hashTable[h].offset + srcBase;
+}
+
+static BYTE LDM_read_byte(const void *memPtr) {
+ BYTE val;
+ memcpy(&val, memPtr, 1);
+ return val;
+}
+
+static unsigned LDM_count(const BYTE *pIn, const BYTE *pMatch,
+ const BYTE *pInLimit) {
+ const BYTE * const pStart = pIn;
+ while (pIn < pInLimit - 1) {
+ BYTE const diff = LDM_read_byte(pMatch) ^ LDM_read_byte(pIn);
+ if (!diff) {
+ pIn++;
+ pMatch++;
+ continue;
+ }
+ return (unsigned)(pIn - pStart);
+ }
+ return (unsigned)(pIn - pStart);
+}
+
+void LDM_readHeader(const void *src, size_t *compressSize,
+ size_t *decompressSize) {
+ const U32 *ip = (const U32 *)src;
+ *compressSize = *ip++;
+ *decompressSize = *ip;
+}
+
+static void LDM_initializeCCtx(LDM_CCtx *cctx,
+ const void *src, size_t srcSize,
+ void *dst, size_t maxDstSize) {
+ cctx->isize = srcSize;
+ cctx->maxOSize = maxDstSize;
+
+ cctx->ibase = (const BYTE *)src;
+ cctx->ip = cctx->ibase;
+ cctx->iend = cctx->ibase + srcSize;
+
+ cctx->ihashLimit = cctx->iend - HASH_SIZE;
+ cctx->imatchLimit = cctx->iend - MINMATCH;
+
+ cctx->obase = (BYTE *)dst;
+ cctx->op = (BYTE *)dst;
+
+ cctx->anchor = cctx->ibase;
+
+ memset(&(cctx->stats), 0, sizeof(cctx->stats));
+ memset(cctx->hashTable, 0, sizeof(cctx->hashTable));
+
+ cctx->lastPosHashed = NULL;
+ cctx->nextIp = NULL;
+
+ cctx->step = 1;
+}
+
+static int LDM_findBestMatch(LDM_CCtx *cctx, const BYTE **match) {
+ cctx->nextIp = cctx->ip;
+
+ do {
+ hash_t const h = cctx->nextHash;
+ cctx->ip = cctx->nextIp;
+ cctx->nextIp += cctx->step;
+
+ if (cctx->nextIp > cctx->imatchLimit) {
+ return 1;
+ }
+
+ *match = LDM_get_position_on_hash(h, cctx->hashTable, cctx->ibase);
+
+ cctx->nextHash = LDM_hashPosition(cctx->nextIp);
+ LDM_putHashOfCurrentPositionFromHash(cctx, h);
+ } while (cctx->ip - *match > WINDOW_SIZE ||
+ LDM_read64(*match) != LDM_read64(cctx->ip));
+ return 0;
+}
+
+// TODO: srcSize and maxDstSize is unused
+size_t LDM_compress(const void *src, size_t srcSize,
+ void *dst, size_t maxDstSize) {
+ LDM_CCtx cctx;
+ LDM_initializeCCtx(&cctx, src, srcSize, dst, maxDstSize);
+
+ /* Hash the first position and put it into the hash table. */
+ LDM_putHashOfCurrentPosition(&cctx);
+ cctx.ip++;
+ cctx.nextHash = LDM_hashPosition(cctx.ip);
+
+ // TODO: loop condition is not accurate.
+ while (1) {
+ const BYTE *match;
+
+ /**
+ * Find a match.
+ * If no more matches can be found (i.e. the length of the remaining input
+ * is less than the minimum match length), then stop searching for matches
+ * and encode the final literals.
+ */
+ if (LDM_findBestMatch(&cctx, &match) != 0) {
+ goto _last_literals;
+ }
+
+ cctx.stats.numMatches++;
+
+ /**
+ * Catch up: look back to extend the match backwards from the found match.
+ */
+ while (cctx.ip > cctx.anchor && match > cctx.ibase &&
+ cctx.ip[-1] == match[-1]) {
+ cctx.ip--;
+ match--;
+ }
+
+ /**
+ * Write current block (literals, literal length, match offset, match
+ * length) and update pointers and hashes.
+ */
+ {
+ unsigned const literalLength = (unsigned)(cctx.ip - cctx.anchor);
+ unsigned const offset = cctx.ip - match;
+ unsigned const matchLength = LDM_count(
+ cctx.ip + MINMATCH, match + MINMATCH, cctx.ihashLimit);
+ BYTE *token = cctx.op++;
+
+ cctx.stats.totalLiteralLength += literalLength;
+ cctx.stats.totalOffset += offset;
+ cctx.stats.totalMatchLength += matchLength + MINMATCH;
+
+ /* Encode the literal length. */
+ if (literalLength >= RUN_MASK) {
+ int len = (int)literalLength - RUN_MASK;
+ *token = (RUN_MASK << ML_BITS);
+ for (; len >= 255; len -= 255) {
+ *(cctx.op)++ = 255;
+ }
+ *(cctx.op)++ = (BYTE)len;
+ } else {
+ *token = (BYTE)(literalLength << ML_BITS);
+ }
+
+ /* Encode the literals. */
+ memcpy(cctx.op, cctx.anchor, literalLength);
+ cctx.op += literalLength;
+
+ /* Encode the offset. */
+ LDM_write32(cctx.op, offset);
+ cctx.op += LDM_OFFSET_SIZE;
+
+ /* Encode match length */
+ if (matchLength >= ML_MASK) {
+ unsigned matchLengthRemaining = matchLength;
+ *token += ML_MASK;
+ matchLengthRemaining -= ML_MASK;
+ LDM_write32(cctx.op, 0xFFFFFFFF);
+ while (matchLengthRemaining >= 4*0xFF) {
+ cctx.op += 4;
+ LDM_write32(cctx.op, 0xffffffff);
+ matchLengthRemaining -= 4*0xFF;
+ }
+ cctx.op += matchLengthRemaining / 255;
+ *(cctx.op)++ = (BYTE)(matchLengthRemaining % 255);
+ } else {
+ *token += (BYTE)(matchLength);
+ }
+
+ /* Update input pointer, inserting hashes into hash table along the
+ * way.
+ */
+ while (cctx.ip < cctx.anchor + MINMATCH + matchLength + literalLength) {
+ LDM_putHashOfCurrentPosition(&cctx);
+ cctx.ip++;
+ }
+ }
+
+ // Set start of next block to current input pointer.
+ cctx.anchor = cctx.ip;
+ LDM_putHashOfCurrentPosition(&cctx);
+ cctx.nextHash = LDM_hashPosition(++cctx.ip);
+ }
+_last_literals:
+ /* Encode the last literals (no more matches). */
+ {
+ size_t const lastRun = (size_t)(cctx.iend - cctx.anchor);
+ if (lastRun >= RUN_MASK) {
+ size_t accumulator = lastRun - RUN_MASK;
+ *(cctx.op)++ = RUN_MASK << ML_BITS;
+ for(; accumulator >= 255; accumulator -= 255) {
+ *(cctx.op)++ = 255;
+ }
+ *(cctx.op)++ = (BYTE)accumulator;
+ } else {
+ *(cctx.op)++ = (BYTE)(lastRun << ML_BITS);
+ }
+ memcpy(cctx.op, cctx.anchor, lastRun);
+ cctx.op += lastRun;
+ }
+ LDM_printCompressStats(&cctx.stats);
+ return (cctx.op - (const BYTE *)cctx.obase);
+}
+
+typedef struct LDM_DCtx {
+ size_t compressSize;
+ size_t maxDecompressSize;
+
+ const BYTE *ibase; /* Base of input */
+ const BYTE *ip; /* Current input position */
+ const BYTE *iend; /* End of source */
+
+ const BYTE *obase; /* Base of output */
+ BYTE *op; /* Current output position */
+ const BYTE *oend; /* End of output */
+} LDM_DCtx;
+
+static void LDM_initializeDCtx(LDM_DCtx *dctx,
+ const void *src, size_t compressSize,
+ void *dst, size_t maxDecompressSize) {
+ dctx->compressSize = compressSize;
+ dctx->maxDecompressSize = maxDecompressSize;
+
+ dctx->ibase = src;
+ dctx->ip = (const BYTE *)src;
+ dctx->iend = dctx->ip + dctx->compressSize;
+ dctx->op = dst;
+ dctx->oend = dctx->op + dctx->maxDecompressSize;
+
+}
+
+size_t LDM_decompress(const void *src, size_t compressSize,
+ void *dst, size_t maxDecompressSize) {
+ LDM_DCtx dctx;
+ LDM_initializeDCtx(&dctx, src, compressSize, dst, maxDecompressSize);
+
+ while (dctx.ip < dctx.iend) {
+ BYTE *cpy;
+ const BYTE *match;
+ size_t length, offset;
+
+ /* Get the literal length. */
+ unsigned const token = *(dctx.ip)++;
+ if ((length = (token >> ML_BITS)) == RUN_MASK) {
+ unsigned s;
+ do {
+ s = *(dctx.ip)++;
+ length += s;
+ } while (s == 255);
+ }
+
+ /* Copy literals. */
+ cpy = dctx.op + length;
+ memcpy(dctx.op, dctx.ip, length);
+ dctx.ip += length;
+ dctx.op = cpy;
+
+ //TODO : dynamic offset size
+ offset = LDM_read32(dctx.ip);
+ dctx.ip += LDM_OFFSET_SIZE;
+ match = dctx.op - offset;
+
+ /* Get the match length. */
+ length = token & ML_MASK;
+ if (length == ML_MASK) {
+ unsigned s;
+ do {
+ s = *(dctx.ip)++;
+ length += s;
+ } while (s == 255);
+ }
+ length += MINMATCH;
+
+ /* Copy match. */
+ cpy = dctx.op + length;
+
+ // Inefficient for now
+ while (match < cpy - offset && dctx.op < dctx.oend) {
+ *(dctx.op)++ = *match++;
+ }
+ }
+ return dctx.op - (BYTE *)dst;
+}
+
+
--- /dev/null
+#ifndef LDM_H
+#define LDM_H
+
+#include <stddef.h> /* size_t */
+
+#define LDM_COMPRESS_SIZE 4
+#define LDM_DECOMPRESS_SIZE 4
+#define LDM_HEADER_SIZE ((LDM_COMPRESS_SIZE)+(LDM_DECOMPRESS_SIZE))
+
+size_t LDM_compress(const void *src, size_t srcSize,
+ void *dst, size_t maxDstSize);
+
+size_t LDM_decompress(const void *src, size_t srcSize,
+ void *dst, size_t maxDstSize);
+
+void LDM_readHeader(const void *src, size_t *compressSize,
+ size_t *decompressSize);
+
+#endif /* LDM_H */
--- /dev/null
+// TODO: file size must fit into a U32
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <zstd.h>
+
+#include <fcntl.h>
+#include "ldm.h"
+
+// #define BUF_SIZE 16*1024 // Block size
+#define DEBUG
+
+//#define ZSTD
+
+/* Compress file given by fname and output to oname.
+ * Returns 0 if successful, error code otherwise.
+ */
+static int compress(const char *fname, const char *oname) {
+ int fdin, fdout;
+ struct stat statbuf;
+ char *src, *dst;
+ size_t maxCompressSize, compressSize;
+
+ /* Open the input file. */
+ if ((fdin = open(fname, O_RDONLY)) < 0) {
+ perror("Error in file opening");
+ return 1;
+ }
+
+ /* Open the output file. */
+ if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
+ perror("Can't create output file");
+ return 1;
+ }
+
+ /* Find the size of the input file. */
+ if (fstat (fdin, &statbuf) < 0) {
+ perror("Fstat error");
+ return 1;
+ }
+
+ maxCompressSize = statbuf.st_size + LDM_HEADER_SIZE;
+
+ /* Go to the location corresponding to the last byte. */
+ /* TODO: fallocate? */
+ if (lseek(fdout, maxCompressSize - 1, SEEK_SET) == -1) {
+ perror("lseek error");
+ return 1;
+ }
+
+ /* Write a dummy byte at the last location. */
+ if (write(fdout, "", 1) != 1) {
+ perror("write error");
+ return 1;
+ }
+
+ /* mmap the input file. */
+ if ((src = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, fdin, 0))
+ == (caddr_t) - 1) {
+ perror("mmap error for input");
+ return 1;
+ }
+
+ /* mmap the output file */
+ if ((dst = mmap(0, maxCompressSize, PROT_READ | PROT_WRITE,
+ MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
+ perror("mmap error for output");
+ return 1;
+ }
+
+#ifdef ZSTD
+ compressSize = ZSTD_compress(dst, statbuf.st_size,
+ src, statbuf.st_size, 1);
+#else
+ compressSize = LDM_HEADER_SIZE +
+ LDM_compress(src, statbuf.st_size,
+ dst + LDM_HEADER_SIZE, statbuf.st_size);
+
+ // Write compress and decompress size to header
+ // TODO: should depend on LDM_DECOMPRESS_SIZE write32
+ memcpy(dst, &compressSize, 4);
+ memcpy(dst + 4, &(statbuf.st_size), 4);
+
+#ifdef DEBUG
+ printf("Compressed size: %zu\n", compressSize);
+ printf("Decompressed size: %zu\n", (size_t)statbuf.st_size);
+#endif
+#endif
+
+ // Truncate file to compressSize.
+ ftruncate(fdout, compressSize);
+
+ printf("%25s : %6u -> %7u - %s (%.1f%%)\n", fname,
+ (unsigned)statbuf.st_size, (unsigned)compressSize, oname,
+ (double)compressSize / (statbuf.st_size) * 100);
+
+ // Close files.
+ close(fdin);
+ close(fdout);
+ return 0;
+}
+
+/* Decompress file compressed using LDM_compress.
+ * The input file should have the LDM_HEADER followed by payload.
+ * Returns 0 if succesful, and an error code otherwise.
+ */
+static int decompress(const char *fname, const char *oname) {
+ int fdin, fdout;
+ struct stat statbuf;
+ char *src, *dst;
+ size_t compressSize, decompressSize, outSize;
+
+ /* Open the input file. */
+ if ((fdin = open(fname, O_RDONLY)) < 0) {
+ perror("Error in file opening");
+ return 1;
+ }
+
+ /* Open the output file. */
+ if ((fdout = open(oname, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600)) < 0) {
+ perror("Can't create output file");
+ return 1;
+ }
+
+ /* Find the size of the input file. */
+ if (fstat (fdin, &statbuf) < 0) {
+ perror("Fstat error");
+ return 1;
+ }
+
+ /* mmap the input file. */
+ if ((src = mmap(0, statbuf.st_size, PROT_READ, MAP_SHARED, fdin, 0))
+ == (caddr_t) - 1) {
+ perror("mmap error for input");
+ return 1;
+ }
+
+ /* Read the header. */
+ LDM_readHeader(src, &compressSize, &decompressSize);
+
+#ifdef DEBUG
+ printf("Size, compressSize, decompressSize: %zu %zu %zu\n",
+ (size_t)statbuf.st_size, compressSize, decompressSize);
+#endif
+
+ /* Go to the location corresponding to the last byte. */
+ if (lseek(fdout, decompressSize - 1, SEEK_SET) == -1) {
+ perror("lseek error");
+ return 1;
+ }
+
+ /* write a dummy byte at the last location */
+ if (write(fdout, "", 1) != 1) {
+ perror("write error");
+ return 1;
+ }
+
+ /* mmap the output file */
+ if ((dst = mmap(0, decompressSize, PROT_READ | PROT_WRITE,
+ MAP_SHARED, fdout, 0)) == (caddr_t) - 1) {
+ perror("mmap error for output");
+ return 1;
+ }
+
+#ifdef ZSTD
+ outSize = ZSTD_decompress(dst, decomrpessed_size,
+ src + LDM_HEADER_SIZE,
+ statbuf.st_size - LDM_HEADER_SIZE);
+#else
+ outSize = LDM_decompress(
+ src + LDM_HEADER_SIZE, statbuf.st_size - LDM_HEADER_SIZE,
+ dst, decompressSize);
+
+ printf("Ret size out: %zu\n", outSize);
+ #endif
+ ftruncate(fdout, outSize);
+
+ close(fdin);
+ close(fdout);
+ return 0;
+}
+
+/* Compare two files.
+ * Returns 0 iff they are the same.
+ */
+static int compare(FILE *fp0, FILE *fp1) {
+ int result = 0;
+ while (result == 0) {
+ char b0[1024];
+ char b1[1024];
+ const size_t r0 = fread(b0, 1, sizeof(b0), fp0);
+ const size_t r1 = fread(b1, 1, sizeof(b1), fp1);
+
+ result = (int)r0 - (int)r1;
+
+ if (0 == r0 || 0 == r1) break;
+
+ if (0 == result) result = memcmp(b0, b1, r0);
+ }
+ return result;
+}
+
+/* Verify the input file is the same as the decompressed file. */
+static void verify(const char *inpFilename, const char *decFilename) {
+ FILE *inpFp = fopen(inpFilename, "rb");
+ FILE *decFp = fopen(decFilename, "rb");
+
+ printf("verify : %s <-> %s\n", inpFilename, decFilename);
+ {
+ const int cmp = compare(inpFp, decFp);
+ if(0 == cmp) {
+ printf("verify : OK\n");
+ } else {
+ printf("verify : NG\n");
+ }
+ }
+
+ fclose(decFp);
+ fclose(inpFp);
+}
+
+int main(int argc, const char *argv[]) {
+ const char * const exeName = argv[0];
+ char inpFilename[256] = { 0 };
+ char ldmFilename[256] = { 0 };
+ char decFilename[256] = { 0 };
+
+ if (argc < 2) {
+ printf("Wrong arguments\n");
+ printf("Usage:\n");
+ printf("%s FILE\n", exeName);
+ return 1;
+ }
+
+ snprintf(inpFilename, 256, "%s", argv[1]);
+ snprintf(ldmFilename, 256, "%s.ldm", argv[1]);
+ snprintf(decFilename, 256, "%s.ldm.dec", argv[1]);
+
+ printf("inp = [%s]\n", inpFilename);
+ printf("ldm = [%s]\n", ldmFilename);
+ printf("dec = [%s]\n", decFilename);
+
+
+ /* Compress */
+ {
+ struct timeval tv1, tv2;
+ gettimeofday(&tv1, NULL);
+ if (compress(inpFilename, ldmFilename)) {
+ printf("Compress error");
+ return 1;
+ }
+ gettimeofday(&tv2, NULL);
+ printf("Total time = %f seconds\n",
+ (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
+ (double) (tv2.tv_sec - tv1.tv_sec));
+ }
+
+ /* Decompress */
+ {
+ struct timeval tv1, tv2;
+ gettimeofday(&tv1, NULL);
+ if (decompress(ldmFilename, decFilename)) {
+ printf("Decompress error");
+ return 1;
+ }
+ gettimeofday(&tv2, NULL);
+ printf("Total time = %f seconds\n",
+ (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
+ (double) (tv2.tv_sec - tv1.tv_sec));
+ }
+ /* verify */
+ verify(inpFilename, decFilename);
+ return 0;
+}
+
+
+#if 0
+static size_t compress_file(FILE *in, FILE *out, size_t *size_in,
+ size_t *size_out) {
+ char *src, *buf = NULL;
+ size_t r = 1;
+ size_t size, n, k, count_in = 0, count_out = 0, offset, frame_size = 0;
+
+ src = malloc(BUF_SIZE);
+ if (!src) {
+ printf("Not enough memory\n");
+ goto cleanup;
+ }
+
+ size = BUF_SIZE + LDM_HEADER_SIZE;
+ buf = malloc(size);
+ if (!buf) {
+ printf("Not enough memory\n");
+ goto cleanup;
+ }
+
+
+ for (;;) {
+ k = fread(src, 1, BUF_SIZE, in);
+ if (k == 0)
+ break;
+ count_in += k;
+
+ n = LDM_compress(src, buf, k, BUF_SIZE);
+
+ // n = k;
+ // offset += n;
+ offset = k;
+ count_out += k;
+
+// k = fwrite(src, 1, offset, out);
+
+ k = fwrite(buf, 1, offset, out);
+ if (k < offset) {
+ if (ferror(out))
+ printf("Write failed\n");
+ else
+ printf("Short write\n");
+ goto cleanup;
+ }
+
+ }
+ *size_in = count_in;
+ *size_out = count_out;
+ r = 0;
+ cleanup:
+ free(src);
+ free(buf);
+ return r;
+}
+
+static size_t decompress_file(FILE *in, FILE *out) {
+ void *src = malloc(BUF_SIZE);
+ void *dst = NULL;
+ size_t dst_capacity = BUF_SIZE;
+ size_t ret = 1;
+ size_t bytes_written = 0;
+
+ if (!src) {
+ perror("decompress_file(src)");
+ goto cleanup;
+ }
+
+ while (ret != 0) {
+ /* Load more input */
+ size_t src_size = fread(src, 1, BUF_SIZE, in);
+ void *src_ptr = src;
+ void *src_end = src_ptr + src_size;
+ if (src_size == 0 || ferror(in)) {
+ printf("(TODO): Decompress: not enough input or error reading file\n");
+ //TODO
+ ret = 0;
+ goto cleanup;
+ }
+
+ /* Allocate destination buffer if it hasn't been allocated already */
+ if (!dst) {
+ dst = malloc(dst_capacity);
+ if (!dst) {
+ perror("decompress_file(dst)");
+ goto cleanup;
+ }
+ }
+
+ // TODO
+
+ /* Decompress:
+ * Continue while there is more input to read.
+ */
+ while (src_ptr != src_end && ret != 0) {
+ // size_t dst_size = src_size;
+ size_t dst_size = LDM_decompress(src, dst, src_size, dst_capacity);
+ size_t written = fwrite(dst, 1, dst_size, out);
+// printf("Writing %zu bytes\n", dst_size);
+ bytes_written += dst_size;
+ if (written != dst_size) {
+ printf("Decompress: Failed to write to file\n");
+ goto cleanup;
+ }
+ src_ptr += src_size;
+ src_size = src_end - src_ptr;
+ }
+
+ /* Update input */
+
+ }
+
+ printf("Wrote %zu bytes\n", bytes_written);
+
+ cleanup:
+ free(src);
+ free(dst);
+
+ return ret;
+}
+
+int main2(int argc, char *argv[]) {
+ char inpFilename[256] = { 0 };
+ char ldmFilename[256] = { 0 };
+ char decFilename[256] = { 0 };
+
+ if (argc < 2) {
+ printf("Please specify input filename\n");
+ return 0;
+ }
+ snprintf(inpFilename, 256, "%s", argv[1]);
+ snprintf(ldmFilename, 256, "%s.ldm", argv[1]);
+ snprintf(decFilename, 256, "%s.ldm.dec", argv[1]);
+
+ printf("inp = [%s]\n", inpFilename);
+ printf("ldm = [%s]\n", ldmFilename);
+ printf("dec = [%s]\n", decFilename);
+
+ /* compress */
+ {
+ FILE *inpFp = fopen(inpFilename, "rb");
+ FILE *outFp = fopen(ldmFilename, "wb");
+ size_t sizeIn = 0;
+ size_t sizeOut = 0;
+ size_t ret;
+ printf("compress : %s -> %s\n", inpFilename, ldmFilename);
+ ret = compress_file(inpFp, outFp, &sizeIn, &sizeOut);
+ if (ret) {
+ printf("compress : failed with code %zu\n", ret);
+ return ret;
+ }
+ printf("%s: %zu → %zu bytes, %.1f%%\n",
+ inpFilename, sizeIn, sizeOut,
+ (double)sizeOut / sizeIn * 100);
+ printf("compress : done\n");
+
+ fclose(outFp);
+ fclose(inpFp);
+ }
+
+ /* decompress */
+ {
+ FILE *inpFp = fopen(ldmFilename, "rb");
+ FILE *outFp = fopen(decFilename, "wb");
+ size_t ret;
+
+ printf("decompress : %s -> %s\n", ldmFilename, decFilename);
+ ret = decompress_file(inpFp, outFp);
+ if (ret) {
+ printf("decompress : failed with code %zu\n", ret);
+ return ret;
+ }
+ printf("decompress : done\n");
+
+ fclose(outFp);
+ fclose(inpFp);
+ }
+
+ /* verify */
+ {
+ FILE *inpFp = fopen(inpFilename, "rb");
+ FILE *decFp = fopen(decFilename, "rb");
+
+ printf("verify : %s <-> %s\n", inpFilename, decFilename);
+ const int cmp = compare(inpFp, decFp);
+ if(0 == cmp) {
+ printf("verify : OK\n");
+ } else {
+ printf("verify : NG\n");
+ }
+
+ fclose(decFp);
+ fclose(inpFp);
+ }
+ return 0;
+}
+#endif
+
--- /dev/null
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "util.h"
+
+typedef uint8_t BYTE;
+typedef uint16_t U16;
+typedef uint32_t U32;
+typedef int32_t S32;
+typedef uint64_t U64;
+
+unsigned LDM_isLittleEndian(void) {
+ const union { U32 u; BYTE c[4]; } one = { 1 };
+ return one.c[0];
+}
+
+U16 LDM_read16(const void *memPtr) {
+ U16 val;
+ memcpy(&val, memPtr, sizeof(val));
+ return val;
+}
+
+U16 LDM_readLE16(const void *memPtr) {
+ if (LDM_isLittleEndian()) {
+ return LDM_read16(memPtr);
+ } else {
+ const BYTE *p = (const BYTE *)memPtr;
+ return (U16)((U16)p[0] + (p[1] << 8));
+ }
+}
+
+void LDM_write16(void *memPtr, U16 value){
+ memcpy(memPtr, &value, sizeof(value));
+}
+
+void LDM_write32(void *memPtr, U32 value) {
+ memcpy(memPtr, &value, sizeof(value));
+}
+
+void LDM_writeLE16(void *memPtr, U16 value) {
+ if (LDM_isLittleEndian()) {
+ LDM_write16(memPtr, value);
+ } else {
+ BYTE* p = (BYTE *)memPtr;
+ p[0] = (BYTE) value;
+ p[1] = (BYTE)(value>>8);
+ }
+}
+
+U32 LDM_read32(const void *ptr) {
+ return *(const U32 *)ptr;
+}
+
+U64 LDM_read64(const void *ptr) {
+ return *(const U64 *)ptr;
+}
+
+void LDM_copy8(void *dst, const void *src) {
+ memcpy(dst, src, 8);
+}
+
+
--- /dev/null
+#ifndef LDM_UTIL_H
+#define LDM_UTIL_H
+
+unsigned LDM_isLittleEndian(void);
+
+uint16_t LDM_read16(const void *memPtr);
+
+uint16_t LDM_readLE16(const void *memPtr);
+
+void LDM_write16(void *memPtr, uint16_t value);
+
+void LDM_write32(void *memPtr, uint32_t value);
+
+void LDM_writeLE16(void *memPtr, uint16_t value);
+
+uint32_t LDM_read32(const void *ptr);
+
+uint64_t LDM_read64(const void *ptr);
+
+void LDM_copy8(void *dst, const void *src);
+
+
+#endif /* LDM_UTIL_H */
projects / thirdparty / zstd.git / commitdiff
