electrobun 0.0.1 → 0.0.2

package/src/bsdiff/zstd/contrib/seekable_format/zstdseek_decompress.c

@@ -1,595 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-/* *********************************************************
-*  Turn on Large Files support (>4GB) for 32-bit Linux/Unix
-***********************************************************/
-#if !defined(__64BIT__) || defined(__MINGW32__)       /* No point defining Large file for 64 bit but MinGW-w64 requires it */
-#  if !defined(_FILE_OFFSET_BITS)
-#    define _FILE_OFFSET_BITS 64                      /* turn off_t into a 64-bit type for ftello, fseeko */
-#  endif
-#  if !defined(_LARGEFILE_SOURCE)                     /* obsolete macro, replaced with _FILE_OFFSET_BITS */
-#    define _LARGEFILE_SOURCE 1                       /* Large File Support extension (LFS) - fseeko, ftello */
-#  endif
-#  if defined(_AIX) || defined(__hpux)
-#    define _LARGE_FILES                              /* Large file support on 32-bits AIX and HP-UX */
-#  endif
-#endif
-
-/* ************************************************************
-*  Detect POSIX version
-*  PLATFORM_POSIX_VERSION = 0 for non-Unix e.g. Windows
-*  PLATFORM_POSIX_VERSION = 1 for Unix-like but non-POSIX
-*  PLATFORM_POSIX_VERSION > 1 is equal to found _POSIX_VERSION
-*  Value of PLATFORM_POSIX_VERSION can be forced on command line
-***************************************************************/
-#ifndef PLATFORM_POSIX_VERSION
-
-#  if (defined(__APPLE__) && defined(__MACH__)) || defined(__SVR4) || defined(_AIX) || defined(__hpux) /* POSIX.1-2001 (SUSv3) conformant */ \
-     || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)  /* BSD distros */
-     /* exception rule : force posix version to 200112L,
-      * note: it's better to use unistd.h's _POSIX_VERSION whenever possible */
-#    define PLATFORM_POSIX_VERSION 200112L
-
-/* try to determine posix version through official unistd.h's _POSIX_VERSION (https://pubs.opengroup.org/onlinepubs/7908799/xsh/unistd.h.html).
- * note : there is no simple way to know in advance if <unistd.h> is present or not on target system,
- * Posix specification mandates its presence and its content, but target system must respect this spec.
- * It's necessary to _not_ #include <unistd.h> whenever target OS is not unix-like
- * otherwise it will block preprocessing stage.
- * The following list of build macros tries to "guess" if target OS is likely unix-like, and therefore can #include <unistd.h>
- */
-#  elif !defined(_WIN32) \
-     && ( defined(__unix__) || defined(__unix) \
-       || defined(__midipix__) || defined(__VMS) || defined(__HAIKU__) )
-
-#    if defined(__linux__) || defined(__linux) || defined(__CYGWIN__)
-#      ifndef _POSIX_C_SOURCE
-#        define _POSIX_C_SOURCE 200809L  /* feature test macro : https://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html */
-#      endif
-#    endif
-#    include <unistd.h>  /* declares _POSIX_VERSION */
-#    if defined(_POSIX_VERSION)  /* POSIX compliant */
-#      define PLATFORM_POSIX_VERSION _POSIX_VERSION
-#    else
-#      define PLATFORM_POSIX_VERSION 1
-#    endif
-
-#    ifdef __UCLIBC__
-#     ifndef __USE_MISC
-#      define __USE_MISC /* enable st_mtim on uclibc */
-#     endif
-#    endif
-
-#  else  /* non-unix target platform (like Windows) */
-#    define PLATFORM_POSIX_VERSION 0
-#  endif
-
-#endif   /* PLATFORM_POSIX_VERSION */
-
-
-/* ************************************************************
-* Avoid fseek()'s 2GiB barrier with MSVC, macOS, *BSD, MinGW
-***************************************************************/
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-#   define LONG_SEEK _fseeki64
-#elif !defined(__64BIT__) && (PLATFORM_POSIX_VERSION >= 200112L) /* No point defining Large file for 64 bit */
-#   define LONG_SEEK fseeko
-#elif defined(__MINGW32__) && !defined(__STRICT_ANSI__) && !defined(__NO_MINGW_LFS) && defined(__MSVCRT__)
-#   define LONG_SEEK fseeko64
-#elif defined(_WIN32) && !defined(__DJGPP__)
-#   include <windows.h>
-    static int LONG_SEEK(FILE* file, __int64 offset, int origin) {
-        LARGE_INTEGER off;
-        DWORD method;
-        off.QuadPart = offset;
-        if (origin == SEEK_END)
-            method = FILE_END;
-        else if (origin == SEEK_CUR)
-            method = FILE_CURRENT;
-        else
-            method = FILE_BEGIN;
-
-        if (SetFilePointerEx((HANDLE) _get_osfhandle(_fileno(file)), off, NULL, method))
-            return 0;
-        else
-            return -1;
-    }
-#else
-#   define LONG_SEEK fseek
-#endif
-
-#include <stdlib.h>  /* malloc, free */
-#include <stdio.h>   /* FILE* */
-#include <limits.h>  /* UNIT_MAX */
-#include <assert.h>
-
-#define XXH_STATIC_LINKING_ONLY
-#include "xxhash.h"
-
-#define ZSTD_STATIC_LINKING_ONLY
-#include "zstd.h"
-#include "zstd_errors.h"
-#include "mem.h"
-#include "zstd_seekable.h"
-
-#undef ERROR
-#define ERROR(name) ((size_t)-ZSTD_error_##name)
-
-#define CHECK_IO(f) { int const errcod = (f); if (errcod < 0) return ERROR(seekableIO); }
-
-#undef MIN
-#undef MAX
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-
-#define ZSTD_SEEKABLE_NO_OUTPUT_PROGRESS_MAX 16
-
-/* Special-case callbacks for FILE* and in-memory modes, so that we can treat
- * them the same way as the advanced API */
-static int ZSTD_seekable_read_FILE(void* opaque, void* buffer, size_t n)
-{
-    size_t const result = fread(buffer, 1, n, (FILE*)opaque);
-    if (result != n) {
-        return -1;
-    }
-    return 0;
-}
-
-static int ZSTD_seekable_seek_FILE(void* opaque, long long offset, int origin)
-{
-    int const ret = LONG_SEEK((FILE*)opaque, offset, origin);
-    if (ret) return ret;
-    return fflush((FILE*)opaque);
-}
-
-typedef struct {
-    const void *ptr;
-    size_t size;
-    size_t pos;
-} buffWrapper_t;
-
-static int ZSTD_seekable_read_buff(void* opaque, void* buffer, size_t n)
-{
-    buffWrapper_t* const buff = (buffWrapper_t*)opaque;
-    assert(buff != NULL);
-    if (buff->pos + n > buff->size) return -1;
-    memcpy(buffer, (const BYTE*)buff->ptr + buff->pos, n);
-    buff->pos += n;
-    return 0;
-}
-
-static int ZSTD_seekable_seek_buff(void* opaque, long long offset, int origin)
-{
-    buffWrapper_t* const buff = (buffWrapper_t*) opaque;
-    unsigned long long newOffset;
-    assert(buff != NULL);
-    switch (origin) {
-    case SEEK_SET:
-        assert(offset >= 0);
-        newOffset = (unsigned long long)offset;
-        break;
-    case SEEK_CUR:
-        newOffset = (unsigned long long)((long long)buff->pos + offset);
-        break;
-    case SEEK_END:
-        newOffset = (unsigned long long)((long long)buff->size + offset);
-        break;
-    default:
-        assert(0);  /* not possible */
-    }
-    if (newOffset > buff->size) {
-        return -1;
-    }
-    buff->pos = newOffset;
-    return 0;
-}
-
-typedef struct {
-    U64 cOffset;
-    U64 dOffset;
-    U32 checksum;
-} seekEntry_t;
-
-struct ZSTD_seekTable_s {
-    seekEntry_t* entries;
-    size_t tableLen;
-
-    int checksumFlag;
-};
-
-#define SEEKABLE_BUFF_SIZE ZSTD_BLOCKSIZE_MAX
-
-struct ZSTD_seekable_s {
-    ZSTD_DStream* dstream;
-    ZSTD_seekTable seekTable;
-    ZSTD_seekable_customFile src;
-
-    U64 decompressedOffset;
-    U32 curFrame;
-
-    BYTE inBuff[SEEKABLE_BUFF_SIZE]; /* need to do our own input buffering */
-    BYTE outBuff[SEEKABLE_BUFF_SIZE]; /* so we can efficiently decompress the
-                                         starts of chunks before we get to the
-                                         desired section */
-    ZSTD_inBuffer in; /* maintain continuity across ZSTD_seekable_decompress operations */
-    buffWrapper_t buffWrapper; /* for `src.opaque` in in-memory mode */
-
-    XXH64_state_t xxhState;
-};
-
-ZSTD_seekable* ZSTD_seekable_create(void)
-{
-    ZSTD_seekable* const zs = (ZSTD_seekable*)malloc(sizeof(ZSTD_seekable));
-    if (zs == NULL) return NULL;
-
-    /* also initializes stage to zsds_init */
-    memset(zs, 0, sizeof(*zs));
-
-    zs->dstream = ZSTD_createDStream();
-    if (zs->dstream == NULL) {
-        free(zs);
-        return NULL;
-    }
-
-    return zs;
-}
-
-size_t ZSTD_seekable_free(ZSTD_seekable* zs)
-{
-    if (zs == NULL) return 0; /* support free on null */
-    ZSTD_freeDStream(zs->dstream);
-    free(zs->seekTable.entries);
-    free(zs);
-    return 0;
-}
-
-ZSTD_seekTable* ZSTD_seekTable_create_fromSeekable(const ZSTD_seekable* zs)
-{
-    ZSTD_seekTable* const st = (ZSTD_seekTable*)malloc(sizeof(ZSTD_seekTable));
-    if (st==NULL) return NULL;
-
-    st->checksumFlag = zs->seekTable.checksumFlag;
-    st->tableLen = zs->seekTable.tableLen;
-
-    /* Allocate an extra entry at the end to match logic of initial allocation */
-    size_t const entriesSize = sizeof(seekEntry_t) * (zs->seekTable.tableLen + 1);
-    seekEntry_t* const entries = (seekEntry_t*)malloc(entriesSize);
-    if (entries==NULL) {
-        free(st);
-        return NULL;
-    }
-
-    memcpy(entries, zs->seekTable.entries, entriesSize);
-    st->entries = entries;
-    return st;
-}
-
-size_t ZSTD_seekTable_free(ZSTD_seekTable* st)
-{
-    if (st == NULL) return 0; /* support free on null */
-    free(st->entries);
-    free(st);
-    return 0;
-}
-
-/** ZSTD_seekable_offsetToFrameIndex() :
- *  Performs a binary search to find the last frame with a decompressed offset
- *  <= pos
- *  @return : the frame's index */
-unsigned ZSTD_seekable_offsetToFrameIndex(const ZSTD_seekable* zs, unsigned long long pos)
-{
-    return ZSTD_seekTable_offsetToFrameIndex(&zs->seekTable, pos);
-}
-
-unsigned ZSTD_seekTable_offsetToFrameIndex(const ZSTD_seekTable* st, unsigned long long pos)
-{
-    U32 lo = 0;
-    U32 hi = (U32)st->tableLen;
-    assert(st->tableLen <= UINT_MAX);
-
-    if (pos >= st->entries[st->tableLen].dOffset) {
-        return (unsigned)st->tableLen;
-    }
-
-    while (lo + 1 < hi) {
-        U32 const mid = lo + ((hi - lo) >> 1);
-        if (st->entries[mid].dOffset <= pos) {
-            lo = mid;
-        } else {
-            hi = mid;
-        }
-    }
-    return lo;
-}
-
-unsigned ZSTD_seekable_getNumFrames(const ZSTD_seekable* zs)
-{
-    return ZSTD_seekTable_getNumFrames(&zs->seekTable);
-}
-
-unsigned ZSTD_seekTable_getNumFrames(const ZSTD_seekTable* st)
-{
-    assert(st->tableLen <= UINT_MAX);
-    return (unsigned)st->tableLen;
-}
-
-unsigned long long ZSTD_seekable_getFrameCompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex)
-{
-    return ZSTD_seekTable_getFrameCompressedOffset(&zs->seekTable, frameIndex);
-}
-
-unsigned long long ZSTD_seekTable_getFrameCompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex)
-{
-    if (frameIndex >= st->tableLen) return ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE;
-    return st->entries[frameIndex].cOffset;
-}
-
-unsigned long long ZSTD_seekable_getFrameDecompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex)
-{
-    return ZSTD_seekTable_getFrameDecompressedOffset(&zs->seekTable, frameIndex);
-}
-
-unsigned long long ZSTD_seekTable_getFrameDecompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex)
-{
-    if (frameIndex >= st->tableLen) return ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE;
-    return st->entries[frameIndex].dOffset;
-}
-
-size_t ZSTD_seekable_getFrameCompressedSize(const ZSTD_seekable* zs, unsigned frameIndex)
-{
-    return ZSTD_seekTable_getFrameCompressedSize(&zs->seekTable, frameIndex);
-}
-
-size_t ZSTD_seekTable_getFrameCompressedSize(const ZSTD_seekTable* st, unsigned frameIndex)
-{
-    if (frameIndex >= st->tableLen) return ERROR(frameIndex_tooLarge);
-    return st->entries[frameIndex + 1].cOffset -
-           st->entries[frameIndex].cOffset;
-}
-
-size_t ZSTD_seekable_getFrameDecompressedSize(const ZSTD_seekable* zs, unsigned frameIndex)
-{
-    return ZSTD_seekTable_getFrameDecompressedSize(&zs->seekTable, frameIndex);
-}
-
-size_t ZSTD_seekTable_getFrameDecompressedSize(const ZSTD_seekTable* st, unsigned frameIndex)
-{
-    if (frameIndex > st->tableLen) return ERROR(frameIndex_tooLarge);
-    return st->entries[frameIndex + 1].dOffset -
-           st->entries[frameIndex].dOffset;
-}
-
-static size_t ZSTD_seekable_loadSeekTable(ZSTD_seekable* zs)
-{
-    int checksumFlag;
-    ZSTD_seekable_customFile src = zs->src;
-    /* read the footer, fixed size */
-    CHECK_IO(src.seek(src.opaque, -(int)ZSTD_seekTableFooterSize, SEEK_END));
-    CHECK_IO(src.read(src.opaque, zs->inBuff, ZSTD_seekTableFooterSize));
-
-    if (MEM_readLE32(zs->inBuff + 5) != ZSTD_SEEKABLE_MAGICNUMBER) {
-        return ERROR(prefix_unknown);
-    }
-
-    {   BYTE const sfd = zs->inBuff[4];
-        checksumFlag = sfd >> 7;
-
-        /* check reserved bits */
-        if ((sfd >> 2) & 0x1f) {
-            return ERROR(corruption_detected);
-    }   }
-
-    {   U32 const numFrames = MEM_readLE32(zs->inBuff);
-        U32 const sizePerEntry = 8 + (checksumFlag?4:0);
-        U32 const tableSize = sizePerEntry * numFrames;
-        U32 const frameSize = tableSize + ZSTD_seekTableFooterSize + ZSTD_SKIPPABLEHEADERSIZE;
-
-        U32 remaining = frameSize - ZSTD_seekTableFooterSize; /* don't need to re-read footer */
-        {   U32 const toRead = MIN(remaining, SEEKABLE_BUFF_SIZE);
-            CHECK_IO(src.seek(src.opaque, -(S64)frameSize, SEEK_END));
-            CHECK_IO(src.read(src.opaque, zs->inBuff, toRead));
-            remaining -= toRead;
-        }
-
-        if (MEM_readLE32(zs->inBuff) != (ZSTD_MAGIC_SKIPPABLE_START | 0xE)) {
-            return ERROR(prefix_unknown);
-        }
-        if (MEM_readLE32(zs->inBuff+4) + ZSTD_SKIPPABLEHEADERSIZE != frameSize) {
-            return ERROR(prefix_unknown);
-        }
-
-        {   /* Allocate an extra entry at the end so that we can do size
-             * computations on the last element without special case */
-            seekEntry_t* const entries = (seekEntry_t*)malloc(sizeof(seekEntry_t) * (numFrames + 1));
-
-            U32 idx = 0;
-            U32 pos = 8;
-
-            U64 cOffset = 0;
-            U64 dOffset = 0;
-
-            if (entries == NULL) return ERROR(memory_allocation);
-
-            /* compute cumulative positions */
-            for (; idx < numFrames; idx++) {
-                if (pos + sizePerEntry > SEEKABLE_BUFF_SIZE) {
-                    U32 const offset = SEEKABLE_BUFF_SIZE - pos;
-                    U32 const toRead = MIN(remaining, SEEKABLE_BUFF_SIZE - offset);
-                    memmove(zs->inBuff, zs->inBuff + pos, offset); /* move any data we haven't read yet */
-                    CHECK_IO(src.read(src.opaque, zs->inBuff+offset, toRead));
-                    remaining -= toRead;
-                    pos = 0;
-                }
-                entries[idx].cOffset = cOffset;
-                entries[idx].dOffset = dOffset;
-
-                cOffset += MEM_readLE32(zs->inBuff + pos);
-                pos += 4;
-                dOffset += MEM_readLE32(zs->inBuff + pos);
-                pos += 4;
-                if (checksumFlag) {
-                    entries[idx].checksum = MEM_readLE32(zs->inBuff + pos);
-                    pos += 4;
-                }
-            }
-            entries[numFrames].cOffset = cOffset;
-            entries[numFrames].dOffset = dOffset;
-
-            zs->seekTable.entries = entries;
-            zs->seekTable.tableLen = numFrames;
-            zs->seekTable.checksumFlag = checksumFlag;
-            return 0;
-        }
-    }
-}
-
-size_t ZSTD_seekable_initBuff(ZSTD_seekable* zs, const void* src, size_t srcSize)
-{
-    zs->buffWrapper = (buffWrapper_t){src, srcSize, 0};
-    {   ZSTD_seekable_customFile srcFile = {&zs->buffWrapper,
-                                            &ZSTD_seekable_read_buff,
-                                            &ZSTD_seekable_seek_buff};
-        return ZSTD_seekable_initAdvanced(zs, srcFile); }
-}
-
-size_t ZSTD_seekable_initFile(ZSTD_seekable* zs, FILE* src)
-{
-    ZSTD_seekable_customFile srcFile = {src, &ZSTD_seekable_read_FILE,
-                                        &ZSTD_seekable_seek_FILE};
-    return ZSTD_seekable_initAdvanced(zs, srcFile);
-}
-
-size_t ZSTD_seekable_initAdvanced(ZSTD_seekable* zs, ZSTD_seekable_customFile src)
-{
-    zs->src = src;
-
-    {   const size_t seekTableInit = ZSTD_seekable_loadSeekTable(zs);
-        if (ZSTD_isError(seekTableInit)) return seekTableInit; }
-
-    zs->decompressedOffset = (U64)-1;
-    zs->curFrame = (U32)-1;
-
-    {   const size_t dstreamInit = ZSTD_initDStream(zs->dstream);
-        if (ZSTD_isError(dstreamInit)) return dstreamInit; }
-    return 0;
-}
-
-size_t ZSTD_seekable_decompress(ZSTD_seekable* zs, void* dst, size_t len, unsigned long long offset)
-{
-    unsigned long long const eos = zs->seekTable.entries[zs->seekTable.tableLen].dOffset;
-    if (offset + len > eos) {
-        len = eos - offset;
-    }
-
-    U32 targetFrame = ZSTD_seekable_offsetToFrameIndex(zs, offset);
-    U32 noOutputProgressCount = 0;
-    size_t srcBytesRead = 0;
-    do {
-        /* check if we can continue from a previous decompress job */
-        if (targetFrame != zs->curFrame || offset < zs->decompressedOffset) {
-            zs->decompressedOffset = zs->seekTable.entries[targetFrame].dOffset;
-            zs->curFrame = targetFrame;
-
-            assert(zs->seekTable.entries[targetFrame].cOffset < LLONG_MAX);
-            CHECK_IO(zs->src.seek(zs->src.opaque,
-                                  (long long)zs->seekTable.entries[targetFrame].cOffset,
-                                  SEEK_SET));
-            zs->in = (ZSTD_inBuffer){zs->inBuff, 0, 0};
-            XXH64_reset(&zs->xxhState, 0);
-            ZSTD_DCtx_reset(zs->dstream, ZSTD_reset_session_only);
-            if (zs->buffWrapper.size && srcBytesRead > zs->buffWrapper.size) {
-                return ERROR(seekableIO);
-            }
-        }
-
-        while (zs->decompressedOffset < offset + len) {
-            size_t toRead;
-            ZSTD_outBuffer outTmp;
-            size_t prevOutPos;
-            size_t prevInPos;
-            size_t forwardProgress;
-            if (zs->decompressedOffset < offset) {
-                /* dummy decompressions until we get to the target offset */
-                outTmp = (ZSTD_outBuffer){zs->outBuff, (size_t) (MIN(SEEKABLE_BUFF_SIZE, offset - zs->decompressedOffset)), 0};
-            } else {
-                outTmp = (ZSTD_outBuffer){dst, len, (size_t) (zs->decompressedOffset - offset)};
-            }
-
-            prevOutPos = outTmp.pos;
-            prevInPos = zs->in.pos;
-            toRead = ZSTD_decompressStream(zs->dstream, &outTmp, &zs->in);
-            if (ZSTD_isError(toRead)) {
-                return toRead;
-            }
-
-            if (zs->seekTable.checksumFlag) {
-                XXH64_update(&zs->xxhState, (BYTE*)outTmp.dst + prevOutPos,
-                             outTmp.pos - prevOutPos);
-            }
-            forwardProgress = outTmp.pos - prevOutPos;
-            if (forwardProgress == 0) {
-                if (noOutputProgressCount++ > ZSTD_SEEKABLE_NO_OUTPUT_PROGRESS_MAX) {
-                    return ERROR(seekableIO);
-                }
-            } else {
-                noOutputProgressCount = 0;
-            }
-            zs->decompressedOffset += forwardProgress;
-            srcBytesRead += zs->in.pos - prevInPos;
-
-            if (toRead == 0) {
-                /* frame complete */
-
-                /* verify checksum */
-                if (zs->seekTable.checksumFlag &&
-                    (XXH64_digest(&zs->xxhState) & 0xFFFFFFFFU) !=
-                            zs->seekTable.entries[targetFrame].checksum) {
-                    return ERROR(corruption_detected);
-                }
-
-                if (zs->decompressedOffset < offset + len) {
-                    /* go back to the start and force a reset of the stream */
-                    targetFrame = ZSTD_seekable_offsetToFrameIndex(zs, zs->decompressedOffset);
-                    /* in this case it will fail later with corruption_detected, since last block does not have checksum */
-                    assert(targetFrame != zs->seekTable.tableLen);
-                }
-                break;
-            }
-
-            /* read in more data if we're done with this buffer */
-            if (zs->in.pos == zs->in.size) {
-                toRead = MIN(toRead, SEEKABLE_BUFF_SIZE);
-                CHECK_IO(zs->src.read(zs->src.opaque, zs->inBuff, toRead));
-                zs->in.size = toRead;
-                zs->in.pos = 0;
-            }
-        }  /* while (zs->decompressedOffset < offset + len) */
-    } while (zs->decompressedOffset != offset + len);
-
-    return len;
-}
-
-size_t ZSTD_seekable_decompressFrame(ZSTD_seekable* zs, void* dst, size_t dstSize, unsigned frameIndex)
-{
-    if (frameIndex >= zs->seekTable.tableLen) {
-        return ERROR(frameIndex_tooLarge);
-    }
-
-    {   size_t const decompressedSize =
-                zs->seekTable.entries[frameIndex + 1].dOffset -
-                zs->seekTable.entries[frameIndex].dOffset;
-        if (dstSize < decompressedSize) {
-            return ERROR(dstSize_tooSmall);
-        }
-        return ZSTD_seekable_decompress(
-                zs, dst, decompressedSize,
-                zs->seekTable.entries[frameIndex].dOffset);
-    }
-}

package/src/bsdiff/zstd/contrib/seqBench/Makefile

@@ -1,58 +0,0 @@
-# ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under both the BSD-style license (found in the
-# LICENSE file in the root directory of this source tree) and the GPLv2 (found
-# in the COPYING file in the root directory of this source tree).
-# ################################################################
-
-PROGDIR = ../../programs
-LIBDIR  = ../../lib
-
-LIBZSTD = $(LIBDIR)/libzstd.a
-
-CPPFLAGS+= -I$(LIBDIR) -I$(LIBDIR)/common -I$(LIBDIR)/dictBuilder -I$(PROGDIR)
-
-CFLAGS  ?= -O3 -g
-CFLAGS  += -std=gnu99
-DEBUGFLAGS= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
-            -Wstrict-aliasing=1 -Wswitch-enum \
-            -Wstrict-prototypes -Wundef -Wpointer-arith \
-            -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
-            -Wredundant-decls
-CFLAGS  += $(DEBUGFLAGS) $(MOREFLAGS)
-
-
-default: seqBench
-
-all : seqBench
-
-seqBench: util.o timefn.o benchfn.o datagen.o xxhash.o seqBench.c $(LIBZSTD)
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
-
-.PHONY: $(LIBZSTD)
-$(LIBZSTD):
-	$(MAKE) -C $(LIBDIR) libzstd.a CFLAGS="$(CFLAGS)"
-
-benchfn.o: $(PROGDIR)/benchfn.c
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c
-
-timefn.o: $(PROGDIR)/timefn.c
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c
-
-datagen.o: $(PROGDIR)/datagen.c
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c
-
-util.o: $(PROGDIR)/util.c
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c
-
-
-xxhash.o : $(LIBDIR)/common/xxhash.c
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c
-
-
-clean:
-	$(RM) *.o
-	$(MAKE) -C $(LIBDIR) clean > /dev/null
-	$(RM) seqBench

