PNG图片数据解析

PNG是一种非常流行的图片格式，它不仅支持透明效果，而且图片数据经过了压缩处理，所以广泛用于web等应用。

PNG的文件格式：

　　PNG文件中的数据，总是以一个固定的8个字节开头：

　　　　（图片来自http://blog.csdn.net/bisword/article/details/2777121）

　　除此之外，PNG的其他数据都是以数据块的方式组织，它们被分为标准数据块和辅助数据块，其中的辅助数据块是可选的。关键数据块包含我们必须的图片信息，我们之后要重点解析的也是关键数据块。

　　

　　（图片来自http://blog.csdn.net/bisword/article/details/2777121）

每种数据块的结构：

　　

　　　　（图片来自http://blog.csdn.net/bisword/article/details/2777121）

　　Length：该数据块的中Chunk Data的长度；

　　Chunk Type Code：数据类型，就是指上面提到的IHDR，IEND等；

　　Chunk Data：数据区域，如果是IDAT，就表示存储的还未解压的图片数据；

　　CRC：循环冗余效验码；

具体实现：（实现中没有处理png数据中变形的情况，部分头中的宏定义来自libpng，实例不具备实用性，仅作参考）

头文件：

#ifndef __PNG__
#define __PNG__

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "zlib/zlib.h"

/**
 * 类型标志
 */
#define PNG_FLAG_HEX "89504E470D0A1A0A"

/**
 * 数据块类型
 */
#define DATA_CHUNK_TYPE_IHDR "IHDR"
#define DATA_CHUNK_TYPE_IDAT "IDAT"
#define DATA_CHUNK_TYPE_IEND "IEND"
#define DATA_CHUNK_TYPE_tEXt "tEXt"
#define DATA_CHUNK_TYPE_iTXt "iTXt"

/**
 * 过滤方式
 */
#define DATA_FILTER_TYPE_DEFAULT 0
#define DATA_FILTER_TYPE_ADD_ROW 1
#define DATA_FILTER_TYPE_ADD_UP  2
#define DATA_FILTER_TYPE_AVERGE  3
#define DATA_FILTER_TYPE_PAETH   4

/* color type masks */
#define PNG_COLOR_MASK_PALETTE    1
#define PNG_COLOR_MASK_COLOR      2
#define PNG_COLOR_MASK_ALPHA      4

/* color types.  Note that not all combinations are legal */
#define PNG_COLOR_TYPE_GRAY           0
#define PNG_COLOR_TYPE_PALETTE    (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)
#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)

#define RGB_USE_ALPHA(vr, vg, vb, va) 
    (unsigned)(((unsigned)((unsigned char)(vr) * ((unsigned char)(va) + 1)) >> 8) | 
    ((unsigned)((unsigned char)(vg) * ((unsigned char)(va) + 1) >> 8) << 8) | 
    ((unsigned)((unsigned char)(vb) * ((unsigned char)(va) + 1) >> 8) << 16) | 
    ((unsigned)(unsigned char)(va) << 24))

/**
 * 一次解压图片数据的限制
 */
#define DECOMPRESSION_MAX_BYTES 8192

/**
 * 数据块信息
 */
typedef struct _DataChunkHeader 
{
    // 数据长度
    unsigned char length[4];
    // 数据类型
    unsigned char type[4];
} DataChunkHeader;

/**
 * IHDR数据
 */
typedef struct _IDHRData
{
    unsigned char width[4];
    unsigned char height[4];
    unsigned char bitDepth[1];
    unsigned char colorType[1];
    unsigned char compressionMethod[1];
    unsigned char filterMethod[1];
    unsigned char interlaceMethod[1];
} IDHRData;

/**
 * PNG图片类
 */
class PNG
{
public:
    PNG();
    PNG(const char* filePath);

    ~PNG();

    int getWindth();
    int getHeight();

    /**
     * 获取图片宽度
     */
    unsigned char* getImageData();

private:
    int m_width;
    int m_height;

    unsigned char m_bitDepth;
    unsigned char m_colorType;
    unsigned char m_compressionMethod;
    unsigned char m_filterMethod;
    unsigned char m_interlaceMethod;
    unsigned char m_chanels;

