diff --git a/contrib/liblzma/compress_easy_mt.cpp b/contrib/liblzma/compress_easy_mt.cpp index 380744c..a3e2984 100644 --- a/contrib/liblzma/compress_easy_mt.cpp +++ b/contrib/liblzma/compress_easy_mt.cpp @@ -21,67 +21,7 @@ #include #include "lzma.h" - -static bool -init_encoder(lzma_stream *strm) -{ - // The threaded encoder takes the options as pointer to - // a lzma_mt structure. - lzma_mt mt;// = { - // No flags are needed. - mt .flags = 0; - - // Let liblzma determine a sane block size. - mt .block_size = 0; - - // Use no timeout for lzma_code() calls by setting timeout - // to zero. That is, sometimes lzma_code() might block for - // a long time (from several seconds to even minutes). - // If this is not OK, for example due to progress indicator - // needing updates, specify a timeout in milliseconds here. - // See the documentation of lzma_mt in lzma/container.h for - // information how to choose a reasonable timeout. - mt .timeout = 0; - - // Use the default preset (6) for LZMA2. - // To use a preset, filters must be set to NULL. - mt .preset = LZMA_PRESET_EXTREME; // LZMA_PRESET_DEFAULT, - mt .filters = NULL; - - // Use CRC64 for integrity checking. See also - // 01_compress_easy.c about choosing the integrity check. - mt .check = LZMA_CHECK_CRC64; - //}; - - // Detect how many threads the CPU supports. - mt.threads = lzma_cputhreads(); - - // If the number of CPU cores/threads cannot be detected, - // use one thread. Note that this isn't the same as the normal - // single-threaded mode as this will still split the data into - // blocks and use more RAM than the normal single-threaded mode. - // You may want to consider using lzma_easy_encoder() or - // lzma_stream_encoder() instead of lzma_stream_encoder_mt() if - // lzma_cputhreads() returns 0 or 1. - if (mt.threads == 0) - mt.threads = 1; - - // If the number of CPU cores/threads exceeds threads_max, - // limit the number of threads to keep memory usage lower. - // The number 8 is arbitrarily chosen and may be too low or - // high depending on the compression preset and the computer - // being used. - // - // FIXME: A better way could be to check the amount of RAM - // (or available RAM) and use lzma_stream_encoder_mt_memusage() - // to determine if the number of threads should be reduced. - const uint32_t threads_max = 8; - if (mt.threads > threads_max) - mt.threads = threads_max; - - // Initialize the threaded encoder. - lzma_ret ret = lzma_stream_encoder_mt(strm, &mt); - +bool check(lzma_ret ret) { if (ret == LZMA_OK) return true; @@ -112,27 +52,141 @@ init_encoder(lzma_stream *strm) return false; } +#if _WIN64 || __amd64__ +const uint32_t dict = 4; +#else +const uint32_t dict = 2; +#endif + +bool init_lzma1(lzma_stream *strm) +{ + lzma_options_lzma opt_lzma; + if (lzma_lzma_preset(&opt_lzma, UINT32_C(9))) { // LZMA_PRESET_DEFAULT + fprintf(stderr, "Unsupported preset, possibly a bug\n"); + return false; + } + opt_lzma.dict_size *= dict; + //opt_lzma.mf = LZMA_MF_HC4; + //opt_lzma.mode = LZMA_MODE_FAST; + printf("0x%i%i, %i, dict: %i MB\n", opt_lzma.mf/16, opt_lzma.mf%16, opt_lzma.mode, opt_lzma.dict_size/1048576); + return check(lzma_alone_encoder(strm, &opt_lzma)); +} + +bool init_lzma2(lzma_stream *strm) { + lzma_options_lzma opt_lzma; + if (lzma_lzma_preset(&opt_lzma, UINT32_C(9))) { // LZMA_PRESET_DEFAULT + fprintf(stderr, "Unsupported preset, possibly a bug\n"); + return false; + } + opt_lzma.dict_size *= dict; + lzma_filter filters[] = { + { LZMA_FILTER_LZMA2, &opt_lzma }, + { LZMA_VLI_UNKNOWN, NULL }, + }; + printf("0x%i%i, %i, dict: %i MB\n", opt_lzma.mf / 16, opt_lzma.mf % 16, opt_lzma.mode, opt_lzma.dict_size / 1048576); + return check(lzma_stream_encoder(strm, filters, LZMA_CHECK_CRC32)); +} + +bool init_decoder(lzma_stream *strm) +{ + lzma_ret ret = lzma_auto_decoder( + strm, UINT64_MAX, LZMA_CONCATENATED); + return check(ret); +} + +//static +bool init_encoder_mt(lzma_stream *strm) +{ + // The threaded encoder takes the options as pointer to + // a lzma_mt structure. + lzma_mt mt;// = { + // No flags are needed. + mt .flags = 0; + + // Let liblzma determine a sane block size. + mt .block_size = 0; + + // Use no timeout for lzma_code() calls by setting timeout + // to zero. That is, sometimes lzma_code() might block for + // a long time (from several seconds to even minutes). + // If this is not OK, for example due to progress indicator + // needing updates, specify a timeout in milliseconds here. + // See the documentation of lzma_mt in lzma/container.h for + // information how to choose a reasonable timeout. + mt .timeout = 110; + + // Use the default preset (6) for LZMA2. + // To use a preset, filters must be set to NULL. + mt .preset = //LZMA_PRESET_DEFAULT; //UINT32_C(8); + UINT32_C(9);// | LZMA_PRESET_EXTREME; // 9 OR 9e +#ifdef __BIG_DICT_REQUIRES_MUCH_MORE_MEM // > 8 GB @ _WIN64 || __amd64__ + lzma_options_lzma opt_lzma; + if (lzma_lzma_preset(&opt_lzma, mt.preset)) { // LZMA_PRESET_DEFAULT + fprintf(stderr, "Unsupported preset, possibly a bug\n"); + return false; + } + opt_lzma.dict_size *= 2; + lzma_filter filters[] = { + { LZMA_FILTER_LZMA2, &opt_lzma }, + { LZMA_VLI_UNKNOWN, NULL }, + }; + mt.filters = filters; +#else + mt.filters = NULL; +#endif + + // Use CRC64 for integrity checking. See also + // 01_compress_easy.c about choosing the integrity check. + mt.check = LZMA_CHECK_CRC32; + //}; + + // Detect how many threads the CPU supports. + mt.threads = dict;//lzma_cputhreads(); + + // If the number of CPU cores/threads cannot be detected, + // use one thread. Note that this isn't the same as the normal + // single-threaded mode as this will still split the data into + // blocks and use more RAM than the normal single-threaded mode. + // You may want to consider using lzma_easy_encoder() or + // lzma_stream_encoder() instead of lzma_stream_encoder_mt() if + // lzma_cputhreads() returns 0 or 1. + if (mt.threads == 0) + mt.threads = 1; + + // If the number of CPU cores/threads exceeds threads_max, + // limit the number of threads to keep memory usage lower. + // The number 8 is arbitrarily chosen and may be too low or + // high depending on the compression preset and the computer + // being used. + // + // FIXME: A better way could be to check the amount of RAM + // (or available RAM) and use lzma_stream_encoder_mt_memusage() + // to determine if the number of threads should be reduced. + const uint32_t threads_max = 8; + if (mt.threads > threads_max) + mt.threads = threads_max; + + // Initialize the threaded encoder. + lzma_ret ret = lzma_stream_encoder_mt(strm, &mt); + return check(ret); +} + lzma_action action = LZMA_RUN; uint8_t inbuf[BUFSIZ]; uint8_t outbuf[BUFSIZ]; -static bool -begin_compress(lzma_stream *strm) -{ - action = LZMA_RUN; - - strm->next_in = NULL; - strm->avail_in = 0; - strm->next_out = outbuf; - strm->avail_out = sizeof(outbuf); -} - // This function is identical to the one in 01_compress_easy.c. static bool compress(lzma_stream *strm, FILE *infile, FILE *outfile) { - //while (true) { + action = LZMA_RUN; + + strm->next_in = NULL; + strm->avail_in = 0; + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + while (true) { if (strm->avail_in == 0 && !feof(infile)) { strm->next_in = inbuf; strm->avail_in = fread(inbuf, 1, sizeof(inbuf), @@ -187,7 +241,7 @@ compress(lzma_stream *strm, FILE *infile, FILE *outfile) msg, ret); return false; } - //} + } } /* diff --git a/contrib/liblzma/precomp_xz.h b/contrib/liblzma/precomp_xz.h new file mode 100644 index 0000000..6ad639f --- /dev/null +++ b/contrib/liblzma/precomp_xz.h @@ -0,0 +1,11 @@ +#ifndef PRECOMP_XZ_H +#define PRECOMP_XZ_H + +#include "lzma.h" + +bool init_lzma1(lzma_stream *strm); +bool init_lzma2(lzma_stream *strm); +bool init_encoder_mt(lzma_stream *strm); +bool init_decoder(lzma_stream *strm); + +#endif /* ifndef PRECOMP_XZ_H */ diff --git a/precomp.cpp b/precomp.cpp index cce1460..5ba910b 100644 --- a/precomp.cpp +++ b/precomp.cpp @@ -125,7 +125,17 @@ float global_max_percent = 100; // compression-on-the-fly unsigned char bz2_in[CHUNK]; unsigned char bz2_out[CHUNK]; + +//#ifdef COMFORT +#include "contrib/liblzma/precomp_xz.h" +lzma_stream otf_xz_stream_c = LZMA_STREAM_INIT, otf_xz_stream_d = LZMA_STREAM_INIT; +//#endif // COMFORT + +#ifdef LZMA_H +int compression_otf_method = 4; // 0 = uncompressed, 1 = bZip2, 2 = lzma, 3 = xz(lzma2), 4 = xz_MT +#else int compression_otf_method = 1; // 0 = uncompressed, 1 = bZip2 +#endif // LZMA_H int conversion_from_method; // 0 = uncompressed, 1 = bZip2 int conversion_to_method; // 0 = uncompressed, 1 = bZip2 bool decompress_otf_end = false; @@ -768,6 +778,17 @@ int init(int argc, char* argv[]) { case 'B': // bZip2 compression_otf_method = 1; break; +#ifdef LZMA_H + case 'L': // lzma + compression_otf_method = 2; + break; + case 'X': // xz(lzma2) + compression_otf_method = 3; + break; + case 'M': // xz: Multi-Threaded + compression_otf_method = 4; + break; +#endif // LZMA_H default: printf("ERROR: Invalid compression method %c\n", argv[i][2]); exit(1); @@ -1157,8 +1178,8 @@ int init_comfort(int argc, char* argv[]) { fprintf(fnewini,";; Precomp Comfort v%i.%i.%i - %s version - INI file\n",V_MAJOR,V_MINOR,V_MINOR2,V_STATE); fprintf(fnewini,";; Use a semicolon (;) for comments\n\n"); fprintf(fnewini,";; Compression method to use\n"); - fprintf(fnewini,";; 0 = none, 1 = bZip2\n"); - fprintf(fnewini,"Compression_Method=1\n\n"); + fprintf(fnewini,";; 0 = none, 1 = bZip2, 2 = lzma, 3 = xz(lzma2), 4 = xz Multi-Threaded\n"); + fprintf(fnewini,"Compression_Method=4\n\n"); fprintf(fnewini,";; Fast mode (on/off)\n"); fprintf(fnewini,"Fast_Mode=off\n\n"); fprintf(fnewini,";; Intense mode (on/off)\n"); @@ -1321,6 +1342,24 @@ int init_comfort(int argc, char* argv[]) { valid_param = true; } + if (strcmp(value, "2") == 0) { + printf("INI: Using lzma compression method\n"); + compression_otf_method = 2; + valid_param = true; + } + + if (strcmp(value, "3") == 0) { + printf("INI: Using xz(lzma2) compression method\n"); + compression_otf_method = 3; + valid_param = true; + } + + if (strcmp(value, "4") == 0) { + printf("INI: Using xz Multi-Threaded compression method\n"); + compression_otf_method = 4; + valid_param = true; + } + if (!valid_param) { printf("ERROR: Invalid compression method value: %s\n", value); wait_for_key(); @@ -5988,6 +6027,60 @@ size_t own_fwrite(const void *ptr, size_t size, size_t count, FILE* stream, int result = size * count; break; } +#ifdef LZMA_H + case 4: // xz_MT + case 2: // lzma + case 3: { // xz + if (size != 1 || count > 512) { + printf("\b\nown_fwrite(xz%i: %i * %i = %i\n-", compression_otf_method, size, count, size * count); + } + lzma_action action = (final_byte == 1) ? LZMA_FINISH : LZMA_RUN; + lzma_ret ret; + unsigned have; + + otf_xz_stream_c.avail_in = size * count; + otf_xz_stream_c.next_in = (uint8_t *)ptr; + do { + print_work_sign(true); + otf_xz_stream_c.avail_out = CHUNK; + otf_xz_stream_c.next_out = (uint8_t *)bz2_out; + ret = lzma_code(&otf_xz_stream_c, action); + have = CHUNK - otf_xz_stream_c.avail_out; + if (fwrite(bz2_out, 1, have, stream) != have || ferror(stream)) { + result = 0; + error(ERR_DISK_FULL); + } + if (ret != LZMA_OK && ret != LZMA_STREAM_END) { + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_DATA_ERROR: + msg = "File size limits exceeded"; + break; + + default: + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "\nERROR: liblzma error: %s (error code %u)\n", msg, ret); +#ifdef COMFORT + ctrl_c_handler(9); + wait_for_key(); +#endif // COMFORT + exit(1); + } // .avail_out == 0 + if (otf_xz_stream_c.avail_in > 0) { + Sleep(110); + } + } while (otf_xz_stream_c.avail_in > 0 || final_byte == 1 && ret != LZMA_STREAM_END); + result = size * count; + break; + } +#endif // LZMA_H } } @@ -6044,6 +6137,12 @@ size_t own_fread(void *ptr, size_t size, size_t count, FILE* stream) { return bytes_read; } + case 4: // xz_MT + case 2: // lzma + case 3: { // xz + printf("\b\nown_fread(xz%i: %i * %i = %i\n-", compression_otf_method, size, count, size * count); + return size * count; + } } } @@ -8426,6 +8525,7 @@ void wait_for_key() { printf("\nPress any key to continue\n"); // wait for key do { + Sleep(55); // lower CPU cost } while (!kbhit()); } #endif @@ -8931,6 +9031,9 @@ void fout_fputc(char c) { fputc(c, fout); break; } + case 4: // xz_MT + case 2: // lzma + case 3: // xz case 1: { // bZip2 unsigned char temp_buf[1]; temp_buf[0] = c; @@ -9002,6 +9105,9 @@ unsigned char fin_fgetc() { return fgetc(fin); break; } + case 4: // xz_MT + case 2: // lzma + case 3: // xz case 1: { // bZip2 unsigned char temp_buf[1]; own_fread(temp_buf, 1, 1, fin); @@ -9027,14 +9133,36 @@ void init_compress_otf() { } break; } +#ifdef LZMA_H + case 2: { // lzma + if (!init_lzma1(&otf_xz_stream_c)) { + printf("ERROR: liblzma1 init failed\n"); + exit(1); + } + break; + } + case 3: { // xz + if (!init_lzma2(&otf_xz_stream_c)) { + printf("ERROR: liblzma2 init failed\n"); + exit(1); + } + break; + } + case 4: { // xz_MT + if (!init_encoder_mt(&otf_xz_stream_c)) { + printf("ERROR: xz Multi-Threaded init failed\n"); + exit(1); + } + break; + } +#endif // LZMA_H } } void denit_compress_otf() { if (comp_decomp_state == P_CONVERT) compression_otf_method = conversion_to_method; - switch (compression_otf_method) { - case 1: { // bZip2 + if (compression_otf_method > 0) { // uncompressed data of length 0 ends bZip2 compress-on-the-fly data char final_buf[9]; @@ -9042,10 +9170,22 @@ void denit_compress_otf() { final_buf[i] = 0; } own_fwrite(final_buf, 1, 9, fout, 1); + } + + switch (compression_otf_method) { + case 1: { // bZip2 (void)BZ2_bzCompressEnd(&otf_bz2_stream_c); break; } +#ifdef LZMA_H + case 4: // xz_MT + case 2: // lzma + case 3: { // xz + (void)lzma_end(&otf_xz_stream_c); + break; + } +#endif // LZMA_H } } @@ -9065,6 +9205,16 @@ void init_decompress_otf() { } break; } +#ifdef LZMA_H + case 4: // xz_MT + case 2: // lzma + case 3: { // xz + if (!init_decoder(&otf_xz_stream_d)) { + printf("ERROR: liblzma init failed\n"); + exit(1); + } + } +#endif // LZMA_H } decompress_otf_end = false; } @@ -9078,6 +9228,15 @@ void denit_decompress_otf() { (void)BZ2_bzDecompressEnd(&otf_bz2_stream_d); break; } +#ifdef LZMA_H + case 4: // xz_MT + case 2: // lzma + case 3: { // xz + + (void)lzma_end(&otf_xz_stream_d); + break; + } +#endif // LZMA_H } } @@ -9152,6 +9311,12 @@ void ctrl_c_handler(int sig) { } } (void) signal(SIGINT, SIG_DFL); +#ifdef LZMA_H + if (compression_otf_method >=2 && compression_otf_method <= 4) { + (void)lzma_end(&otf_xz_stream_c); + (void)lzma_end(&otf_xz_stream_d); + } +#endif // LZMA_H error(ERR_CTRL_C); } \ No newline at end of file diff --git a/vs2012/Precomp/Precomf15.vcxproj b/vs2012/Precomp/Precomf15.vcxproj new file mode 100644 index 0000000..ffe3881 --- /dev/null +++ b/vs2012/Precomp/Precomf15.vcxproj @@ -0,0 +1,273 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + ReleaseMT + Win32 + + + ReleaseMT + x64 + + + Release + Win32 + + + Release + x64 + + + + {04EA71E2-770B-4D2E-905D-2E7AFB98590E} + Win32Proj + Precomf + + + + Application + true + Unicode + v140 + + + Application + true + Unicode + v140 + + + Application + false + true + Unicode + v140 + + + Application + false + true + Unicode + v140 + + + Application + false + true + Unicode + v140 + + + Application + false + true + Unicode + v140 + + + + + + + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + false + + + false + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;BUILD_LIB;COMFORT;%(PreprocessorDefinitions) + + + Console + true + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_CONSOLE;BUILD_LIB;COMFORT;%(PreprocessorDefinitions) + + + Console + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;BUILD_LIB;COMFORT;%(PreprocessorDefinitions) + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + LZMA_API_STATIC;WIN32;NDEBUG;_CONSOLE;BUILD_LIB;COMFORT;%(PreprocessorDefinitions) + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_CONSOLE;BUILD_LIB;COMFORT;%(PreprocessorDefinitions) + MultiThreaded + + + Console + true + true + true + + + + + Level3 + + + MaxSpeed + true + true + LZMA_API_STATIC;WIN32;NDEBUG;_CONSOLE;BUILD_LIB;COMFORT;%(PreprocessorDefinitions) + MultiThreaded + + + Console + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {12728250-16ec-4dc6-94d7-e21dd88947f8} + + + + + + \ No newline at end of file diff --git a/vs2012/Precomp/Precomf15.vcxproj.filters b/vs2012/Precomp/Precomf15.vcxproj.filters new file mode 100644 index 0000000..acacd8c --- /dev/null +++ b/vs2012/Precomp/Precomf15.vcxproj.filters @@ -0,0 +1,174 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {026486a2-caec-45f1-bb06-253064ab62b6} + + + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source\contrib + + + Source + + + Source + + + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + Header + + + \ No newline at end of file diff --git a/vs2012/Precomp/Precomf15_0.sln b/vs2012/Precomp/Precomf15_0.sln new file mode 100644 index 0000000..3087982 --- /dev/null +++ b/vs2012/Precomp/Precomf15_0.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.25302.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Precomf15", "Precomf15.vcxproj", "{04EA71E2-770B-4D2E-905D-2E7AFB98590E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Debug|Win32.ActiveCfg = Debug|Win32 + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Debug|Win32.Build.0 = Debug|Win32 + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Debug|x64.ActiveCfg = Release|x64 + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Debug|x64.Build.0 = Release|x64 + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Release|Win32.ActiveCfg = Release|Win32 + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Release|Win32.Build.0 = Release|Win32 + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Release|x64.ActiveCfg = Release|x64 + {04EA71E2-770B-4D2E-905D-2E7AFB98590E}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/vs2012/Precomp/precomf.vcproj b/vs2012/Precomp/precomf.vcproj index 71e340c..fe608f8 100644 --- a/vs2012/Precomp/precomf.vcproj +++ b/vs2012/Precomp/precomf.vcproj @@ -12,6 +12,9 @@ + @@ -115,7 +118,7 @@ Optimization="2" EnableIntrinsicFunctions="true" PreprocessorDefinitions="BUILD_LIB;COMFORT;WIN32;NDEBUG;_CONSOLE" - RuntimeLibrary="2" + RuntimeLibrary="0" EnableFunctionLevelLinking="true" UsePrecompiledHeader="0" WarningLevel="3" @@ -133,6 +136,7 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -293,10 +445,6 @@ RelativePath="..\..\contrib\liblzma\compress_easy_mt.cpp" > - - + + + + + +