package/src/bsdiff/zstd/contrib/seqBench/seqBench.c

@@ -1,53 +0,0 @@
-#define ZSTD_STATIC_LINKING_ONLY
-#include <zstd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <string.h>
-
-int main(int argc, char *argv[]) {
-    ZSTD_CCtx* zc = ZSTD_createCCtx();
-
-    if (argc != 2) {
-        printf("Usage: seqBench <file>\n"); // TODO provide the block delim option here
-        return 1;
-    }
-
-    FILE *f = fopen(argv[1], "rb");
-    fseek(f, 0, SEEK_END);
-    long inBufSize = ftell(f);
-    fseek(f, 0, SEEK_SET);
-
-    char *inBuf = malloc(inBufSize + 1);
-    fread(inBuf, inBufSize, 1, f);
-    fclose(f);
-
-    size_t seqsSize = ZSTD_sequenceBound(inBufSize);
-    ZSTD_Sequence *seqs = (ZSTD_Sequence*)malloc(seqsSize * sizeof(ZSTD_Sequence));
-    char *outBuf = malloc(ZSTD_compressBound(inBufSize));
-
-    ZSTD_generateSequences(zc, seqs, seqsSize, inBuf, inBufSize);
-    ZSTD_CCtx_setParameter(zc, ZSTD_c_blockDelimiters, ZSTD_sf_explicitBlockDelimiters);
-    size_t outBufSize = ZSTD_compressSequences(zc, outBuf, inBufSize, seqs, seqsSize, inBuf, inBufSize);
-    if (ZSTD_isError(outBufSize)) {
-        printf("ERROR: %lu\n", outBufSize);
-        return 1;
-    }
-
-    char *validationBuf = malloc(inBufSize);
-    ZSTD_decompress(validationBuf, inBufSize, outBuf, outBufSize);
-
-    if (memcmp(inBuf, validationBuf, inBufSize) == 0) {
-        printf("Compression and decompression were successful!\n");
-    } else {
-        printf("ERROR: input and validation buffers don't match!\n");
-        for (int i = 0; i < inBufSize; i++) {
-            if (inBuf[i] != validationBuf[i]) {
-                printf("First bad index: %d\n", i);
-                break;
-            }
-        }
-    }
-
-    return 0;
-}