    unsigned char* m_imageData;

    /**
     * 从文件加载图片数据
     */
    bool loadImageDataFromFile(const char* filePath);

    /**
     * 解析数值
     */
    int parseNumber(const unsigned char* data, int len);

    /**
     * 解压数据
     */
    int decompressData(z_stream* zStream, unsigned char* data, int dataLen, int leftLen, FILE *pFile);

    /**
     * 生成图片数据
     */
    void generateImageData(unsigned char* data, unsigned long dataLen);

    /**
     * 默认的过滤方式
     */
    void defaultFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);

    /**
     * 当前行相加的过滤方式
     */
    void addCurrentRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);

    /**
     * 前一行相加的过滤方式
     */
    void addUpRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);

    /**
     * 平均的过滤方式
     */
    void avergeFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);

    /**
     * paeth的过滤方式
     */
    void paethFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes);

    /**
     * 解析IHDR数据
     */
    void parseIHDRData(DataChunkHeader& dataChunkHeader, FILE* pFile);

    /**
     * 解析IDAT数据
     */
    void parseIDATData(DataChunkHeader& dataChunkHeader, FILE* pFile);

    /**
     * 解析IEND数据
     */
    void parseIENDData(DataChunkHeader& dataChunkHeader, FILE *pFile);

    /**
     * 解析其他数据
     */
    void parseCommonData(DataChunkHeader& dataChunkHeader, FILE *pFile);
};

#endif

cpp文件：

#include "png.h"
#include "utils/cUtil.h"
#include <stdlib.h>

#include <windows.h>

/**
 * 默认构造函数
 */
PNG::PNG()
{
    this->m_width = 0;
    this->m_height = 0;

    this->m_imageData = 0;
}

/**
 * 构造函数
 * @param filePath 图片路径
 */
PNG::PNG(const char *filePath)
{
    this->m_width = 0;
    this->m_height = 0;

    this->loadImageDataFromFile(filePath);
}

/**
 * 析构函数
 */
PNG::~PNG()
{

}

/**
 * 从文件加载图片数据
 */
bool PNG::loadImageDataFromFile(const char* filePath)
{
    FILE* pFile = fopen(filePath, "rb");
    if (!pFile)
        return false;

    // 解析PNG标志
    char flag[8];
    char hexFlag[17];
    fread(flag, 1, 8, pFile);
    toHexStr(flag, 8, hexFlag);
    if (strcmp(hexFlag, PNG_FLAG_HEX) != 0)
        return false;

    // 解析图片数据
    DataChunkHeader dataChunkHeader;
    char dataChunkHeaderType[5];
    do {
        fread(&dataChunkHeader, 1, sizeof(DataChunkHeader), pFile);

        memcpy(dataChunkHeaderType, dataChunkHeader.type, 4);
        dataChunkHeaderType[4] = '';

        // IHDR
        if ( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IHDR) == 0 ) {
            this->parseIHDRData(dataChunkHeader, pFile);
        }
        // IDAT
        else if ( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IDAT) == 0 ) {
            this->parseIDATData(dataChunkHeader, pFile);
        }
        // IEND
        else if ( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IEND) == 0 ) {
            this->parseIENDData(dataChunkHeader, pFile);
        }
        // 其他数据
        else {
            this->parseCommonData(dataChunkHeader, pFile);
        }
    } while( strcmp(dataChunkHeaderType, DATA_CHUNK_TYPE_IEND) != 0 );

    int i = 1;

    return true;
}

/**
 * 解析数值
 */
int PNG::parseNumber(const unsigned char* data, int len)
{
    char localNum[4];

    bool isLittleEndian = checkEndian();
    for (int i = 0; i<4; i++) {
        char ch;

        if (isLittleEndian) {
            if (i <= len-1)
                ch = data[len - 1 - i];
            else
                ch = '';
        }
        else {
            if (i <= len-1)
                ch = data[i];
            else
                ch = '';
        }
        localNum[i] = ch;
    }

    int num;
    memcpy(&num, localNum, 4);
    return num;
}

/**
 * 解析IHDR数据
 */
