int lzma_compress_size( const unsigned char* data, unsigned size ){
//Initialize LZMA
lzma_stream strm = LZMA_STREAM_INIT;
if( lzma_easy_encoder( &strm, 9 | LZMA_PRESET_EXTREME, LZMA_CHECK_CRC64 ) != LZMA_OK )
return {};
std::vector<uint8_t> out( size*2 ); //TODO: Find value properly
//Setup in/out buffers
strm.next_in = (uint8_t*)data;
strm.avail_in = size;
strm.next_out = out.data();
strm.avail_out = out.size();
//Compress
lzma_ret ret = lzma_code( &strm, LZMA_FINISH );
if( ret != LZMA_STREAM_END ){
lzma_end( &strm ); //TODO: Use RAII
return {};
}
lzma_end( &strm );
//Return only the range actually needed
//return out.left( out.size() - strm.avail_out );
return out.size() - strm.avail_out;
}
/* lzma_close flushes the stream pointed to by the lzmafile pointer
and closes the underlying file descriptor. Upon successful
completion 0 is returned. On error, EOF is returned. */
int lzma_close(struct lzmafile* file)
{
int ret, outsize;
unsigned char buf[BUF_SIZE]; /* buffer used when flushing remaining
output data in write mode */
if (!file) return -1;
if (file->mode == 'w') {
/* flush LZMA output buffer */
for (;;) {
file->str.next_out = buf;
file->str.avail_out = BUF_SIZE;
ret = lzma_code(&file->str, LZMA_FINISH);
if (ret != LZMA_STREAM_END && ret != LZMA_OK) {
fprintf(stderr,"lzma_close error: encoding failed: %d\n",ret);
lzma_end(&file->str);
fclose(file->fp);
free(file);
return EOF;
}
outsize = BUF_SIZE - file->str.avail_out;
if (fwrite(buf, 1, outsize, file->fp) != outsize) {
lzma_end(&file->str);
fclose(file->fp);
free(file);
return EOF;
}
if (ret == LZMA_STREAM_END) break;
}
}
lzma_end(&file->str);
ret = fclose(file->fp);
free(file);
return ret;
}
static int lzclose(void *cookie)
{
LZFILE *lzfile = cookie;
lzma_ret ret;
size_t n;
int rc;
if (!lzfile)
return -1;
if (lzfile->encoding)
{
for (;;)
{
lzfile->strm.avail_out = sizeof(lzfile->buf);
lzfile->strm.next_out = lzfile->buf;
ret = lzma_code(&lzfile->strm, LZMA_FINISH);
if (ret != LZMA_OK && ret != LZMA_STREAM_END)
return -1;
n = sizeof(lzfile->buf) - lzfile->strm.avail_out;
if (n && fwrite(lzfile->buf, 1, n, lzfile->file) != n)
return -1;
if (ret == LZMA_STREAM_END)
break;
}
}
lzma_end(&lzfile->strm);
rc = fclose(lzfile->file);
free(lzfile);
return rc;
}
extern void io_release(IO_HANDLE ptr)
{
io_private_t *io_ptr = ptr;
if (!io_ptr)
return (errno = EBADF , (void)NULL);
if (io_ptr->buffer_crypt)
{
if (io_ptr->buffer_crypt->stream)
gcry_free(io_ptr->buffer_crypt->stream);
gcry_free(io_ptr->buffer_crypt);
}
if (io_ptr->buffer_ecc)
{
if (io_ptr->buffer_ecc->stream)
free(io_ptr->buffer_ecc->stream);
free(io_ptr->buffer_ecc);
}
if (io_ptr->cipher_init)
gcry_cipher_close(io_ptr->cipher_handle);
if (io_ptr->hash_init)
gcry_md_close(io_ptr->hash_handle);
if (io_ptr->lzma_init)
lzma_end(&io_ptr->lzma_handle);
gcry_free(io_ptr);
io_ptr = NULL;
return;
}
lzma_vli read_file_index(lzma_vli offset) {
void *bdata = NULL;
if (!offset)
offset = find_file_index(&bdata);
if (!offset)
return 0;
while (true) {
char *name = read_file_index_name();
if (!name)
break;
file_index_t *f = malloc(sizeof(file_index_t));
f->name = strlen(name) ? xstrdup(name) : NULL;
f->offset = xle64dec(gFileIndexBuf + gFIBPos);
gFIBPos += sizeof(uint64_t);
if (gLastFile) {
gLastFile->next = f;
} else {
gFileIndex = f;
}
gLastFile = f;
}
free(gFileIndexBuf);
lzma_end(&gStream);
free(bdata);
return offset;
}
int xz_enc_exit(lzma_stream *str, FILE *fp_out)
{
int ret;
ret = xz_enc_write(str, NULL, 0, fp_out);
lzma_end(str);
return ret;
}
static int xzclose(/*@only@*/ XZFILE *xzfile)
/*@globals fileSystem @*/
/*@modifies *xzfile, fileSystem @*/
{
lzma_ret ret;
size_t n;
int rc;
if (!xzfile)
return -1;
if (xzfile->encoding) {
for (;;) {
xzfile->strm.avail_out = kBufferSize;
xzfile->strm.next_out = (uint8_t *)xzfile->buf;
ret = lzma_code(&xzfile->strm, LZMA_FINISH);
if (ret != LZMA_OK && ret != LZMA_STREAM_END)
return -1;
n = kBufferSize - xzfile->strm.avail_out;
if (n && fwrite(xzfile->buf, 1, n, xzfile->fp) != n)
return -1;
if (ret == LZMA_STREAM_END)
break;
}
}
lzma_end(&xzfile->strm);
rc = fclose(xzfile->fp);
memset(xzfile, 0, sizeof(*xzfile));
free(xzfile);
return rc;
}
static void lzma_close(io_t *io)
{
lzma_end(&DATA(io)->strm);
wandio_destroy(DATA(io)->parent);
free(io->data);
free(io);
}
void code(lzma_stream &stream, std::istream &in, std::ostream &out)
{
std::vector<char> inbuf(chunksize, 0), outbuf(chunksize, 0);
while (true)
{
stream.next_in = reinterpret_cast<uint8_t *>(&inbuf[0]);
in.read(&inbuf[0], inbuf.size());
std::streamsize insize = in.gcount();
stream.avail_in = insize;
stream.total_in = 0;
do
{
stream.total_out = 0;
stream.next_out = reinterpret_cast<uint8_t *>(&outbuf[0]);
stream.avail_out = outbuf.size();
lzma_ret retval = lzma_code(&stream, insize == 0 ? LZMA_FINISH : LZMA_RUN);
if (retval == LZMA_STREAM_END)
{
if (stream.avail_in != 0) throw compress_error{"Unprocessed input remaining in stream"};
out.write(&outbuf[0], stream.total_out);
lzma_end(&stream);
return;
}
if (retval != LZMA_OK) throw compress_error{"Stream encoding failed"};
//std::cout << "Retrieved " << stream.total_in << " bytes and output " << stream.total_out << " bytes\n";
out.write(&outbuf[0], stream.total_out);
}
while (stream.total_out > 0);
}
}
static int xz_close(struct zstream *z)
{
int rc = close(z->xz.fd);
z->xz.fd = -1;
lzma_end(&z->xz.stream);
return rc;
}
/*
* Finish the compression...
*/
static int
archive_compressor_xz_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret, r1;
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
data->total_out +=
data->compressed_buffer_size - data->stream.avail_out;
ret = __archive_write_filter(f->next_filter,
data->compressed,
data->compressed_buffer_size - data->stream.avail_out);
if (f->code == ARCHIVE_FILTER_LZIP && ret == ARCHIVE_OK) {
archive_le32enc(data->compressed, data->crc32);
archive_le64enc(data->compressed+4, data->total_in);
archive_le64enc(data->compressed+12, data->total_out + 20);
ret = __archive_write_filter(f->next_filter,
data->compressed, 20);
}
}
lzma_end(&(data->stream));
r1 = __archive_write_close_filter(f->next_filter);
return (r1 < ret ? r1 : ret);
}
LzmaConnectorWriter::~LzmaConnectorWriter (void)
{
lzma_end (&_lzmaCompStream);
if (_pOutputBuffer) {
delete[] _pOutputBuffer;
}
_pOutputBuffer = NULL;
}
GSDumpLzma::~GSDumpLzma() {
lzma_end(&m_strm);
if (m_inbuf)
_aligned_free(m_inbuf);
if (m_area)
_aligned_free(m_area);
}
void lzma_decompressor_impl_base::close() {
if(stream) {
lzma_stream * strm = static_cast<lzma_stream *>(stream);
lzma_end(strm);
delete strm, stream = NULL;
}
}
void lzma_base::reset( bool compress, bool realloc )
{
lzma_stream *s = static_cast<lzma_stream *>( stream_ );
if ( realloc )
lzma_error::check( lzma_code( s, lzma::full_flush ) );
else
lzma_end( s );
}
static void MojoInput_xz_close(MojoInput *io)
{
XZinfo *info = (XZinfo *) io->opaque;
if (info->origio != NULL)
info->origio->close(info->origio);
lzma_end(&info->stream);
free(info);
free(io);
} // MojoInput_xz_close
static void o_stream_lzma_close(struct iostream_private *stream,
bool close_parent)
{
struct lzma_ostream *zstream = (struct lzma_ostream *)stream;
lzma_end(&zstream->strm);
if (close_parent)
o_stream_close(zstream->ostream.parent);
}
static void
Compressor_dealloc(Compressor *self)
{
lzma_end(&self->lzs);
#ifdef WITH_THREAD
if (self->lock != NULL)
PyThread_free_lock(self->lock);
#endif
Py_TYPE(self)->tp_free((PyObject *)self);
}
void CTarArcFile_Lzma::close()
{
if(m_opened){
// 残ったバッファの分を処理する
m_action = LZMA_FINISH;
coder(NULL,0);
lzma_end(&m_strm);
m_demand_callback(this,NULL,0,DEMAND_CLOSE,m_callback_arg);
m_opened=false;
}
}
/*
* Clean up the decompressor.
*/
static int
xz_filter_close(struct archive_read_filter *self)
{
struct private_data *state;
state = (struct private_data *)self->data;
lzma_end(&(state->stream));
free(state->out_block);
free(state);
return (ARCHIVE_OK);
}
static void i_stream_lzma_close(struct iostream_private *stream,
bool close_parent)
{
struct lzma_istream *zstream = (struct lzma_istream *)stream;
if (!zstream->strm_closed) {
lzma_end(&zstream->strm);
zstream->strm_closed = TRUE;
}
if (close_parent)
i_stream_close(zstream->istream.parent);
}
int LzmaConnectorReader::resetConnectorReader (void)
{
lzma_end (&_lzmaDecompStream);
resetDecompStream();
if (LZMA_OK != lzma_stream_decoder (&_lzmaDecompStream, lzma_easy_decoder_memusage (getCompressionLevel()), DECODER_FLAGS)) {
return -1;
}
return 0;
}
LzmaConnectorReader::~LzmaConnectorReader (void)
{
lzma_end (&_lzmaDecompStream);
if (_pOutputBuffer) {
delete[] _pOutputBuffer;
}
_pOutputBuffer = nullptr;
if (_pInputBuffer) {
delete[] _pInputBuffer;
}
_pInputBuffer = nullptr;
}
static unsigned char *
lzma_decode_buffer(struct stream_encoded *st, unsigned char *data, int len, int *new_len)
{
struct lzma_enc_data *enc_data = (struct lzma_enc_data *) st->data;
lzma_stream *stream = &enc_data->flzma_stream;
unsigned char *buffer = NULL;
int error;
*new_len = 0; /* default, left there if an error occurs */
stream->next_in = data;
stream->avail_in = len;
stream->total_out = 0;
if (lzma_auto_decoder(stream, ELINKS_LZMA_MEMORY_LIMIT, 0) != LZMA_OK)
return NULL;
do {
unsigned char *new_buffer;
size_t size = stream->total_out + MAX_STR_LEN;
new_buffer = mem_realloc(buffer, size);
if (!new_buffer) {
error = LZMA_MEM_ERROR;
break;
}
buffer = new_buffer;
stream->next_out = buffer + stream->total_out;
stream->avail_out = MAX_STR_LEN;
error = lzma_code(stream, LZMA_RUN);
if (error == LZMA_STREAM_END) {
error = LZMA_OK;
break;
}
} while (error == LZMA_OK && stream->avail_in > 0);
if (error == LZMA_STREAM_END) {
lzma_end(stream);
enc_data->after_end = 1;
error = LZMA_OK;
}
if (error == LZMA_OK) {
*new_len = stream->total_out;
return buffer;
} else {
if (buffer) mem_free(buffer);
return NULL;
}
}
static int
LZMASetupEncode(TIFF* tif)
{
LZMAState* sp = EncoderState(tif);
assert(sp != NULL);
if (sp->state & LSTATE_INIT_DECODE) {
lzma_end(&sp->stream);
sp->state = 0;
}
sp->state |= LSTATE_INIT_ENCODE;
return 1;
}
bool loadBlock(std::string &error) {
clearFilters();
position = -1;
//LOG_VERBOSE("seeking to offset %i", (int) iter->block.compressed_file_offset);
reader.seek(iter.block.compressed_file_offset);
strm.avail_in = 0; /* make sure we read new data after lseek */
if (!fill_input_buffer(error)) return false;
if (0 == strm.avail_in) {
error.assign("Unexpected end of file while trying to read block header");
return false;
}
block.version = 0;
block.check = iter.stream.flags->check;
block.header_size = lzma_block_header_size_decode(strm.next_in[0]);
if (block.header_size > strm.avail_in) {
error.assign("Unexpected end of file while trying to read block header");
return false;
}
// Decode the Block Header.
lzma_ret ret = lzma_block_header_decode(&block, NULL, strm.next_in);
if (LZMA_OK != ret) {
errnoLzmaToStr("decoding block header failed", ret, error);
return false;
}
ret = lzma_block_compressed_size(&block, iter.block.unpadded_size);
if (LZMA_OK != ret) {
errnoLzmaToStr("decoding block header failed, invalid compressed size", ret, error);
return false;
}
strm.next_in += block.header_size;
strm.avail_in -= block.header_size;
lzma_end(&strm);
ret = lzma_block_decoder(&strm, &block);
if (LZMA_OK != ret) {
errnoLzmaToStr("couldn't initialize block decoder", ret, error);
return false;
}
position = iter.block.uncompressed_file_offset;
return true;
}
static int
LZMASetupDecode(TIFF* tif)
{
LZMAState* sp = DecoderState(tif);
assert(sp != NULL);
/* if we were last encoding, terminate this mode */
if (sp->state & LSTATE_INIT_ENCODE) {
lzma_end(&sp->stream);
sp->state = 0;
}
sp->state |= LSTATE_INIT_DECODE;
return 1;
}
static void
lzma_close(struct stream_encoded *stream)
{
struct lzma_enc_data *data = (struct lzma_enc_data *) stream->data;
if (data) {
if (!data->after_end) {
lzma_end(&data->flzma_stream);
}
if (data->fdread != -1) {
close(data->fdread);
}
mem_free(data);
stream->data = 0;
}
}
static void i_stream_lzma_reset(struct lzma_istream *zstream)
{
struct istream_private *stream = &zstream->istream;
i_stream_seek(stream->parent, stream->parent_start_offset);
zstream->eof_offset = (uoff_t)-1;
zstream->strm.next_in = NULL;
zstream->strm.avail_in = 0;
stream->parent_expected_offset = stream->parent_start_offset;
stream->skip = stream->pos = 0;
stream->istream.v_offset = 0;
zstream->high_pos = 0;
lzma_end(&zstream->strm);
i_stream_lzma_init(zstream);
}
static readstat_error_t reset_stream(rdata_ctx_t *ctx) {
if (ctx->z_strm) {
inflateEnd(ctx->z_strm);
free(ctx->z_strm);
ctx->z_strm = NULL;
}
#ifdef HAVE_LZMA
if (ctx->lzma_strm) {
lzma_end(ctx->lzma_strm);
free(ctx->lzma_strm);
ctx->lzma_strm = NULL;
}
#endif
lseek(ctx->fd, 0, SEEK_SET);
return init_stream(ctx);
}
