etc1.h File Reference

Go to the source code of this file.

Macros
#define	ETC1_ENCODED_BLOCK_SIZE   8
#define	ETC1_DECODED_BLOCK_SIZE   48
#define	ETC1_RGB8_OES   0x8D64
#define	ETC_PKM_HEADER_SIZE   16

Typedefs
typedef unsigned char	etc1_byte
typedef int	etc1_bool
typedef unsigned int	etc1_uint32

Functions
void	etc1_encode_block (const etc1_byte *pIn, etc1_uint32 validPixelMask, etc1_byte *pOut)
void	etc1_decode_block (const etc1_byte *pIn, etc1_byte *pOut)
etc1_uint32	etc1_get_encoded_data_size (etc1_uint32 width, etc1_uint32 height)
int	etc1_encode_image (const etc1_byte *pIn, etc1_uint32 width, etc1_uint32 height, etc1_uint32 pixelSize, etc1_uint32 stride, etc1_byte *pOut)
int	etc1_decode_image (const etc1_byte *pIn, etc1_byte *pOut, etc1_uint32 width, etc1_uint32 height, etc1_uint32 pixelSize, etc1_uint32 stride)
void	etc1_pkm_format_header (etc1_byte *pHeader, etc1_uint32 width, etc1_uint32 height)
etc1_bool	etc1_pkm_is_valid (const etc1_byte *pHeader)
etc1_uint32	etc1_pkm_get_width (const etc1_byte *pHeader)
etc1_uint32	etc1_pkm_get_height (const etc1_byte *pHeader)

Macro Definition Documentation

ETC1_DECODED_BLOCK_SIZE

#define ETC1_DECODED_BLOCK_SIZE   48

Definition at line 27 of file etc1.h.

ETC1_ENCODED_BLOCK_SIZE

#define ETC1_ENCODED_BLOCK_SIZE   8

Definition at line 26 of file etc1.h.

ETC1_RGB8_OES

#define ETC1_RGB8_OES   0x8D64

Definition at line 30 of file etc1.h.

ETC_PKM_HEADER_SIZE

#define ETC_PKM_HEADER_SIZE   16

Definition at line 92 of file etc1.h.

Typedef Documentation

etc1_bool

typedef int etc1_bool

Definition at line 34 of file etc1.h.

etc1_byte

typedef unsigned char etc1_byte

Definition at line 33 of file etc1.h.

etc1_uint32

typedef unsigned int etc1_uint32

Definition at line 35 of file etc1.h.

Function Documentation

etc1_decode_block()

void etc1_decode_block	(	const etc1_byte *	pIn,
		etc1_byte *	pOut
	)

Definition at line 208 of file etc1.cpp.

                                                              {
    etc1_uint32 high = (pIn[0] << 24) | (pIn[1] << 16) | (pIn[2] << 8) | pIn[3];
    etc1_uint32 low = (pIn[4] << 24) | (pIn[5] << 16) | (pIn[6] << 8) | pIn[7];
    int r1, r2, g1, g2, b1, b2;
    if (high & 2) {
        // differential
        int rBase = high >> 27;
        int gBase = high >> 19;
        int bBase = high >> 11;
        r1 = convert5To8(rBase);
        r2 = convertDiff(rBase, high >> 24);
        g1 = convert5To8(gBase);
        g2 = convertDiff(gBase, high >> 16);
        b1 = convert5To8(bBase);
        b2 = convertDiff(bBase, high >> 8);
    } else {
        // not differential
        r1 = convert4To8(high >> 28);
        r2 = convert4To8(high >> 24);
        g1 = convert4To8(high >> 20);
        g2 = convert4To8(high >> 16);
        b1 = convert4To8(high >> 12);
        b2 = convert4To8(high >> 8);
    }
    int tableIndexA = 7 & (high >> 5);
    int tableIndexB = 7 & (high >> 2);
    const int* tableA = kModifierTable + tableIndexA * 4;
    const int* tableB = kModifierTable + tableIndexB * 4;
    bool flipped = (high & 1) != 0;
    decode_subblock(pOut, r1, g1, b1, tableA, low, false, flipped);
    decode_subblock(pOut, r2, g2, b2, tableB, low, true, flipped);
}

etc1_decode_image()

int etc1_decode_image	(	const etc1_byte *	pIn,
		etc1_byte *	pOut,
		etc1_uint32	width,
		etc1_uint32	height,
		etc1_uint32	pixelSize,
		etc1_uint32	stride
	)

Definition at line 573 of file etc1.cpp.

                                                   {
    if (pixelSize < 2 || pixelSize > 3) {
        return -1;
    }
    etc1_byte block[ETC1_DECODED_BLOCK_SIZE];
 
    etc1_uint32 encodedWidth = (width + 3) & ~3;
    etc1_uint32 encodedHeight = (height + 3) & ~3;
 
    for (etc1_uint32 y = 0; y < encodedHeight; y += 4) {
        etc1_uint32 yEnd = height - y;
        if (yEnd > 4) {
            yEnd = 4;
        }
        for (etc1_uint32 x = 0; x < encodedWidth; x += 4) {
            etc1_uint32 xEnd = width - x;
            if (xEnd > 4) {
                xEnd = 4;
            }
            etc1_decode_block(pIn, block);
            pIn += ETC1_ENCODED_BLOCK_SIZE;
            for (etc1_uint32 cy = 0; cy < yEnd; cy++) {
                const etc1_byte* q = block + (cy * 4) * 3;
                etc1_byte* p = pOut + pixelSize * x + stride * (y + cy);
                if (pixelSize == 3) {
                    memcpy(p, q, xEnd * 3);
                } else {
                    for (etc1_uint32 cx = 0; cx < xEnd; cx++) {
                        etc1_byte r = *q++;
                        etc1_byte g = *q++;
                        etc1_byte b = *q++;
                        etc1_uint32 pixel = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
                        *p++ = (etc1_byte) pixel;
                        *p++ = (etc1_byte) (pixel >> 8);
                    }
                }
            }
        }
    }
    return 0;
}

