static int LZMAVSetField(TIFF* tif, uint32 tag, va_list ap) { static const char module[] = "LZMAVSetField"; LZMAState* sp = LState(tif); switch (tag) { case TIFFTAG_LZMAPRESET: sp->preset = (int) va_arg(ap, int); lzma_lzma_preset(&sp->opt_lzma, sp->preset); if (sp->state & LSTATE_INIT_ENCODE) { lzma_ret ret = lzma_stream_encoder(&sp->stream, sp->filters, sp->check); if (ret != LZMA_OK) { TIFFErrorExt(tif->tif_clientdata, module, "Liblzma error: %s", LZMAStrerror(ret)); } } return 1; default: return (*sp->vsetparent)(tif, tag, ap); } /*NOTREACHED*/ }
static int archive_compressor_xz_init_stream(struct archive_write *a, struct private_data *state) { int ret; state->stream = (lzma_stream)LZMA_STREAM_INIT; state->stream.next_out = state->compressed; state->stream.avail_out = state->compressed_buffer_size; if (a->archive.compression_code == ARCHIVE_COMPRESSION_XZ) ret = lzma_stream_encoder(&(state->stream), state->lzmafilters, LZMA_CHECK_CRC64); else ret = lzma_alone_encoder(&(state->stream), &state->lzma_opt); if (ret == LZMA_OK) return (ARCHIVE_OK); switch (ret) { case LZMA_MEM_ERROR: archive_set_error(&a->archive, ENOMEM, "Internal error initializing compression library: " "Cannot allocate memory"); break; default: archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Internal error initializing compression library: " "It's a bug in liblzma"); break; } return (ARCHIVE_FATAL); }
lzma_easy_encoder(lzma_stream *strm, uint32_t preset, lzma_check check) { lzma_options_easy opt_easy; if (lzma_easy_preset(&opt_easy, preset)) return LZMA_OPTIONS_ERROR; return lzma_stream_encoder(strm, opt_easy.filters, check); }
static void io_do_compress(io_private_t *io_ptr) { lzma_stream l = LZMA_STREAM_INIT; io_ptr->lzma_handle = l; lzma_filter lzf[2]; lzma_options_lzma lzo; lzma_lzma_preset(&lzo, LZMA_PRESET_DEFAULT); lzf[0].id = LZMA_FILTER_LZMA2; lzf[0].options = &lzo; lzf[1].id = LZMA_VLI_UNKNOWN; if (lzma_stream_encoder(&io_ptr->lzma_handle, lzf, LZMA_CHECK_NONE) != LZMA_OK) return; io_ptr->lzma_init = true; return; }
/* * Reset encoding state at the start of a strip. */ static int LZMAPreEncode(TIFF* tif, uint16 s) { static const char module[] = "LZMAPreEncode"; LZMAState *sp = EncoderState(tif); (void) s; assert(sp != NULL); if( sp->state != LSTATE_INIT_ENCODE ) tif->tif_setupencode(tif); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = (size_t)tif->tif_rawdatasize; if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) { TIFFErrorExt(tif->tif_clientdata, module, "Liblzma cannot deal with buffers this size"); return 0; } return (lzma_stream_encoder(&sp->stream, sp->filters, sp->check) == LZMA_OK); }
static int Compressor_init_xz(lzma_stream *lzs, int check, uint32_t preset, PyObject *filterspecs) { lzma_ret lzret; if (filterspecs == Py_None) { lzret = lzma_easy_encoder(lzs, preset, check); } else { lzma_filter filters[LZMA_FILTERS_MAX + 1]; if (parse_filter_chain_spec(filters, filterspecs) == -1) return -1; lzret = lzma_stream_encoder(lzs, filters, check); free_filter_chain(filters); } if (catch_lzma_error(lzret)) return -1; else return 0; }
struct mkuz_blk * mkuz_lzma_compress(void *p, const struct mkuz_blk *iblk) { lzma_ret ret; struct mkuz_blk *rval; struct mkuz_lzma *ulp; ulp = (struct mkuz_lzma *)p; rval = mkuz_blk_ctor(ulp->blksz * 2); ret = lzma_stream_encoder(&ulp->strm, ulp->filters, LZMA_CHECK_CRC32); if (ret != LZMA_OK) { if (ret == LZMA_MEMLIMIT_ERROR) errx(1, "can't compress data: LZMA_MEMLIMIT_ERROR"); errx(1, "can't compress data: LZMA compressor ERROR"); } ulp->strm.next_in = iblk->data; ulp->strm.avail_in = ulp->blksz; ulp->strm.next_out = rval->data; ulp->strm.avail_out = rval->alen; ret = lzma_code(&ulp->strm, LZMA_FINISH); if (ret != LZMA_STREAM_END) { /* Error */ errx(1, "lzma_code FINISH failed, code=%d, pos(in=%zd, " "out=%zd)", ret, (ulp->blksz - ulp->strm.avail_in), (ulp->blksz * 2 - ulp->strm.avail_out)); } #if 0 lzma_end(&ulp->strm); #endif rval->info.len = rval->alen - ulp->strm.avail_out; return (rval); }
static int archive_compressor_xz_init_stream(struct archive_write_filter *f, struct private_data *data) { static const lzma_stream lzma_stream_init_data = LZMA_STREAM_INIT; int ret; data->stream = lzma_stream_init_data; data->stream.next_out = data->compressed; data->stream.avail_out = data->compressed_buffer_size; if (f->code == ARCHIVE_FILTER_XZ) ret = lzma_stream_encoder(&(data->stream), data->lzmafilters, LZMA_CHECK_CRC64); else if (f->code == ARCHIVE_FILTER_LZMA) ret = lzma_alone_encoder(&(data->stream), &data->lzma_opt); else { /* ARCHIVE_FILTER_LZIP */ int dict_size = data->lzma_opt.dict_size; int ds, log2dic, wedges; /* Calculate a coded dictionary size */ if (dict_size < (1 << 12) || dict_size > (1 << 27)) { archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, "Unacceptable dictionary dize for lzip: %d", dict_size); return (ARCHIVE_FATAL); } for (log2dic = 27; log2dic >= 12; log2dic--) { if (dict_size & (1 << log2dic)) break; } if (dict_size > (1 << log2dic)) { log2dic++; wedges = ((1 << log2dic) - dict_size) / (1 << (log2dic - 4)); } else wedges = 0; ds = ((wedges << 5) & 0xe0) | (log2dic & 0x1f); data->crc32 = 0; /* Make a header */ data->compressed[0] = 0x4C; data->compressed[1] = 0x5A; data->compressed[2] = 0x49; data->compressed[3] = 0x50; data->compressed[4] = 1;/* Version */ data->compressed[5] = (unsigned char)ds; data->stream.next_out += 6; data->stream.avail_out -= 6; ret = lzma_raw_encoder(&(data->stream), data->lzmafilters); } if (ret == LZMA_OK) return (ARCHIVE_OK); switch (ret) { case LZMA_MEM_ERROR: archive_set_error(f->archive, ENOMEM, "Internal error initializing compression library: " "Cannot allocate memory"); break; default: archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, "Internal error initializing compression library: " "It's a bug in liblzma"); break; } return (ARCHIVE_FATAL); }
int main( int argc, char **argv ) { int i; uint64_t p, threads, chunk_size; uint8_t *m; struct stat s; ssize_t rd, ts = 0; size_t page_size; struct sigaction new_action, old_action; struct utimbuf u; lzma_filter filters[LZMA_FILTERS_MAX + 1]; lzma_options_lzma lzma_options; xzcmd_max = sysconf(_SC_ARG_MAX); page_size = sysconf(_SC_PAGE_SIZE); xzcmd = malloc(xzcmd_max); snprintf(xzcmd, xzcmd_max, XZ_BINARY); parse_args(argc, argv); lzma_lzma_preset(&lzma_options, opt_complevel); filters[0].id = LZMA_FILTER_LZMA2; filters[0].options = &lzma_options; filters[1].id = LZMA_VLI_UNKNOWN; for (i=0; i<files; i++) { int std_in = file[i][0] == '-' && file[i][1] == '\0'; #ifdef _OPENMP threads = omp_get_max_threads(); #else threads = 1; #endif if ( (rd=strlen(file[i])) >= 3 && !strncmp(&file[i][rd-3], ".xz", 3) ) { if (opt_verbose) { error(EXIT_FAILURE, 0, "ignoring '%s', it seems to be already compressed", file[i]); } continue; } if ( !std_in ) { if ( stat(file[i], &s)) { error(EXIT_FAILURE, errno, "can't stat '%s'", file[i]); } } chunk_size = opt_context_size * lzma_options.dict_size; chunk_size = (chunk_size + page_size)&~(page_size-1); if ( opt_verbose ) { fprintf(stderr, "context size per thread: %"PRIu64" B\n", chunk_size); } if ( opt_threads && (threads > opt_threads || opt_force) ) { threads = opt_threads; } fo = stdout; if ( std_in ) { fi = stdin; } else { if ( !(fi=fopen(file[i], "rb")) ) { error(EXIT_FAILURE, errno, "can't open '%s' for reading", file[i]); } if ( !opt_stdout ) { snprintf(str, sizeof(str), "%s.xz", file[i]); if ( !(fo=fopen(str, "wb")) ) { error(EXIT_FAILURE, errno, "error creating target archive '%s'", str); } } } if ( opt_verbose ) { if ( fo != stdout ) { fprintf(stderr, "%s -> %"PRIu64"/%"PRIu64" thread%c: [", file[i], threads, (s.st_size+chunk_size-1)/chunk_size, threads != 1 ? 's' : ' '); } else { fprintf(stderr, "%"PRIu64" thread%c: [", threads, threads != 1 ? 's' : ' '); } fflush(stderr); } m = malloc(threads*chunk_size); new_action.sa_handler = term_handler; sigemptyset (&new_action.sa_mask); new_action.sa_flags = 0; sigaction(SIGINT, NULL, &old_action); if (old_action.sa_handler != SIG_IGN) sigaction(SIGINT, &new_action, NULL); sigaction(SIGHUP, NULL, &old_action); if (old_action.sa_handler != SIG_IGN) sigaction(SIGHUP, &new_action, NULL); sigaction(SIGTERM, NULL, &old_action); if (old_action.sa_handler != SIG_IGN) sigaction(SIGTERM, &new_action, NULL); ftemp = malloc(threads*sizeof(ftemp[0])); while ( !feof(fi) ) { size_t actrd; for (p=0; p<threads; p++) { ftemp[p] = tmpfile(); } for ( actrd=rd=0; !feof(fi) && !ferror(fi) && (uint64_t)rd < threads*chunk_size; rd += actrd) { actrd = fread(&m[rd], 1, threads*chunk_size-actrd, fi); } if (ferror(fi)) { error(EXIT_FAILURE, errno, "error in reading input"); } #pragma omp parallel for private(p) num_threads(threads) for ( p=0; p<(rd+chunk_size-1)/chunk_size; p++ ) { off_t pt, len = rd-p*chunk_size >= chunk_size ? chunk_size : rd-p*chunk_size; uint8_t *mo; lzma_stream strm = LZMA_STREAM_INIT; lzma_ret ret; mo = malloc(BUFFSIZE); if ( lzma_stream_encoder(&strm, filters, LZMA_CHECK_CRC64) != LZMA_OK ) { error(EXIT_FAILURE, errno, "unable to initialize LZMA encoder"); } for (pt=0; pt<len; pt+=BUFFSIZE) { strm.next_in = &m[p*chunk_size+pt]; strm.avail_in = len-pt >= BUFFSIZE ? BUFFSIZE : len-pt; strm.next_out = mo; strm.avail_out = BUFFSIZE; do { ret = lzma_code(&strm, LZMA_RUN); if ( ret != LZMA_OK ) { error(EXIT_FAILURE, 0, "error in LZMA_RUN"); } if ( BUFFSIZE - strm.avail_out > 0 ) { if ( !fwrite(mo, 1, BUFFSIZE - strm.avail_out, ftemp[p]) ) { error(EXIT_FAILURE, errno, "writing to temp file failed"); } strm.next_out = mo; strm.avail_out = BUFFSIZE; } } while ( strm.avail_in ); } strm.next_out = mo; strm.avail_out = BUFFSIZE; do { ret = lzma_code(&strm, LZMA_FINISH); if ( ret != LZMA_OK && ret != LZMA_STREAM_END ) { error(EXIT_FAILURE, 0, "error in LZMA_FINISH"); } if ( BUFFSIZE - strm.avail_out > 0 ) { if ( !fwrite(mo, 1, BUFFSIZE - strm.avail_out, ftemp[p]) ) { error(EXIT_FAILURE, errno, "writing to temp file failed"); } strm.next_out = mo; strm.avail_out = BUFFSIZE; } } while ( ret == LZMA_OK ); lzma_end(&strm); free(mo); if ( opt_verbose ) { fprintf(stderr, "%"PRIu64" ", p); fflush(stderr); } } for ( p=0; p<threads; p++ ) { rewind(ftemp[p]); while ( (rd=fread(buf, 1, sizeof(buf), ftemp[p])) > 0 ) { if ( fwrite(buf, 1, rd, fo) != (size_t)rd ) { error(0, errno, "writing to archive failed"); if ( fo != stdout && unlink(str) ) { error(0, errno, "error deleting corrupted target archive %s", str); } exit(EXIT_FAILURE); } else ts += rd; } if (rd < 0) { error(0, errno, "reading from temporary file failed"); if ( fo != stdout && unlink(str) ) { error(0, errno, "error deleting corrupted target archive %s", str); } exit(EXIT_FAILURE); } if ( close_stream(ftemp[p]) ) { error(0, errno, "I/O error in temp file"); } } } if ( fi != stdin && close_stream(fi) ) { error(0, errno, "I/O error in input file"); } if ( opt_verbose ) { fprintf(stderr, "] "); } free(ftemp); if ( fo != stdout ) { if ( close_stream(fo) ) { error(0, errno, "I/O error in target archive"); } } else return 0; if ( chmod(str, s.st_mode) ) { error(0, errno, "warning: unable to change archive permissions"); } u.actime = s.st_atime; u.modtime = s.st_mtime; if ( utime(str, &u) ) { error(0, errno, "warning: unable to change archive timestamp"); } sigaction(SIGINT, &old_action, NULL); sigaction(SIGHUP, &old_action, NULL); sigaction(SIGTERM, &old_action, NULL); if ( opt_verbose ) { fprintf(stderr, "%"PRIu64" -> %zd %3.3f%%\n", s.st_size, ts, ts*100./s.st_size); } if ( !opt_keep && unlink(file[i]) ) { error(0, errno, "error deleting input file %s", file[i]); } } return 0; }
} static int php_xz_init_encoder(struct php_xz_stream_data_t *self) { lzma_stream *strm = &self->strm; lzma_options_lzma opt_lzma2; if (lzma_lzma_preset(&opt_lzma2, LZMA_PRESET_DEFAULT)) { return 0; } lzma_filter filters[] = { { .id = LZMA_FILTER_LZMA2, .options = &opt_lzma2 }, { .id = LZMA_VLI_UNKNOWN, .options = NULL }, }; lzma_ret ret = lzma_stream_encoder(strm, filters, LZMA_CHECK_CRC64); if (ret == LZMA_OK) { self->in_buf_sz = XZ_INBUF_SIZE; self->out_buf_sz = XZ_OUTBUF_SIZE; self->in_buf = emalloc(self->in_buf_sz); self->out_buf = emalloc(self->out_buf_sz); strm->avail_in = 0; strm->next_in = self->in_buf; strm->avail_out = self->out_buf_sz; strm->next_out = self->out_buf; return 1; } /*const char *msg; switch (ret) {