void PNG::parseIHDRData(DataChunkHeader& dataChunkHeader, FILE* pFile)
{
    int dataLen = this->parseNumber(dataChunkHeader.length, 4);

    IDHRData idhrData;
    char crc[4];

    fread(&idhrData, 1, sizeof(IDHRData), pFile);
    fread(crc, 1, 4, pFile);

    this->m_width              = this->parseNumber(idhrData.width, 4);
    this->m_height              = this->parseNumber(idhrData.height, 4);
    this->m_bitDepth          = this->parseNumber(idhrData.bitDepth, 1);
    this->m_colorType          = this->parseNumber(idhrData.colorType, 1);
    this->m_compressionMethod = this->parseNumber(idhrData.compressionMethod, 1);
    this->m_filterMethod      = this->parseNumber(idhrData.filterMethod, 1);
    this->m_interlaceMethod   = this->parseNumber(idhrData.interlaceMethod, 1);
    this->m_chanels              = 0;

    switch (this->m_colorType) {
        case PNG_COLOR_TYPE_GRAY:
        case PNG_COLOR_TYPE_PALETTE:
            this->m_chanels = 1;
        break;
        case PNG_COLOR_TYPE_RGB:
            this->m_chanels = 3;
        break;
        case PNG_COLOR_TYPE_GRAY_ALPHA:
            this->m_chanels = 2;
        break;
        case PNG_COLOR_TYPE_RGB_ALPHA:
            this->m_chanels = 4;
        break;
        default:
            this->m_chanels = 0;
        break;
   }
}

/**
 * 解压数据
 */
int PNG::decompressData(z_stream* zStream, unsigned char* data, int dataLen, int leftLen, FILE *pFile)
{
    int result = 0;

    int leftBytesCount = leftLen;
    int avail_out = -1;
    do {
        if (zStream->avail_in == 0) {
            if (avail_out == 0) 
                break;
            else {
                if (leftBytesCount == 0) {
                    DataChunkHeader dataChunkHeader;
                    fread(&dataChunkHeader, 1, sizeof(DataChunkHeader), pFile);

                    int newDataLen = this->parseNumber(dataChunkHeader.length, 4);
                    unsigned char* newData = new unsigned char[dataLen + newDataLen];
                    char crc[4];

                    fread(newData + dataLen, 1, newDataLen, pFile);
                    fread(crc, 1, 4, pFile);
                    memcpy(newData, data, dataLen);

                    delete data;
                    data = newData;

                    zStream->next_in = newData + dataLen;
                    zStream->avail_in = newDataLen;

                    dataLen = dataLen + newDataLen;
                    
                    return this->decompressData(zStream, data, dataLen, 0, pFile);
                }
            }

            // 导出数据是否超过限制
            if (leftBytesCount > DECOMPRESSION_MAX_BYTES)
                zStream->avail_in = DECOMPRESSION_MAX_BYTES;
            else
                zStream->avail_in = leftBytesCount;

            leftBytesCount -= zStream->avail_in;
        }
        
        if (avail_out > 0)
            zStream->avail_out = avail_out;
        else
            zStream->avail_out = m_width * 4 + 1;

        result = inflate(zStream, Z_NO_FLUSH);
        if (result != Z_OK)
            break;

        avail_out = zStream->avail_out;
    } while (zStream->avail_in >= 0);

    return result;
}

/**
 * 生成图片数据
 */
