blockStreaming_doubleBuffer.c File Reference

#include "lz4.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

Go to the source code of this file.

Enumerations
enum	{ BLOCK_BYTES = 1024 * 8 }

Functions
size_t	write_int (FILE *fp, int i)
size_t	write_bin (FILE *fp, const void *array, size_t arrayBytes)
size_t	read_int (FILE *fp, int *i)
size_t	read_bin (FILE *fp, void *array, size_t arrayBytes)
void	test_compress (FILE *outFp, FILE *inpFp)
void	test_decompress (FILE *outFp, FILE *inpFp)
int	compare (FILE *fp0, FILE *fp1)
int	main (int argc, char *argv[])

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
BLOCK_BYTES

Definition at line 16 of file blockStreaming_doubleBuffer.c.

     {
    BLOCK_BYTES = 1024 * 8,
//  BLOCK_BYTES = 1024 * 64,
};

Function Documentation

compare()

int compare	(	FILE *	fp0,
		FILE *	fp1
	)

Definition at line 115 of file blockStreaming_doubleBuffer.c.

{
    int result = 0;
 
    while(0 == result) {
        char b0[65536];
        char b1[65536];
        const size_t r0 = read_bin(fp0, b0, sizeof(b0));
        const size_t r1 = read_bin(fp1, b1, sizeof(b1));
 
        result = (int) r0 - (int) r1;
 
        if(0 == r0 || 0 == r1) {
            break;
        }
        if(0 == result) {
            result = memcmp(b0, b1, r0);
        }
    }
 
    return result;
}

References b1, int, r0, r1, and read_bin().

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 139 of file blockStreaming_doubleBuffer.c.

{
    char inpFilename[256] = { 0 };
    char lz4Filename[256] = { 0 };
    char decFilename[256] = { 0 };
 
    if(argc < 2) {
        printf("Please specify input filename\n");
        return 0;
    }
 
    snprintf(inpFilename, 256, "%s", argv[1]);
    snprintf(lz4Filename, 256, "%s.lz4s-%d", argv[1], BLOCK_BYTES);
    snprintf(decFilename, 256, "%s.lz4s-%d.dec", argv[1], BLOCK_BYTES);
 
    printf("inp = [%s]\n", inpFilename);
    printf("lz4 = [%s]\n", lz4Filename);
    printf("dec = [%s]\n", decFilename);
 
    // compress
    {
        FILE* inpFp = fopen(inpFilename, "rb");
        FILE* outFp = fopen(lz4Filename, "wb");
 
        printf("compress : %s -> %s\n", inpFilename, lz4Filename);
        test_compress(outFp, inpFp);
        printf("compress : done\n");
 
        fclose(outFp);
        fclose(inpFp);
    }
 
    // decompress
    {
        FILE* inpFp = fopen(lz4Filename, "rb");
        FILE* outFp = fopen(decFilename, "wb");
 
        printf("decompress : %s -> %s\n", lz4Filename, decFilename);
        test_decompress(outFp, inpFp);
        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;
}

References argv, BLOCK_BYTES, cmp(), compare(), benchmark::FILE, printf(), snprintf, test_compress(), and test_decompress().

read_bin()

size_t read_bin	(	FILE *	fp,
		void *	array,
		size_t	arrayBytes
	)

Definition at line 34 of file blockStreaming_doubleBuffer.c.

                                                          {
    return fread(array, 1, arrayBytes, fp);
}

Referenced by compare(), test_compress(), and test_decompress().

read_int()

size_t read_int	(	FILE *	fp,
		int *	i
	)

Definition at line 30 of file blockStreaming_doubleBuffer.c.

                                  {
    return fread(i, sizeof(*i), 1, fp);
}

References i.

Referenced by test_decompress().

test_compress()

void test_compress	(	FILE *	outFp,
		FILE *	inpFp
	)

Definition at line 39 of file blockStreaming_doubleBuffer.c.

{
    LZ4_stream_t lz4Stream_body;
    LZ4_stream_t* lz4Stream = &lz4Stream_body;
 
    char inpBuf[2][BLOCK_BYTES];
    int  inpBufIndex = 0;
 
    LZ4_initStream(lz4Stream, sizeof (*lz4Stream));
 
    for(;;) {
        char* const inpPtr = inpBuf[inpBufIndex];
        const int inpBytes = (int) read_bin(inpFp, inpPtr, BLOCK_BYTES);
        if(0 == inpBytes) {
            break;
        }
 
        {
            char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
            const int cmpBytes = LZ4_compress_fast_continue(
                lz4Stream, inpPtr, cmpBuf, inpBytes, sizeof(cmpBuf), 1);
            if(cmpBytes <= 0) {
                break;
            }
            write_int(outFp, cmpBytes);
            write_bin(outFp, cmpBuf, (size_t) cmpBytes);
        }
 
        inpBufIndex = (inpBufIndex + 1) % 2;
    }
 
    write_int(outFp, 0);
}

References BLOCK_BYTES, int, LZ4_compress_fast_continue(), LZ4_COMPRESSBOUND, LZ4_initStream(), read_bin(), write_bin(), and write_int().

Referenced by main().

test_decompress()

void test_decompress	(	FILE *	outFp,
		FILE *	inpFp
	)

Definition at line 74 of file blockStreaming_doubleBuffer.c.

{
    LZ4_streamDecode_t lz4StreamDecode_body;
    LZ4_streamDecode_t* lz4StreamDecode = &lz4StreamDecode_body;
 
    char decBuf[2][BLOCK_BYTES];
    int  decBufIndex = 0;
 
    LZ4_setStreamDecode(lz4StreamDecode, NULL, 0);
 
    for(;;) {
        char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
        int  cmpBytes = 0;
 
        {
            const size_t readCount0 = read_int(inpFp, &cmpBytes);
            if(readCount0 != 1 || cmpBytes <= 0) {
                break;
            }
 
            const size_t readCount1 = read_bin(inpFp, cmpBuf, (size_t) cmpBytes);
            if(readCount1 != (size_t) cmpBytes) {
                break;
            }
        }
 
        {
            char* const decPtr = decBuf[decBufIndex];
            const int decBytes = LZ4_decompress_safe_continue(
                lz4StreamDecode, cmpBuf, decPtr, cmpBytes, BLOCK_BYTES);
            if(decBytes <= 0) {
                break;
            }
            write_bin(outFp, decPtr, (size_t) decBytes);
        }
 
        decBufIndex = (decBufIndex + 1) % 2;
    }
}

References BLOCK_BYTES, LZ4_COMPRESSBOUND, LZ4_decompress_safe_continue(), LZ4_setStreamDecode(), NULL, read_bin(), read_int(), and write_bin().

Referenced by main().

write_bin()

size_t write_bin	(	FILE *	fp,
		const void *	array,
		size_t	arrayBytes
	)

Definition at line 26 of file blockStreaming_doubleBuffer.c.

                                                                 {
    return fwrite(array, 1, arrayBytes, fp);
}

Referenced by test_compress(), and test_decompress().

write_int()

size_t write_int	(	FILE *	fp,
		int	i
	)

Definition at line 22 of file blockStreaming_doubleBuffer.c.

                                  {
    return fwrite(&i, sizeof(i), 1, fp);
}

References i.

Referenced by test_compress().