decodecorpus.c File Reference

#include <limits.h>
#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "util.h"
#include "timefn.h"
#include "zstd.h"
#include "zstd_internal.h"
#include "mem.h"
#include "zdict.h"
#include "zstd_compress.c"
#include "xxhash.h"

Data Structures
struct	frameHeader_t
struct	cblockStats_t
struct	frame_t
struct	dictInfo

Macros
#define	ZDICT_STATIC_LINKING_ONLY
#define	XXH_STATIC_LINKING_ONLY
#define	MIN(a, b)
#define	MAX_PATH   256
#define	DISPLAY(...)
#define	DISPLAYLEVEL(l, ...)
#define	DISPLAYUPDATE(...)
#define	CHECKERR(code)
#define	RAND_rotl32(x, r)
#define	DISTSIZE   (8192)
#define	ROUND(x)
#define	MAX_DECOMPRESSED_SIZE_LOG   20
#define	MAX_DECOMPRESSED_SIZE   (1ULL << MAX_DECOMPRESSED_SIZE_LOG)
#define	MAX_WINDOW_LOG   22 /* Recommended support is 8MB, so limit to 4MB + mantissa */
#define	MIN_SEQ_LEN   (3)
#define	MAX_NB_SEQ   ((ZSTD_BLOCKSIZE_MAX + MIN_SEQ_LEN - 1) / MIN_SEQ_LEN)

Enumerations
enum	genType_e { gt_frame = 0 , gt_block }

Functions
int	main (int argc, char **argv)

Variables
const char *	BLOCK_TYPES [] = {"raw", "rle", "compressed"}
BYTE	CONTENT_BUFFER [MAX_DECOMPRESSED_SIZE]
BYTE	FRAME_BUFFER [MAX_DECOMPRESSED_SIZE *2]
BYTE	LITERAL_BUFFER [ZSTD_BLOCKSIZE_MAX]
seqDef	SEQUENCE_BUFFER [MAX_NB_SEQ]
BYTE	SEQUENCE_LITERAL_BUFFER [ZSTD_BLOCKSIZE_MAX]
BYTE	SEQUENCE_LLCODE [ZSTD_BLOCKSIZE_MAX]
BYTE	SEQUENCE_MLCODE [ZSTD_BLOCKSIZE_MAX]
BYTE	SEQUENCE_OFCODE [ZSTD_BLOCKSIZE_MAX]
U64	WKSP [HUF_WORKSPACE_SIZE_U64]
U32	g_maxDecompressedSizeLog = MAX_DECOMPRESSED_SIZE_LOG
U32	g_maxBlockSize = ZSTD_BLOCKSIZE_MAX
struct {
int   contentSize
}	opts
BYTE	DECOMPRESSED_BUFFER [MAX_DECOMPRESSED_SIZE]

Macro Definition Documentation

CHECKERR

#define CHECKERR

(

code

)

Value:

    do {                                                                       \
        if (ZSTD_isError(code)) {                                              \
            DISPLAY("Error occurred while generating data: %s\n",              \
                    ZSTD_getErrorName(code));                                  \
            exit(1);                                                           \
        }                                                                      \
    } while (0)

DISPLAY

#define DISPLAY

(

...

)

Value:

fprintf(stderr, __VA_ARGS__)

DISPLAYLEVEL

#define DISPLAYLEVEL	(		l,
			... )

Value:

if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }

DISPLAYUPDATE

#define DISPLAYUPDATE

(

...

)

Value:

    do {                                                                       \
        if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) ||           \
            (g_displayLevel >= 4)) {                                           \
            g_displayClock = UTIL_getTime();                                   \
            DISPLAY(__VA_ARGS__);                                              \
            if (g_displayLevel >= 4) fflush(stderr);                           \
        }                                                                      \
    } while (0)

DISTSIZE

#define DISTSIZE   (8192)

MAX_DECOMPRESSED_SIZE

#define MAX_DECOMPRESSED_SIZE   (1ULL << MAX_DECOMPRESSED_SIZE_LOG)

MAX_DECOMPRESSED_SIZE_LOG

#define MAX_DECOMPRESSED_SIZE_LOG   20

MAX_NB_SEQ

#define MAX_NB_SEQ   ((ZSTD_BLOCKSIZE_MAX + MIN_SEQ_LEN - 1) / MIN_SEQ_LEN)

MAX_PATH

#define MAX_PATH   256

MAX_WINDOW_LOG

#define MAX_WINDOW_LOG   22 /* Recommended support is 8MB, so limit to 4MB + mantissa */

MIN

#define MIN	(		a,
			b )

Value:

((a) < (b) ? (a) : (b))

MIN_SEQ_LEN

#define MIN_SEQ_LEN   (3)

RAND_rotl32

#define RAND_rotl32	(		x,
			r )

Value:

((x << r) | (x >> (32 - r)))

ROUND

#define ROUND

(

x

)

Value:

((U32)(x + 0.5))

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

ZDICT_STATIC_LINKING_ONLY

#define ZDICT_STATIC_LINKING_ONLY

Enumeration Type Documentation

genType_e

enum genType_e

Enumerator
gt_frame
gt_block

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Variable Documentation

BLOCK_TYPES

const char* BLOCK_TYPES[] = {"raw", "rle", "compressed"}

CONTENT_BUFFER

BYTE CONTENT_BUFFER[MAX_DECOMPRESSED_SIZE]

contentSize

int contentSize

DECOMPRESSED_BUFFER

BYTE DECOMPRESSED_BUFFER[MAX_DECOMPRESSED_SIZE]

FRAME_BUFFER

BYTE FRAME_BUFFER[MAX_DECOMPRESSED_SIZE *2]

g_maxBlockSize

U32 g_maxBlockSize = ZSTD_BLOCKSIZE_MAX

g_maxDecompressedSizeLog

U32 g_maxDecompressedSizeLog = MAX_DECOMPRESSED_SIZE_LOG

LITERAL_BUFFER

BYTE LITERAL_BUFFER[ZSTD_BLOCKSIZE_MAX]

[struct]

struct { ... } opts

SEQUENCE_BUFFER

seqDef SEQUENCE_BUFFER[MAX_NB_SEQ]

SEQUENCE_LITERAL_BUFFER

BYTE SEQUENCE_LITERAL_BUFFER[ZSTD_BLOCKSIZE_MAX]

SEQUENCE_LLCODE

BYTE SEQUENCE_LLCODE[ZSTD_BLOCKSIZE_MAX]

SEQUENCE_MLCODE

BYTE SEQUENCE_MLCODE[ZSTD_BLOCKSIZE_MAX]

SEQUENCE_OFCODE

BYTE SEQUENCE_OFCODE[ZSTD_BLOCKSIZE_MAX]

WKSP

U64 WKSP[HUF_WORKSPACE_SIZE_U64]