void PNG::generateImageData(unsigned char* data, unsigned long dataLen)
{
    // 行字节数
    int rowBytes = this->m_chanels * this->m_width;

    // 初始化图片数据
    this->m_imageData = new unsigned char[rowBytes * this->m_height];

    unsigned char* pImageData = this->m_imageData;
    unsigned char* pRowData = data;

    for (int rowIndex = 0; rowIndex < this->m_height; rowIndex++) {
        // 过滤类型
        unsigned char filterType = pRowData[0]; 

        pRowData += 1;

        switch (filterType) {
            // 不需要过滤处理
            case DATA_FILTER_TYPE_DEFAULT:
                this->defaultFilterType(pImageData, pRowData, rowBytes);
            break;
            // 当前行相加
            case DATA_FILTER_TYPE_ADD_ROW:
                this->addCurrentRowFilterType(pImageData, pRowData, rowBytes);
            break;
            // 和前一行相加
            case DATA_FILTER_TYPE_ADD_UP:
                this->addUpRowFilterType(pImageData, pRowData, rowBytes);
            break;
            // 求平均
            case DATA_FILTER_TYPE_AVERGE:
                this->avergeFilterType(pImageData, pRowData, rowBytes);
            break;
            // Paeth
            case DATA_FILTER_TYPE_PAETH:
                this->paethFilterType(pImageData, pRowData, rowBytes);
            break;
            // 类型错误
            default:
            break;
        }

        pImageData += rowBytes;
        pRowData += rowBytes;

        char text[100];
        sprintf(text, "filter type:%d, rowIndex:%d 
", filterType, rowIndex);
        OutputDebugString(text);
    }

    int channel = rowBytes / this->m_width;
    if (channel == 4) {
        unsigned int *tmp = (unsigned int *)this->m_imageData;

        for (unsigned short i = 0; i < this->m_height; i++) {
            for (unsigned int j = 0; j < rowBytes; j+=4) {
                unsigned int offset = i * rowBytes + j;

                *tmp++ = RGB_USE_ALPHA(
                    this->m_imageData[offset], 
                    this->m_imageData[offset+1], 
                    this->m_imageData[offset+2],
                    this->m_imageData[offset+3] 
                );
            }
        }
    }
}

/**
 * 默认的过滤方式
 */
void PNG::defaultFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
{
    for (int i = 0; i < rowBytes; i++) {
        *pImageData++ = *pRowData++;
    }
}

/**
 * 当前行相加的过滤方式
 */
void PNG::addCurrentRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
{
    for (int i = 0; i < rowBytes; i++) {
        if (i == 0) {
            memcpy(pImageData, pRowData, 4);
            i += 3;
            pImageData += 4;
            pRowData += 4;
        }
        else {
            *pImageData++ = (unsigned char)(((int)*(pRowData++) + (int)*(pImageData-4)) & 0xFF);
        }
    }
}

/**
 * 前一行相加的过滤方式
 */
void PNG::addUpRowFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
{
    for (int i = 0; i < rowBytes; i++) {
        *pImageData++ = (unsigned char)(((int)*(pRowData++) + (int)*(pImageData-rowBytes)) & 0xFF);
    }
}

/**
 * 平均的过滤方式
 */
void PNG::avergeFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
{
    for (int i = 0; i < rowBytes; i++) {
        int averge = 0;

        if (i <= 3) {
            averge = ((int)*(pImageData-rowBytes)) / 2;

            *pImageData++ = (unsigned char)((averge + (int)*(pRowData++)) & 0xFF);
        }
        else {
            averge = (((int)*(pImageData-4)) + ((int)*(pImageData-rowBytes))) / 2;

            *pImageData++ = (unsigned char)((averge + (int)*(pRowData++)) & 0xFF);
        }
    }
}

/**
 * paeth的过滤方式
 */
int Paeth(int a, int b, int c)
{
    int p  = a + b - c;
    int pa = abs(p - a);
    int pb = abs(p - b);
    int pc = abs(p - c);
    
    int Paeth;
    if(pa <= pb && pa <= pc)
        Paeth = a;
    else if (pb <= pc) 
        Paeth = b;
    else 
        Paeth = c;
    return Paeth ;
}
void PNG::paethFilterType(unsigned char* pImageData, unsigned char* pRowData, int rowBytes)
{
    for (int i = 0; i < rowBytes; i++) {
        if (i <= 3) {
            *pImageData++ = (unsigned char)(((int)*(pRowData++) + (int)*(pImageData-rowBytes)) & 0xFF);
        }
        else {
            unsigned char left = *(pImageData - 4);
            unsigned char up = *(pImageData - rowBytes);
            unsigned char leftUp = *(pImageData - rowBytes - 4);

            int value = Paeth((int)left, (int)up, (int)leftUp);
            
            *pImageData++ = (unsigned char)(((int)*(pRowData++) + value) & 0xFF);
        }
    }
}

/**
 * 解析IDAT数据
 */
void PNG::parseIDATData(DataChunkHeader& dataChunkHeader, FILE* pFile)
{
    // 解压后的图片数据
    unsigned char* imageData = new unsigned char[m_width * m_height * 4];

    int dataLen = this->parseNumber(dataChunkHeader.length, 4);
    // 解压前的图片数据
    unsigned char* data = new unsigned char[dataLen];
    char crc[4];
    // 提取数据
    fread(data, 1, dataLen, pFile);
    fread(crc, 1, 4, pFile);

    // 存放临时的解压数据
    unsigned long decompressDataLen = m_width * m_height * 4 + m_height;
    unsigned char* decompressData = new unsigned char[decompressDataLen];

    z_stream* zStream = new z_stream();
    zStream->next_in = data;
    zStream->next_out = decompressData;

    inflateInit(zStream);

    // 解压数据
    this->decompressData(zStream, data, dataLen, dataLen, pFile);
    // 生成图片数据
    this->generateImageData(decompressData, decompressDataLen);

    /*
    int result = 0;
    // 开始解压数据
    int leftBytesCount = dataLen;
    int avail_out = -1;
    do {
        if (zStream->avail_in == 0) {
            if (avail_out == 0)
                break;
            else {
                if (leftBytesCount == 0) {

                }
            }

            // 导出数据是否超过限制
            if (leftBytesCount > DECOMPRESSION_MAX_BYTES)
                zStream->avail_in = DECOMPRESSION_MAX_BYTES;
            else
                zStream->avail_in = leftBytesCount;

            leftBytesCount = dataLen - zStream->avail_in;
        }
        
        if (avail_out > 0)
            zStream->avail_out = avail_out;
        else
            zStream->avail_out = m_width * 4 + 1;

        result = inflate(zStream, Z_NO_FLUSH);
        if (result != Z_OK)
            break;

        avail_out = zStream->avail_out;
    } while (zStream->avail_in >= 0);
    // 数据解压是否成功
    if (result == Z_STREAM_END) {
        int i = 1;
    }
    */
}

/**
 * 解析IEND数据
 */
void PNG::parseIENDData(DataChunkHeader& dataChunkHeader, FILE *pFile)
{
    char crc[4];
    fread(crc, 1, 4, pFile);
}

/**
 * 解析其他数据
 */
void PNG::parseCommonData(DataChunkHeader& dataChunkHeader, FILE *pFile)
{
    int dataLen = this->parseNumber(dataChunkHeader.length, 4);
    fseek(pFile, dataLen + 4, SEEK_CUR);
}

/**
 * 获取图片宽度
 */
unsigned char* PNG::getImageData()
{
    return this->m_imageData;
}

/**
 * 获取图片宽度
 */
int PNG::getWindth()
{
    return this->m_width;
}

/**
 * 获取图片高度
 */
int PNG::getHeight()
{
    return this->m_height;
}

如果需要绘制图片，可以使用opengl库

参考代码：

glViewport(0, 0, winWidth, winHeight);    

glMatrixMode(GL_PROJECTION);            
glLoadIdentity();                        
glOrtho(0.0f, winWidth - 1.0, 0.0, winHeight - 1.0, -10.0, 10.0);

glMatrixMode(GL_MODELVIEW);    
glLoadIdentity();        

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

glEnable(GL_TEXTURE_2D);

int width = png->getWindth();
int height = png->getHeight();
unsigned char* data = png->getImageData();

GLuint name1;
glGenTextures(1, &name1);
glBindTexture(GL_TEXTURE_2D, name1);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,      GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,      GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,GL_RGBA, GL_UNSIGNED_BYTE, data); 
glBegin(GL_POLYGON);
    glTexCoord2f(1, 1);
    glVertex3d(800, 800, 2);
    glTexCoord2f(0, 1);
    glVertex3d(0, 800, 2);
    glTexCoord2f(0, 0);
    glVertex3d(0, 0, 2);
    glTexCoord2f(1, 0);
    glVertex3d(800, 0, 2);
glEnd();