Advertisement
Guest User

Untitled

a guest
Jul 4th, 2015
298
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 3.92 KB | None | 0 0
  1. // LZ4 streaming API example
  2. #define _CRT_SECURE_NO_WARNINGS // for MSVC
  3. #include "lz4.h"
  4.  
  5. #include <stdio.h>
  6. #include <stdint.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. //#define BLOCK_BYTES (1024*64)
  11. #define BLOCK_BYTES (1024*8)
  12.  
  13. size_t write_int32(FILE* fp, int32_t i) {
  14. return fwrite(&i, sizeof(i), 1, fp);
  15. }
  16.  
  17. size_t write_bin(FILE* fp, const void* array, int arrayBytes) {
  18. return fwrite(array, 1, arrayBytes, fp);
  19. }
  20.  
  21. size_t read_int32(FILE* fp, int32_t* i) {
  22. return fread(i, sizeof(*i), 1, fp);
  23. }
  24.  
  25. size_t read_bin(FILE* fp, void* array, int arrayBytes) {
  26. return fread(array, 1, arrayBytes, fp);
  27. }
  28.  
  29.  
  30. void test_compress(FILE* outFp, FILE* inpFp)
  31. {
  32. LZ4_stream_t lz4Stream_body = { 0 };
  33. LZ4_stream_t* lz4Stream = &lz4Stream_body;
  34.  
  35. char inpBuf[2][BLOCK_BYTES] = { 0 };
  36. int inpBufIndex = 0;
  37.  
  38. for(;;)
  39. {
  40. char* const inpPtr = inpBuf[inpBufIndex];
  41. const int inpBytes = (int) read_bin(inpFp, inpPtr, BLOCK_BYTES);
  42. if (inpBytes==0) break;
  43.  
  44. {
  45. char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
  46. const int cmpBytes = LZ4_compress_continue(lz4Stream, inpPtr, cmpBuf, inpBytes);
  47. if(cmpBytes <= 0) break;
  48. write_int32(outFp, cmpBytes);
  49. write_bin(outFp, cmpBuf, cmpBytes);
  50. }
  51.  
  52. inpBufIndex ^= 1;
  53. }
  54.  
  55. write_int32(outFp, 0);
  56. }
  57.  
  58.  
  59. void test_decompress(FILE* outFp, FILE* inpFp)
  60. {
  61. char decBuf[2][BLOCK_BYTES] = { 0 };
  62. int decBufIndex = 0;
  63. LZ4_streamDecode_t ctx = { 0 };
  64.  
  65. for(;;) {
  66. char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
  67. int cmpBytes = 0;
  68.  
  69. {
  70. const size_t readCount0 = read_int32(inpFp, &cmpBytes);
  71. if(readCount0 != 1 || cmpBytes <= 0) break;
  72.  
  73. const size_t readCount1 = read_bin(inpFp, cmpBuf, cmpBytes);
  74. if(readCount1 != (size_t) cmpBytes) break;
  75. }
  76.  
  77. {
  78. char* const decPtr = decBuf[decBufIndex];
  79. const int decBytes = LZ4_decompress_safe_continue(
  80. &ctx, cmpBuf, decPtr, cmpBytes, BLOCK_BYTES);
  81. if(decBytes <= 0) break;
  82. write_bin(outFp, decPtr, decBytes);
  83.  
  84. decBufIndex = (decBufIndex + 1) % 2;
  85. }
  86. }
  87. }
  88.  
  89.  
  90. int compare(FILE* f0, FILE* f1)
  91. {
  92. int result = 0;
  93.  
  94. while(0 == result) {
  95. char b0[65536];
  96. char b1[65536];
  97. const size_t r0 = fread(b0, 1, sizeof(b0), f0);
  98. const size_t r1 = fread(b1, 1, sizeof(b1), f1);
  99.  
  100. result = (int) r0 - (int) r1;
  101.  
  102. if(0 == r0 || 0 == r1) {
  103. break;
  104. }
  105. if(0 == result) {
  106. result = memcmp(b0, b1, r0);
  107. }
  108. }
  109.  
  110. return result;
  111. }
  112.  
  113.  
  114. int main(int argc, char** argv[])
  115. {
  116. char inpFilename[256] = { 0 };
  117. char lz4Filename[256] = { 0 };
  118. char decFilename[256] = { 0 };
  119.  
  120. if(argc < 2) {
  121. printf("Please specify input filename\n");
  122. return 0;
  123. }
  124.  
  125. sprintf(inpFilename, "%s", argv[1]);
  126. sprintf(lz4Filename, "%s.lz4s-%d", argv[1], BLOCK_BYTES);
  127. sprintf(decFilename, "%s.lz4s-%d.dec", argv[1], BLOCK_BYTES);
  128.  
  129. printf("inp = [%s]\n", inpFilename);
  130. printf("lz4 = [%s]\n", lz4Filename);
  131. printf("dec = [%s]\n", decFilename);
  132.  
  133. // compress
  134. {
  135. FILE* inpFp = fopen(inpFilename, "rb");
  136. FILE* outFp = fopen(lz4Filename, "wb");
  137.  
  138. test_compress(outFp, inpFp);
  139.  
  140. fclose(outFp);
  141. fclose(inpFp);
  142. }
  143.  
  144. // decompress
  145. {
  146. FILE* inpFp = fopen(lz4Filename, "rb");
  147. FILE* outFp = fopen(decFilename, "wb");
  148.  
  149. test_decompress(outFp, inpFp);
  150.  
  151. fclose(outFp);
  152. fclose(inpFp);
  153. }
  154.  
  155. // verify
  156. {
  157. FILE* inpFp = fopen(inpFilename, "rb");
  158. FILE* decFp = fopen(decFilename, "rb");
  159.  
  160. const int cmp = compare(inpFp, decFp);
  161. if(0 == cmp) {
  162. printf("OK\n");
  163. } else {
  164. printf("NG\n");
  165. }
  166.  
  167. fclose(decFp);
  168. fclose(inpFp);
  169. }
  170.  
  171. return 0;
  172. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement