luo980/miniz
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace tabs with spaces

Browse Source
This commit is contained in:
Deomid rojer Ryabkov 2024-03-23 20:04:38 +00:00
parent 16413c213d
commit 420b407d25
4 changed files with 86 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
miniz_tdef.c
View File

@ -763,15 +763,15 @@ static int tdefl_flush_block(tdefl_compressor *d, int flush)
#ifdef MINIZ_UNALIGNED_USE_MEMCPY #ifdef MINIZ_UNALIGNED_USE_MEMCPY
static mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8* p) static mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8* p)
{ {
mz_uint16 ret; mz_uint16 ret;
memcpy(&ret, p, sizeof(mz_uint16)); memcpy(&ret, p, sizeof(mz_uint16));
return ret; return ret;
} }
static mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16* p) static mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16* p)
{ {
mz_uint16 ret; mz_uint16 ret;
memcpy(&ret, p, sizeof(mz_uint16)); memcpy(&ret, p, sizeof(mz_uint16));
return ret; return ret;
} }
#else #else
#define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p) #define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p)
@ -879,9 +879,9 @@ static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahe
#ifdef MINIZ_UNALIGNED_USE_MEMCPY #ifdef MINIZ_UNALIGNED_USE_MEMCPY
static mz_uint32 TDEFL_READ_UNALIGNED_WORD32(const mz_uint8* p) static mz_uint32 TDEFL_READ_UNALIGNED_WORD32(const mz_uint8* p)
{ {
mz_uint32 ret; mz_uint32 ret;
memcpy(&ret, p, sizeof(mz_uint32)); memcpy(&ret, p, sizeof(mz_uint32));
return ret; return ret;
} }
#else #else
#define TDEFL_READ_UNALIGNED_WORD32(p) *(const mz_uint32 *)(p) #define TDEFL_READ_UNALIGNED_WORD32(p) *(const mz_uint32 *)(p)
@ -956,7 +956,7 @@ static mz_bool tdefl_compress_fast(tdefl_compressor *d)
pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN); pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN);
#ifdef MINIZ_UNALIGNED_USE_MEMCPY #ifdef MINIZ_UNALIGNED_USE_MEMCPY
memcpy(&pLZ_code_buf[1], &cur_match_dist, sizeof(cur_match_dist)); memcpy(&pLZ_code_buf[1], &cur_match_dist, sizeof(cur_match_dist));
#else #else
*(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist; *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist;
#endif #endif

4
miniz_tinfl.c
View File

@ -550,7 +550,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
do do
{ {
#ifdef MINIZ_UNALIGNED_USE_MEMCPY #ifdef MINIZ_UNALIGNED_USE_MEMCPY
memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2); memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2);
#else #else
((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
@ -577,7 +577,7 @@ tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_nex
pOut_buf_cur[2] = pSrc[2]; pOut_buf_cur[2] = pSrc[2];
pOut_buf_cur += 3; pOut_buf_cur += 3;
pSrc += 3; pSrc += 3;
counter -= 3; counter -= 3;
} }
if (counter > 0) if (counter > 0)
{ {

130
miniz_zip.c
View File

@ -805,47 +805,47 @@ static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flag
if (extra_size_remaining) if (extra_size_remaining)
{ {
const mz_uint8 *pExtra_data; const mz_uint8 *pExtra_data;
void* buf = NULL; void* buf = NULL;
if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > n) if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > n)
{ {
buf = MZ_MALLOC(ext_data_size); buf = MZ_MALLOC(ext_data_size);
if(buf==NULL) if(buf==NULL)
return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size, buf, ext_data_size) != ext_data_size) if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size, buf, ext_data_size) != ext_data_size)
{ {
MZ_FREE(buf); MZ_FREE(buf);
return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
} }
pExtra_data = (mz_uint8*)buf; pExtra_data = (mz_uint8*)buf;
} }
else else
{ {
pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size; pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
} }
do do
{ {
mz_uint32 field_id; mz_uint32 field_id;
mz_uint32 field_data_size; mz_uint32 field_data_size;
if (extra_size_remaining < (sizeof(mz_uint16) * 2)) if (extra_size_remaining < (sizeof(mz_uint16) * 2))
{ {
MZ_FREE(buf); MZ_FREE(buf);
return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
} }
field_id = MZ_READ_LE16(pExtra_data); field_id = MZ_READ_LE16(pExtra_data);
field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining) if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
{ {
MZ_FREE(buf); MZ_FREE(buf);
return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
} }
if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
{ {
@ -859,7 +859,7 @@ static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flag
extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
} while (extra_size_remaining); } while (extra_size_remaining);
MZ_FREE(buf); MZ_FREE(buf);
} }
} }
@ -1064,7 +1064,7 @@ mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename,
if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
{ {
MZ_FCLOSE(pFile); MZ_FCLOSE(pFile);
return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
} }
@ -3276,16 +3276,16 @@ mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_n
} }
#endif /* #ifndef MINIZ_NO_TIME */ #endif /* #ifndef MINIZ_NO_TIME */
if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
{ {
uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size); uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
uncomp_size = buf_size; uncomp_size = buf_size;
if (uncomp_size <= 3) if (uncomp_size <= 3)
{ {
level = 0; level = 0;
store_data_uncompressed = MZ_TRUE; store_data_uncompressed = MZ_TRUE;
} }
} }
archive_name_size = strlen(pArchive_name); archive_name_size = strlen(pArchive_name);
if (archive_name_size > MZ_UINT16_MAX) if (archive_name_size > MZ_UINT16_MAX)
@ -3301,9 +3301,9 @@ mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_n
{ {
/* Bail early if the archive would obviously become too large */ /* Bail early if the archive would obviously become too large */
if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size
+ MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len +
pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len
+ MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF) + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
{ {
pState->m_zip64 = MZ_TRUE; pState->m_zip64 = MZ_TRUE;
/*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
@ -3402,13 +3402,13 @@ mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_n
cur_archive_file_ofs += archive_name_size; cur_archive_file_ofs += archive_name_size;
} }
if (user_extra_data_len > 0) if (user_extra_data_len > 0)
{ {
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len) if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
cur_archive_file_ofs += user_extra_data_len; cur_archive_file_ofs += user_extra_data_len;
} }
if (store_data_uncompressed) if (store_data_uncompressed)
{ {
@ -3562,8 +3562,8 @@ mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pA
{ {
/* Bail early if the archive would obviously become too large */ /* Bail early if the archive would obviously become too large */
if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
+ archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024 + archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
+ MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF) + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
{ {
pState->m_zip64 = MZ_TRUE; pState->m_zip64 = MZ_TRUE;
/*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
@ -3854,20 +3854,20 @@ mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pA
static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n) static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
{ {
MZ_FILE *pSrc_file = (MZ_FILE *)pOpaque; MZ_FILE *pSrc_file = (MZ_FILE *)pOpaque;
mz_int64 cur_ofs = MZ_FTELL64(pSrc_file); mz_int64 cur_ofs = MZ_FTELL64(pSrc_file);
if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pSrc_file, (mz_int64)file_ofs, SEEK_SET)))) if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pSrc_file, (mz_int64)file_ofs, SEEK_SET))))
return 0; return 0;
return MZ_FREAD(pBuf, 1, n, pSrc_file); return MZ_FREAD(pBuf, 1, n, pSrc_file);
} }
mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 max_size, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 max_size, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len) const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
{ {
return mz_zip_writer_add_read_buf_callback(pZip, pArchive_name, mz_file_read_func_stdio, pSrc_file, max_size, pFile_time, pComment, comment_size, level_and_flags, return mz_zip_writer_add_read_buf_callback(pZip, pArchive_name, mz_file_read_func_stdio, pSrc_file, max_size, pFile_time, pComment, comment_size, level_and_flags,
user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len); user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len);
} }
mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags) mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
@ -4189,11 +4189,11 @@ mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *
{ {
/* src is zip64, dest must be zip64 */ /* src is zip64, dest must be zip64 */
/* name uint32_t's */ /* name uint32_t's */
/* id 1 (optional in zip64?) */ /* id 1 (optional in zip64?) */
/* crc 1 */ /* crc 1 */
/* comp_size 2 */ /* comp_size 2 */
/* uncomp_size 2 */ /* uncomp_size 2 */
if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6)) if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6))
{ {
pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
@ -4728,7 +4728,7 @@ const char *mz_zip_get_error_string(mz_zip_error mz_err)
return "validation failed"; return "validation failed";
case MZ_ZIP_WRITE_CALLBACK_FAILED: case MZ_ZIP_WRITE_CALLBACK_FAILED:
return "write callback failed"; return "write callback failed";
case MZ_ZIP_TOTAL_ERRORS: case MZ_ZIP_TOTAL_ERRORS:
return "total errors"; return "total errors";
default: default:
break; break;

18
miniz_zip.h
View File

@ -321,13 +321,13 @@ MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, c
#if 0 #if 0
/* TODO */ /* TODO */
typedef void *mz_zip_streaming_extract_state_ptr; typedef void *mz_zip_streaming_extract_state_ptr;
mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags); mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
mz_uint64 mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState); mz_uint64 mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
mz_uint64 mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState); mz_uint64 mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, mz_uint64 new_ofs); mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, mz_uint64 new_ofs);
size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size); size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size);
mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState); mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
#endif #endif
/* This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. */ /* This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. */
@ -391,8 +391,8 @@ MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const cha
/* Adds the contents of a file to an archive. This function also records the disk file's modified time into the archive. */ /* Adds the contents of a file to an archive. This function also records the disk file's modified time into the archive. */
/* File data is supplied via a read callback function. User mz_zip_writer_add_(c)file to add a file directly.*/ /* File data is supplied via a read callback function. User mz_zip_writer_add_(c)file to add a file directly.*/
MINIZ_EXPORT mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void* callback_opaque, mz_uint64 max_size, MINIZ_EXPORT mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void* callback_opaque, mz_uint64 max_size,
const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
const char *user_extra_data_central, mz_uint user_extra_data_central_len); const char *user_extra_data_central, mz_uint user_extra_data_central_len);
#ifndef MINIZ_NO_STDIO #ifndef MINIZ_NO_STDIO