etc1_encode_block()

void etc1_encode_block	(	const etc1_byte *	pIn,
		etc1_uint32	validPixelMask,
		etc1_byte *	pOut
	)

Definition at line 489 of file etc1.cpp.

                         {
    etc1_byte colors[6];
    etc1_byte flippedColors[6];
    etc_average_colors_subblock(pIn, inMask, colors, false, false);
    etc_average_colors_subblock(pIn, inMask, colors + 3, false, true);
    etc_average_colors_subblock(pIn, inMask, flippedColors, true, false);
    etc_average_colors_subblock(pIn, inMask, flippedColors + 3, true, true);
 
    etc_compressed a, b;
    etc_encode_block_helper(pIn, inMask, colors, &a, false);
    etc_encode_block_helper(pIn, inMask, flippedColors, &b, true);
    take_best(&a, &b);
    writeBigEndian(pOut, a.high);
    writeBigEndian(pOut + 4, a.low);
}

etc1_encode_image()

int etc1_encode_image	(	const etc1_byte *	pIn,
		etc1_uint32	width,
		etc1_uint32	height,
		etc1_uint32	pixelSize,
		etc1_uint32	stride,
		etc1_byte *	pOut
	)

Definition at line 517 of file etc1.cpp.

                                                                    {
    if (pixelSize < 2 || pixelSize > 3) {
        return -1;
    }
    static const unsigned short kYMask[] = { 0x0, 0xf, 0xff, 0xfff, 0xffff };
    static const unsigned short kXMask[] = { 0x0, 0x1111, 0x3333, 0x7777,
            0xffff };
    etc1_byte block[ETC1_DECODED_BLOCK_SIZE];
    etc1_byte encoded[ETC1_ENCODED_BLOCK_SIZE];
 
    etc1_uint32 encodedWidth = (width + 3) & ~3;
    etc1_uint32 encodedHeight = (height + 3) & ~3;
 
    for (etc1_uint32 y = 0; y < encodedHeight; y += 4) {
        etc1_uint32 yEnd = height - y;
        if (yEnd > 4) {
            yEnd = 4;
        }
        int ymask = kYMask[yEnd];
        for (etc1_uint32 x = 0; x < encodedWidth; x += 4) {
            etc1_uint32 xEnd = width - x;
            if (xEnd > 4) {
                xEnd = 4;
            }
            int mask = ymask & kXMask[xEnd];
            for (etc1_uint32 cy = 0; cy < yEnd; cy++) {
                etc1_byte* q = block + (cy * 4) * 3;
                const etc1_byte* p = pIn + pixelSize * x + stride * (y + cy);
                if (pixelSize == 3) {
                    memcpy(q, p, xEnd * 3);
                } else {
                    for (etc1_uint32 cx = 0; cx < xEnd; cx++) {
                        int pixel = (p[1] << 8) | p[0];
                        *q++ = convert5To8(pixel >> 11);
                        *q++ = convert6To8(pixel >> 5);
                        *q++ = convert5To8(pixel);
                        p += pixelSize;
                    }
                }
            }
            etc1_encode_block(block, mask, encoded);
            memcpy(pOut, encoded, sizeof(encoded));
            pOut += sizeof(encoded);
        }
    }
    return 0;
}

etc1_get_encoded_data_size()

etc1_uint32 etc1_get_encoded_data_size	(	etc1_uint32	width,
		etc1_uint32	height
	)

Definition at line 508 of file etc1.cpp.

                                                                              {
    return (((width + 3) & ~3) * ((height + 3) & ~3)) >> 1;
}

etc1_pkm_format_header()

void etc1_pkm_format_header	(	etc1_byte *	pHeader,
		etc1_uint32	width,
		etc1_uint32	height
	)

Definition at line 638 of file etc1.cpp.

                                                                                       {
    memcpy(pHeader, kMagic, sizeof(kMagic));
    etc1_uint32 encodedWidth = (width + 3) & ~3;
    etc1_uint32 encodedHeight = (height + 3) & ~3;
    writeBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET, ETC1_RGB_NO_MIPMAPS);
    writeBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFFSET, encodedWidth);
    writeBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET, encodedHeight);
    writeBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET, width);
    writeBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET, height);
}

etc1_pkm_get_height()

etc1_uint32 etc1_pkm_get_height

(

const etc1_byte *

pHeader

)

Definition at line 673 of file etc1.cpp.

                                                         {
    return readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET);
}

etc1_pkm_get_width()

etc1_uint32 etc1_pkm_get_width

(

const etc1_byte *

pHeader

)

Definition at line 667 of file etc1.cpp.

                                                         {
    return readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET);
}

etc1_pkm_is_valid()

etc1_bool etc1_pkm_is_valid

(

const etc1_byte *

pHeader

)

Definition at line 651 of file etc1.cpp.

                                                      {
    if (memcmp(pHeader, kMagic, sizeof(kMagic))) {
        return false;
    }
    etc1_uint32 format = readBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET);
    etc1_uint32 encodedWidth = readBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFFSET);
    etc1_uint32 encodedHeight = readBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET);
    etc1_uint32 width = readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET);
    etc1_uint32 height = readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET);
    return format == ETC1_RGB_NO_MIPMAPS &&
            encodedWidth >= width && encodedWidth - width < 4 &&
            encodedHeight >= height && encodedHeight - height < 4;
}