// lzo 算法 static void lzo(pbuf_t *pbuf) { uint8_t wrkmem[LZO1X_1_MEM_COMPRESS]; uint8_t out[2048+2048/16+64+3]; lzo_uint olen; lzo1x_1_compress(pbuf->payload, pbuf->len, out, &olen, wrkmem); if (olen < pbuf->len) { memcpy(pbuf->payload, out, olen); pbuf->flag |= 0x04; pbuf->len = olen; } }
static void lzo_compress_chunk(void *fptr) { int r; struct lzo_data *ld = fptr; r = lzo1x_1_compress(ld->in, ld->in_len, ld->out, &ld->out_len, ld->wrkmem); if (r != LZO_E_OK) bail("LZF internal compression error: %d", r); ld->bytesout += ld->out_len; ld->in_len = 0; }
int KScriptClient::Call(Lua_State* L) { int nRetCode = 0; int nParamCount = 0; const char* pszFunction = NULL; BYTE* pbyOffset = m_byOriginalBuffer; BYTE* pbyTail = m_byOriginalBuffer + sizeof(m_byOriginalBuffer); size_t uSrcLen = 0; size_t uDstLen = 0; nParamCount = Lua_GetTopIndex(L); KGLOG_PROCESS_ERROR(nParamCount >= 1); pszFunction = Lua_ValueToString(L, 1); KGLOG_PROCESS_ERROR(pszFunction); for (int i = 2; i <= nParamCount; i++) { pbyOffset = LuaPackup(L, i, pbyOffset, (size_t)(pbyTail - pbyOffset)); KGLOG_PROCESS_ERROR(pbyOffset); } uSrcLen = (size_t)(pbyOffset - m_byOriginalBuffer); nRetCode = lzo1x_1_compress(m_byOriginalBuffer, (lzo_uint)uSrcLen, m_byCompressBuffer, (lzo_uint*)&uDstLen, m_LzoWorkBuffer); KGLOG_PROCESS_ERROR(nRetCode == LZO_E_OK); g_PlayerClient.DoRemoteLuaCall(pszFunction, m_byCompressBuffer, uDstLen); Exit0: return 0; }
static int algo_lzo_compress(const unsigned char *in, size_t in_size, unsigned char *out, size_t *out_size, void *data) { int ret; ret = lzo1x_1_compress(in, in_size, out, out_size, data); return ret == LZO_E_OK ? 0 : ret; }
static bool compress_with_lzo(JCR *jcr, char *rbuf, uint32_t rsize, unsigned char *cbuf, uint32_t max_compress_len, uint32_t *compress_len) { int lzores; lzo_uint len = 0; Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, rsize); lzores = lzo1x_1_compress((const unsigned char *)rbuf, rsize, cbuf, &len, jcr->compress.workset.pLZO); *compress_len = len; if (lzores != LZO_E_OK || *compress_len > max_compress_len) { /* * This should NEVER happen */ Jmsg(jcr, M_FATAL, 0, _("Compression LZO error: %d\n"), lzores); jcr->setJobStatus(JS_ErrorTerminated); return false; } Dmsg2(400, "LZO compressed len=%d uncompressed len=%d\n", *compress_len, rsize); return true; }
JNIEXPORT jint JNICALL Java_com_dynatrace_diagnostics_sdk_io_LZOCompression_dynMemCompress (JNIEnv *env, jclass, jbyteArray src, jint offset, jint srcLen, jbyteArray dest){ lzo_uint destLen=0; jbyte *srcBuf = (jbyte*)malloc(srcLen*sizeof(jbyte)); if (srcBuf==NULL) return -1; env->GetByteArrayRegion(src, offset, srcLen, srcBuf); if (env->ExceptionOccurred()) { return -1; } int maxDestLen = srcLen + srcLen / 16 + 64 +3; jbyte *destBuf = (jbyte*)malloc(maxDestLen*sizeof(jbyte)); if (destBuf==NULL) return -1; int result = lzo1x_1_compress((unsigned char*)srcBuf,srcLen, (unsigned char*)destBuf, &destLen, wrkmem); if (result!=LZO_E_OK) { free(srcBuf); free(destBuf); return -1; } env->SetByteArrayRegion(dest, 0, (jsize)destLen, destBuf); if (env->ExceptionOccurred()) { return -1; } free(srcBuf); free(destBuf); return (jsize)destLen; }
rt_private void parsing_compiler_write(size_t size) { RT_GET_CONTEXT char* cmps_out_ptr = cmps_general_buffer; lzo_uint cmps_out_size = (lzo_uint) cmp_buffer_size; int signed_cmps_out_size; int number_written; REQUIRE("cmp_buffer_size not too big", cmp_buffer_size <= 0x7FFFFFFF); REQUIRE("size not too big", size <= 0x7FFFFFFF); lzo1x_1_compress ( (unsigned char *) general_buffer, /* Current buffer location */ (lzo_uint) size, /* Current buffer size */ (unsigned char *) cmps_out_ptr, /* Output buffer for compressed data */ &cmps_out_size, /* Size of output buffer and then size of compressed data */ wrkmem); /* Memory allocator */ signed_cmps_out_size = (int) cmps_out_size; /* Write size of compressed data */ if (write (file_descriptor, (char *) &signed_cmps_out_size, sizeof(int)) <= 0) eraise ("Unable to write compressed data size", EN_IO); /* Write compressed data */ while (signed_cmps_out_size > 0) { number_written = write (file_descriptor, cmps_out_ptr, signed_cmps_out_size); if (number_written <= 0) eio(); signed_cmps_out_size -= number_written; cmps_out_ptr += number_written; } }
int main(int argc, char *argv[]) { FILE *f = fopen(argv[1], "rb"); if (!f) { return 0; } fseek(f, 0, SEEK_END); long file_size = ftell(f); fseek(f, 0, SEEK_SET); if (file_size >= 0x100000000) file_size = 0xFFFFFFFF; void* inpbuffer = malloc((size_t) file_size); void* outbuffer = malloc((size_t) file_size); fread(inpbuffer, 1, (size_t) file_size, f); lzo_uint compressed_size = file_size; void* wrkmem = malloc(((LZO1X_1_MEM_COMPRESS) + (sizeof(lzo_align_t) - 1)) / sizeof(lzo_align_t)); gettimeofday(&time_start, NULL); lzo1x_1_compress(inpbuffer, (unsigned int) file_size, outbuffer, &compressed_size, wrkmem); gettimeofday(&time_end, NULL); printf("Duration: %lu\n", ((time_end.tv_sec * 1000) + (time_end.tv_usec / 1000)) - ((time_start.tv_sec * 1000) + (time_start.tv_usec / 1000))); printf("Original: %lu\n",file_size); printf("Compressed: %lu\n",compressed_size); }
bool LzoCompression::DoCompress(const char* str, size_t length, std::string* out) { size_t outsize = (length + length / 16 + 64 + 3); if (c_buff_size_ < outsize) { delete [] compressed_buff_; c_buff_size_ *= 2; compressed_buff_ = new unsigned char[c_buff_size_]; VLOG(28) << "malloc larger space :" << c_buff_size_; CHECK(compressed_buff_) << "fail to new space"; } lzo_uint out_len = c_buff_size_; int r = lzo1x_1_compress(reinterpret_cast<const unsigned char*>(str), length, compressed_buff_, &out_len, wrkmem_); if (r == LZO_E_OK) { VLOG(28) << "compressed " << length << " bytes into " << out_len << " bytes"; } else { LOG(ERROR)<< "internal error - compression failed"; return false; } out->assign(reinterpret_cast<const char*>(compressed_buff_), out_len); return true; }
rt_private void parsing_store_write(size_t size) { RT_GET_CONTEXT char* cmps_out_ptr = cmps_general_buffer; lzo_uint cmps_out_size = (lzo_uint) cmp_buffer_size; int signed_cmps_out_size; REQUIRE("cmp_buffer_size not too big", cmp_buffer_size <= 0x7FFFFFFF); REQUIRE("size not too big", size <= 0x7FFFFFFF); lzo1x_1_compress ( (unsigned char *) general_buffer, /* Current buffer location */ (lzo_uint) size, /* Current buffer size */ (unsigned char *) cmps_out_ptr, /* Output buffer for compressed data */ &cmps_out_size, /* Size of output buffer and then size of compressed data */ wrkmem); /* Memory allocator */ signed_cmps_out_size = (int) cmps_out_size; /* Write size of compressed data */ if (parsing_char_write ((char *) &signed_cmps_out_size, sizeof(int)) <= 0) eraise ("Unable to write compressed data size", EN_IO); /* Write compressed data */ if (parsing_char_write (cmps_out_ptr, signed_cmps_out_size) <= 0) eraise ("Unable to write on specified device", EN_IO); }
static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) { if(level == 0) { memcpy(dest, source, len); return len; } else if(level == 10) { #ifdef HAVE_LZO lzo_uint lzolen = MAXSIZE; lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem); return lzolen; #else return -1; #endif } else if(level < 10) { #ifdef HAVE_ZLIB unsigned long destlen = MAXSIZE; if(compress2(dest, &destlen, source, len, level) == Z_OK) return destlen; else #endif return -1; } else { #ifdef HAVE_LZO lzo_uint lzolen = MAXSIZE; lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem); return lzolen; #else return -1; #endif } return -1; }
// // MSG_CompressMinilzo // bool MSG_CompressMinilzo (buf_t &buf, size_t start_offset, size_t write_gap) { if(buf.size() < MINILZO_COMPRESS_MINPACKETSIZE) return false; lzo_uint outlen = OUT_LEN(buf.maxsize() - start_offset - write_gap); size_t total_len = outlen + start_offset + write_gap; if(compressed.maxsize() < total_len) compressed.resize(total_len); int r = lzo1x_1_compress (buf.ptr() + start_offset, buf.size() - start_offset, compressed.ptr() + start_offset + write_gap, &outlen, wrkmem); // worth the effort? if(r != LZO_E_OK || outlen >= (buf.size() - start_offset - write_gap)) return false; memcpy(compressed.ptr(), buf.ptr(), start_offset); SZ_Clear(&buf); MSG_WriteChunk(&buf, compressed.ptr(), outlen + start_offset + write_gap); return true; }
static void lzo_compress_buf(struct stream *s, int *c_type, i64 *c_len) { uchar *c_buf; lzo_bytep wrkmem; lzo_uint in_len = s->buflen; lzo_uint dlen = in_len + in_len / 16 + 64 + 3; lzo_int return_var; /* lzo1x_1_compress does not return anything but LZO_OK */ wrkmem = (lzo_bytep) malloc(LZO1X_1_MEM_COMPRESS); if (wrkmem == NULL) return; c_buf = malloc(dlen); if (!c_buf) goto out_free; return_var = lzo1x_1_compress((uchar *)s->buf, in_len, (uchar *)c_buf, &dlen,wrkmem); if (dlen >= in_len){ /* Incompressible, leave as CTYPE_NONE */ free(c_buf); goto out_free; } *c_len = dlen; free(s->buf); s->buf = c_buf; *c_type = CTYPE_LZO; out_free: free(wrkmem); }
void CompressBufferLZO( CMemData& bufOut,const char* szData,size_t stSize ) { //计算保险长度的方法看testmini.c中的例子,这个文件是minilzo附带的 lzo_uint uOutSize=lzo_uint( stSize + stSize / 16 + 64 + 3 ); const size_t stOrgOutSize = bufOut.Size(); bufOut.ReSize( uOutSize + stOrgOutSize ); if( LZO_E_OK != lzo1x_1_compress ( reinterpret_cast<const lzo_bytep>(szData), lzo_uint(stSize) , bufOut.AsPtr<lzo_byte>( stOrgOutSize ),&uOutSize,CLzoWorkBuffer::ms_Inst.GetBuffer() ) ) { GenErr("lzo compress failed!"); } bufOut.ReSize( uOutSize + stOrgOutSize ); //CMemData test(bufOut); //test.ReSize(stSize); //DecompressBufferLZO(test.Data(),stSize,bufOut.AsPtr<const char>(4),bufOut.Size()-4); //printf("%d %d %0.2f\n",int(bufOut.Size()),int(stSize),bufOut.Size()/(float)stSize ); //FILE* fp=fopen("compress.txt","a"); //fwrite( &bufOut[ stOrgOutSize ],1,bufOut.Size()-stOrgOutSize,fp); //fclose(fp); }
int bmz_lz_pack(const void *in, size_t in_len, void *out, size_t *out_len_p, void *work_mem) { lzo_uint olen = *out_len_p; int ret = lzo1x_1_compress((Byte *)in, in_len, (Byte *)out, &olen, work_mem); *out_len_p = olen; return ret; }
void vncEncodeUltra::SendUltrarects(VSocket *outConn) { int NRects=m_nNbRects; const lzo_uint rawDataSize = (m_Queuelen); if (NRects==0) return; // NO update if (m_nNbRects<3 && !must_be_zipped) { outConn->SendExactQueue( (char *)m_Queuebuffer, m_Queuelen); // 1 Small update m_nNbRects=0; m_Queuelen=0; encodedSize += m_Queuelen-sz_rfbFramebufferUpdateRectHeader; rectangleOverhead += sz_rfbFramebufferUpdateRectHeader; return; } m_nNbRects=0; m_Queuelen=0; must_be_zipped=false; lzo1x_1_compress(m_Queuebuffer,rawDataSize,m_QueueCompressedbuffer,&out_len,wrkmem); if (out_len>rawDataSize) { outConn->SendExactQueue( (char *)m_Queuebuffer, m_Queuelen); // 1 Small update m_nNbRects=0; m_Queuelen=0; encodedSize += m_Queuelen-sz_rfbFramebufferUpdateRectHeader; rectangleOverhead += sz_rfbFramebufferUpdateRectHeader; return; } int rawDataSize1=rawDataSize/65535; int rawDataSize2=rawDataSize%65535; rfbFramebufferUpdateRectHeader CacheRectsHeader; CacheRectsHeader.r.x = (CARD16)(NRects); CacheRectsHeader.r.y = (CARD16)(rawDataSize2); CacheRectsHeader.r.w = (CARD16)(rawDataSize1); CacheRectsHeader.r.x = Swap16IfLE(CacheRectsHeader.r.x); CacheRectsHeader.r.y = Swap16IfLE(CacheRectsHeader.r.y); CacheRectsHeader.r.w = Swap16IfLE(CacheRectsHeader.r.w); CacheRectsHeader.r.h = 0; CacheRectsHeader.encoding = Swap32IfLE(rfbEncodingUltraZip); // Format the UltraHeader rfbZlibHeader CacheZipHeader; CacheZipHeader.nBytes = Swap32IfLE(out_len); vnclog.Print(LL_INTINFO, VNCLOG("********QUEUEQUEUE********** %d %d %d\r\n"),out_len,rawDataSize,NRects); outConn->SendExactQueue((char *)&CacheRectsHeader, sizeof(CacheRectsHeader)); outConn->SendExactQueue((char *)&CacheZipHeader, sizeof(CacheZipHeader)); outConn->SendExactQueue((char *)m_QueueCompressedbuffer, out_len); // Update statistics encodedSize += sz_rfbZlibHeader + out_len; rectangleOverhead += sz_rfbFramebufferUpdateRectHeader; transmittedSize += out_len+sz_rfbFramebufferUpdateRectHeader+sz_rfbZlibHeader; }
/* * log_zip - compress(zip) log data into LOG_ZIP * return: true on success, false on failure * log_zip(in/out): LOG_ZIP structure allocated by log_zip_alloc * length(in): length of given data * data(in): log data to be compressed */ bool log_zip (LOG_ZIP * log_zip, LOG_ZIP_SIZE_T length, const void *data) { lzo_uint zip_len = 0; LOG_ZIP_SIZE_T buf_size; int rc; assert (length > 0 && data != NULL); assert (log_zip != NULL); log_zip->data_length = 0; buf_size = LOG_ZIP_BUF_SIZE (length); if (buf_size > log_zip->buf_size) { if (log_zip->log_data) { free_and_init (log_zip->log_data); } log_zip->log_data = (unsigned char *) malloc (buf_size); if (log_zip->log_data == NULL) { er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, buf_size); } log_zip->buf_size = buf_size; } if (log_zip->log_data == NULL) { log_zip->data_length = 0; log_zip->buf_size = 0; return false; } /* save original data length */ memcpy (log_zip->log_data, &length, sizeof (LOG_ZIP_SIZE_T)); rc = lzo1x_1_compress ((lzo_bytep) data, (lzo_uint) length, log_zip->log_data + sizeof (LOG_ZIP_SIZE_T), &zip_len, log_zip->wrkmem); if (rc == LZO_E_OK) { log_zip->data_length = zip_len + sizeof (LOG_ZIP_SIZE_T); /* if the compressed data length >= orginal length, * then it means that compression failed */ if (log_zip->data_length < length) { return true; } } return false; }
bool NetPlayServer::CompressBufferIntoPacket(const std::vector<u8>& in_buffer, sf::Packet& packet) { const sf::Uint64 size = in_buffer.size(); packet << size; if (size == 0) return true; std::vector<u8> out_buffer(NETPLAY_LZO_OUT_LEN); std::vector<u8> wrkmem(LZO1X_1_MEM_COMPRESS); lzo_uint i = 0; while (true) { lzo_uint32 cur_len = 0; // number of bytes to read lzo_uint out_len = 0; // number of bytes to write if ((i + NETPLAY_LZO_IN_LEN) >= size) { cur_len = static_cast<lzo_uint32>(size - i); } else { cur_len = NETPLAY_LZO_IN_LEN; } if (cur_len <= 0) break; // end of buffer if (lzo1x_1_compress(&in_buffer[i], cur_len, out_buffer.data(), &out_len, wrkmem.data()) != LZO_E_OK) { PanicAlertT("Internal LZO Error - compression failed"); return false; } // The size of the data to write is 'out_len' packet << static_cast<u32>(out_len); for (size_t j = 0; j < out_len; j++) { packet << out_buffer[j]; } if (cur_len != NETPLAY_LZO_IN_LEN) break; i += cur_len; } // Mark end of data packet << static_cast<u32>(0); return true; }
int lzo(char *srcfile, char *destfile) { int result; int fd; struct stat s; lzo_bytep in; lzo_bytep out; lzo_uint in_len, out_len; rt_memset(&s, 0, sizeof(struct stat)); stat(srcfile, &s); in_len = s.st_size; in = rt_malloc(in_len); if (in == RT_NULL) return -1; out = rt_malloc(LZO1X_WORST(in_len)); if (out == RT_NULL) return -1; fd = open(srcfile, O_RDONLY, 0); if(fd < 0) { result = -1; goto _exit; } read(fd, in, in_len); close(fd); result = lzo1x_1_compress(in, in_len, out, &out_len, wrkmem); if(result != LZO_E_OK) { rt_kprintf("internal error - compression failed: \nerr_code:(%d) %s, %s.\n", result, parse_lzo_error_code(result), "Please use the binary access"); goto _exit; } fd = open(destfile, O_WRONLY | O_BINARY | O_CREAT, 0); if(fd < 0) { result = -1; goto _exit; } write(fd, &in_len, sizeof(lzo_uint)); /* source file len */ write(fd, out, out_len); close(fd); rt_kprintf("compress lzo ok!\n"); result = 0; _exit: rt_free(in); rt_free(out); return result; }
static int compress_lzo(const void *in, void *out, size_t inlen, size_t outlen) { int ret; ret = lzo1x_1_compress(in, inlen, out, &outlen, workspace); if (ret != LZO_E_OK) { pr_err("lzo_compress error, ret = %d!\n", ret); return -EIO; } return outlen; }
static int lzo_wwrite_block(const char *buffer, off_t len, struct buffer_t *outbuf) { char b2[MAX_BUFFER_SIZE]; int err; lzo_uint dst_len; char scratch[LZO1X_1_MEM_COMPRESS]; outbuf->offset=0; memset(scratch,0,sizeof(scratch)); err=lzo1x_1_compress((void*)buffer, len, (void*)b2, &dst_len, scratch); switch(err) { case LZO_E_OK: break; case LZO_E_ERROR: return -EINVAL; /* WTF? */ case LZO_E_OUT_OF_MEMORY: return -ENOMEM; /* Uh oh */ case LZO_E_NOT_COMPRESSIBLE: return -EINVAL; /* Claimed not to be used, dunno what we'll do */ case LZO_E_INPUT_OVERRUN: return -EINVAL; /* Can't happen on compress? */ case LZO_E_OUTPUT_OVERRUN: return -ENOMEM; case LZO_E_LOOKBEHIND_OVERRUN: return -EINVAL; case LZO_E_EOF_NOT_FOUND: return -ENOENT; /* Can't happen on compress? */ case LZO_E_INPUT_NOT_CONSUMED: return -EINVAL; case LZO_E_NOT_YET_IMPLEMENTED: return -ENOSYS; default: fprintf(stderr,"Unknown lzo error %d\n",err); return -EINVAL; } write32(outbuf, len); /* Original length */ write32(outbuf, min((uint32_t)len,(uint32_t)dst_len)); /* CRC32 of the uncompressed buffer */ #if 0 write32(outbuf, lzo_crc32(CRC32_INIT_VALUE, (void*)buffer, len)); #endif write32(outbuf, lzo_adler32(ADLER32_INIT_VALUE, (const void*)buffer, len)); write_buf(outbuf, b2, dst_len); /* Return the number of bytes compressed */ return len; }
void ts_comp(BYTE *flag, BYTE *pbuff, size_t *pbuff_len, BYTE *mid_buff, BYTE *lz4hc_wrkmem) { size_t mid_buff_size = 0; ///if(lz4hc_compress( (const unsigned char *)pbuff, (*pbuff_len), (unsigned char *)mid_buff, &mid_buff_size, (void *)lz4hc_wrkmem)<0) return; if(lzo1x_1_compress( (const unsigned char *)pbuff, (*pbuff_len), (unsigned char *)mid_buff, &mid_buff_size, (void *)lz4hc_wrkmem)<0) return; if(((mid_buff_size+TS_FLAG_SIZE) < (*pbuff_len)) && (mid_buff_size!=0)) { memcpy((BYTE *)pbuff, (BYTE *)mid_buff, mid_buff_size); (*pbuff_len)=mid_buff_size; (*flag) |= TS_FLAG_COMP; #ifdef CONFIG_TRAFFICSQUEEZER_DEBUG printk("comp - prossd [LZ4-HC] [mid_buff_size: %zu] [flag: %d]\n", mid_buff_size, *flag); #endif } }
void lzowrite_wbuf(struct lzowrite_buffer* lzowrite_buffer) { lzo1x_1_compress(lzowrite_buffer->buffer, lzowrite_buffer->length, lzowrite_buffer->out_buffer, (lzo_uintp)&lzowrite_buffer->out_length, lzowrite_buffer->workmemory); //Write block header fwrite_int32_be(&lzowrite_buffer->length, lzowrite_buffer->output); fwrite_int32_be(&lzowrite_buffer->out_length, lzowrite_buffer->output); //Write content fwrite(lzowrite_buffer->out_buffer, sizeof(unsigned char), lzowrite_buffer->out_length, lzowrite_buffer->output); //Reset buffer lzowrite_buffer->length = 0; }
void SGuildMarkBlock::Compress(const Pixel * pxBuf) { m_sizeCompBuf = MAX_COMP_SIZE; if (LZO_E_OK != lzo1x_1_compress((const BYTE *) pxBuf, sizeof(Pixel) * SGuildMarkBlock::SIZE, m_abCompBuf, &m_sizeCompBuf, CLZO::Instance().GetWorkMemory())) { sys_err("SGuildMarkBlock::Compress: Error! %u > %u", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf); return; } //sys_log(0, "SGuildMarkBlock::Compress %u > %u", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf); m_crc = GetCRC32((const char *) pxBuf, sizeof(Pixel) * SGuildMarkBlock::SIZE); }
void FLZOFile::Implode () { lzo_uint outlen = 0; unsigned int len = m_BufferSize; lzo_byte *compressed = NULL; lzo_byte *wrkmem; byte *oldbuf = m_Buffer; int r; if (!m_NoCompress) { compressed = new lzo_byte[OUT_LEN(len)]; wrkmem = new lzo_byte[LZO1X_1_MEM_COMPRESS]; r = lzo1x_1_compress (m_Buffer, len, compressed, &outlen, wrkmem); delete[] wrkmem; // If the data could not be compressed, store it as-is. if (r != LZO_E_OK || outlen > len) { DPrintf ("LZOFile could not be imploded\n"); outlen = 0; } else { DPrintf ("LZOFile shrunk from %u to %u bytes\n", len, outlen); } } else { outlen = 0; } m_MaxBufferSize = m_BufferSize = ((outlen == 0) ? len : outlen); m_Buffer = (BYTE *)Malloc (m_BufferSize + 8); m_Pos = 0; DWORD *lens = (DWORD *)(m_Buffer); lens[0] = BELONG((unsigned int)outlen); lens[1] = BELONG(len); if (outlen == 0) memcpy (m_Buffer + 8, oldbuf, len); else memcpy (m_Buffer + 8, compressed, outlen); delete[] compressed; compressed = NULL; M_Free(oldbuf); }
static int lzo_compress(struct crypto_tfm *tfm, const u8 *src, unsigned int slen, u8 *dst, unsigned int *dlen) { struct lzo_ctx *ctx = crypto_tfm_ctx(tfm); size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */ int err; err = lzo1x_1_compress(src, slen, dst, &tmp_len, ctx->lzo_comp_mem); if (err != LZO_E_OK) return -EINVAL; *dlen = tmp_len; return 0; }
bool Compress::ToLZO( U8* pSrcData, UInt uiSrcSize, U8* pDstData, U32* uiDstSize){ int r = lzo1x_1_compress(pSrcData,uiSrcSize,pDstData,uiDstSize,wrkmem); if (r == LZO_E_OK){ if (*uiDstSize >= uiSrcSize){ return false; } }else{ return false; } return true; }
BOOL KScriptServer::Call(int nConnIndex, const char cszFunction[]) { BOOL bResult = false; int nRetCode = 0; size_t uOrgLen = (size_t)(m_pbyPos - m_byOriginalBuffer); size_t uCpsLen = 0; nRetCode = lzo1x_1_compress(m_byOriginalBuffer, (lzo_uint)uOrgLen, m_byCompressBuffer, (lzo_uint*)&uCpsLen, m_LzoWorkBuffer); KGLOG_PROCESS_ERROR(nRetCode == LZO_E_OK); g_PlayerServer.DoRemoteLuaCall(nConnIndex, cszFunction, m_byCompressBuffer, uCpsLen); bResult = true; Exit0: return bResult; }
int bufferEncrypt(char *buf, int size, char *target, int targetSize, char *key, int keySize) { char tmp[LZO1X_MEM_COMPRESS]; int ret; lzo_uint retSize=targetSize; xorEncode(buf, size, key, keySize); ret=lzo1x_1_compress((lzo_byte*)buf, size, (lzo_byte*)target, &retSize, tmp); if(ret==LZO_E_OK) { xorEncode2(target, retSize); // printf("Encrpt(%d->%d),key=%s(%d): %02X%02X...%02X%02X -> %02X%02X...%02X%02X\n",size,retSize,key,keySize, // buf[0],buf[1],buf[size-2],buf[size-1], target[0], target[1], target[retSize-2], target[retSize-1]); // if(retSize<256) DumpData(target, retSize); return retSize; } return ret; }
void *_tc_recencode(const void *ptr, int size, int *sp, void *op){ if(!_tc_lzo_init){ if(lzo_init() != LZO_E_OK) return NULL; _tc_lzo_init = false; } lzo_bytep buf = MYMALLOC(size + (size >> 4) + 80); if(!buf) return NULL; lzo_uint bsiz; char wrkmem[LZO1X_1_MEM_COMPRESS]; if(lzo1x_1_compress((lzo_bytep)ptr, size, buf, &bsiz, wrkmem) != LZO_E_OK){ MYFREE(buf); return NULL; } buf[bsiz] = '\0'; *sp = bsiz; return (char *)buf; }