Windows下编译zlib1.2.11

下载源代码

前往zlib官网下载zlib1.2.11源代码

编译汇编代码

使用VS工具运行下面两个批处理

zlib\contrib\masmx86\bld_ml64.bat
zlib\contrib\masmx64\bld_ml32.bat

配置静态库项目

使用VS打开解决方案文件zlib\contrib\vstudio\vc14\zlibvc.sln
设置zlibstat项目编译方式(MT/MD)，以及使用的WindowsSDK等信息

添加内存解压接口

使用VS打开解决方案文件zlib\contrib\vstudio\vc14\zlibvc.sln
添加ioapi_mem.c到zlibstat项目

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "zlib.h"
#include "ioapi.h"



voidpf ZCALLBACK fopen_mem_func OF((
   voidpf opaque,
   const char* filename,
   int mode));

uLong ZCALLBACK fread_mem_func OF((
   voidpf opaque,
   voidpf stream,
   void* buf,
   uLong size));

uLong ZCALLBACK fwrite_mem_func OF((
   voidpf opaque,
   voidpf stream,
   const void* buf,
   uLong size));

long ZCALLBACK ftell_mem_func OF((
   voidpf opaque,
   voidpf stream));

long ZCALLBACK fseek_mem_func OF((
   voidpf opaque,
   voidpf stream,
   uLong offset,
   int origin));

int ZCALLBACK fclose_mem_func OF((
   voidpf opaque,
   voidpf stream));

int ZCALLBACK ferror_mem_func OF((
   voidpf opaque,
   voidpf stream));


typedef struct ourmemory_s {
  char *base; /* Base of the region of memory we're using */
  uLong size; /* Size of the region of memory we're using */
  uLong limit; /* Furthest we've written */
  uLong cur_offset; /* Current offset in the area */
} ourmemory_t;

voidpf ZCALLBACK fopen_mem_func (opaque, filename, mode)
   voidpf opaque;
   const char* filename;
   int mode;
{
    ourmemory_t *mem = malloc(sizeof(*mem));
    if (mem==NULL)
      return NULL; /* Can't allocate space, so failed */

    /* Filenames are specified in the form :
     *    <hex base of zip file>+<hex size of zip file>
     * This may not work where memory addresses are longer than the
     * size of an int and therefore may need addressing for 64bit
     * architectures
     */
    if (sscanf(filename,"%x+%x",&mem->base,&mem->size)!=2)
      return NULL;

    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
      mem->limit=0; /* When writing we start with 0 bytes written */
    else
      mem->limit=mem->size;

    mem->cur_offset = 0;

    return mem;
}


uLong ZCALLBACK fread_mem_func (opaque, stream, buf, size)
   voidpf opaque;
   voidpf stream;
   void* buf;
   uLong size;
{
    ourmemory_t *mem = (ourmemory_t *)stream;

    if (size > mem->size - mem->cur_offset)
      size = mem->size - mem->cur_offset;

    memcpy(buf, mem->base + mem->cur_offset, size);
    mem->cur_offset+=size;

    return size;
}


uLong ZCALLBACK fwrite_mem_func (opaque, stream, buf, size)
   voidpf opaque;
   voidpf stream;
   const void* buf;
   uLong size;
{
    ourmemory_t *mem = (ourmemory_t *)stream;

    if (size > mem->size - mem->cur_offset)
      size = mem->size - mem->cur_offset;

    memcpy(mem->base + mem->cur_offset, buf, size);
    mem->cur_offset+=size;
    if (mem->cur_offset > mem->limit)
      mem->limit = mem->cur_offset;

    return size;
}

long ZCALLBACK ftell_mem_func (opaque, stream)
   voidpf opaque;
   voidpf stream;
{
    ourmemory_t *mem = (ourmemory_t *)stream;

    return mem->cur_offset;
}

long ZCALLBACK fseek_mem_func (opaque, stream, offset, origin)
   voidpf opaque;
   voidpf stream;
   uLong offset;
   int origin;
{
    ourmemory_t *mem = (ourmemory_t *)stream;
    uLong new_pos;
    switch (origin)
    {
    case ZLIB_FILEFUNC_SEEK_CUR :
        new_pos = mem->cur_offset + offset;
        break;
    case ZLIB_FILEFUNC_SEEK_END :
        new_pos = mem->limit + offset;
        break;
    case ZLIB_FILEFUNC_SEEK_SET :
        new_pos = offset;
        break;
    default: return -1;
    }

    if (new_pos > mem->size)
      return 1; /* Failed to seek that far */

    if (new_pos > mem->limit)
      memset(mem->base + mem->limit, 0, new_pos - mem->limit);

    mem->cur_offset = new_pos;
    return 0;
}

int ZCALLBACK fclose_mem_func (opaque, stream)
   voidpf opaque;
   voidpf stream;
{
    ourmemory_t *mem = (ourmemory_t *)stream;

    /* Note that once we've written to the buffer we don't tell anyone
       about it here. Probably the opaque handle could be used to inform
       some other component of how much data was written.

       This, and other aspects of writing through this interface, has
       not been tested.
     */

    free (mem);
    return 0;
}

int ZCALLBACK ferror_mem_func (opaque, stream)
   voidpf opaque;
   voidpf stream;
{
    ourmemory_t *mem = (ourmemory_t *)stream;
    /* We never return errors */
    return 0;
}

void fill_memory_filefunc (pzlib_filefunc_def)
  zlib_filefunc_def* pzlib_filefunc_def;
{
    pzlib_filefunc_def->zopen_file = fopen_mem_func;
    pzlib_filefunc_def->zread_file = fread_mem_func;
    pzlib_filefunc_def->zwrite_file = fwrite_mem_func;
    pzlib_filefunc_def->ztell_file = ftell_mem_func;
    pzlib_filefunc_def->zseek_file = fseek_mem_func;
    pzlib_filefunc_def->zclose_file = fclose_mem_func;
    pzlib_filefunc_def->zerror_file = ferror_mem_func;
    pzlib_filefunc_def->opaque = NULL;
}

void fill_memory_filefunc64_32(zlib_filefunc64_32_def* pzlib_filefunc_def)
{
	pzlib_filefunc_def->zopen32_file = fopen_mem_func;
	pzlib_filefunc_def->zfile_func64.zopen64_file = fopen_mem_func;
	pzlib_filefunc_def->zfile_func64.zread_file = fread_mem_func;
	pzlib_filefunc_def->zfile_func64.zwrite_file = fwrite_mem_func;
	pzlib_filefunc_def->ztell32_file = ftell_mem_func;
	pzlib_filefunc_def->zseek32_file = fseek_mem_func;
	pzlib_filefunc_def->zfile_func64.zseek64_file = NULL;
	pzlib_filefunc_def->zfile_func64.zclose_file = fclose_mem_func;
	pzlib_filefunc_def->zfile_func64.zerror_file = ferror_mem_func;
	pzlib_filefunc_def->zfile_func64.opaque = NULL;
}

unzip.c末尾添加下面代码

void fill_memory_filefunc64_32(zlib_filefunc64_32_def* pzlib_filefunc_def);

extern unzFile ZEXPORT unzOpenBuffer(const  void* buffer, uLong size)
{
	char path[16] = { 0 };
	zlib_filefunc64_32_def memory_file;
	uLong base = (uLong)buffer;

	sprintf(path, "%x+%x", base, size);

	fill_memory_filefunc64_32(&memory_file);
	return unzOpenInternal(path, &memory_file, 0);
}

unzip.h添加下面代码

extern unzFile ZEXPORT unzOpenBuffer(const  void* buffer, uLong size);

完成

最后编译即可，使用该静态库需要添加预处理定义ZLIB_WINAPI