etc1.cpp File Reference

#include "third_party/etc1/etc1.h"
#include <cstring>

Go to the source code of this file.

Classes
struct	etc_compressed

Functions
static etc1_byte	clamp (int x)
static int	convert4To8 (int b)
static int	convert5To8 (int b)
static int	convert6To8 (int b)
static int	divideBy255 (int d)
static int	convert8To4 (int b)
static int	convert8To5 (int b)
static int	convertDiff (int base, int diff)
static void	decode_subblock (etc1_byte *pOut, int r, int g, int b, const int *table, etc1_uint32 low, bool second, bool flipped)
void	etc1_decode_block (const etc1_byte *pIn, etc1_byte *pOut)
static void	take_best (etc_compressed *a, const etc_compressed *b)
static void	etc_average_colors_subblock (const etc1_byte *pIn, etc1_uint32 inMask, etc1_byte *pColors, bool flipped, bool second)
static int	square (int x)
static etc1_uint32	chooseModifier (const etc1_byte *pBaseColors, const etc1_byte *pIn, etc1_uint32 *pLow, int bitIndex, const int *pModifierTable)
static void	etc_encode_subblock_helper (const etc1_byte *pIn, etc1_uint32 inMask, etc_compressed *pCompressed, bool flipped, bool second, const etc1_byte *pBaseColors, const int *pModifierTable)
static bool	inRange4bitSigned (int color)
static void	etc_encodeBaseColors (etc1_byte *pBaseColors, const etc1_byte *pColors, etc_compressed *pCompressed)
static void	etc_encode_block_helper (const etc1_byte *pIn, etc1_uint32 inMask, const etc1_byte *pColors, etc_compressed *pCompressed, bool flipped)
static void	writeBigEndian (etc1_byte *pOut, etc1_uint32 d)
void	etc1_encode_block (const etc1_byte *pIn, etc1_uint32 inMask, 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)
static void	writeBEUint16 (etc1_byte *pOut, etc1_uint32 data)
static etc1_uint32	readBEUint16 (const etc1_byte *pIn)
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)

Variables
static const int	kModifierTable []
static const int	kLookup [8] = { 0, 1, 2, 3, -4, -3, -2, -1 }
static const char	kMagic [] = { 'P', 'K', 'M', ' ', '1', '0' }
static const etc1_uint32	ETC1_PKM_FORMAT_OFFSET = 6
static const etc1_uint32	ETC1_PKM_ENCODED_WIDTH_OFFSET = 8
static const etc1_uint32	ETC1_PKM_ENCODED_HEIGHT_OFFSET = 10
static const etc1_uint32	ETC1_PKM_WIDTH_OFFSET = 12
static const etc1_uint32	ETC1_PKM_HEIGHT_OFFSET = 14
static const etc1_uint32	ETC1_RGB_NO_MIPMAPS = 0

Function Documentation

chooseModifier()

static etc1_uint32 chooseModifier ( const etc1_byte *  pBaseColors, const etc1_byte *  pIn, etc1_uint32 *  pLow, int  bitIndex, const int *  pModifierTable  )

static

Definition at line 306 of file etc1.cpp.

                                   {
    etc1_uint32 bestScore = ~0;
    int bestIndex = 0;
    int pixelR = pIn[0];
    int pixelG = pIn[1];
    int pixelB = pIn[2];
    int r = pBaseColors[0];
    int g = pBaseColors[1];
    int b = pBaseColors[2];
    for (int i = 0; i < 4; i++) {
        int modifier = pModifierTable[i];
        int decodedG = clamp(g + modifier);
        etc1_uint32 score = (etc1_uint32) (6 * square(decodedG - pixelG));
        if (score >= bestScore) {
            continue;
        }
        int decodedR = clamp(r + modifier);
        score += (etc1_uint32) (3 * square(decodedR - pixelR));
        if (score >= bestScore) {
            continue;
        }
        int decodedB = clamp(b + modifier);
        score += (etc1_uint32) square(decodedB - pixelB);
        if (score < bestScore) {
            bestScore = score;
            bestIndex = i;
        }
    }
    etc1_uint32 lowMask = (((bestIndex >> 1) << 16) | (bestIndex & 1))
            << bitIndex;
    *pLow |= lowMask;
    return bestScore;
}

clamp()

static etc1_byte clamp ( int  x )

inlinestatic

Definition at line 130 of file etc1.cpp.

                                     {
    return (etc1_byte) (x >= 0 ? (x < 255 ? x : 255) : 0);
}

convert4To8()

static int convert4To8 ( int  b )

inlinestatic

Definition at line 135 of file etc1.cpp.

                              {
    int c = b & 0xf;
    return (c << 4) | c;
}

convert5To8()

static int convert5To8 ( int  b )

inlinestatic

Definition at line 141 of file etc1.cpp.

                              {
    int c = b & 0x1f;
    return (c << 3) | (c >> 2);
}

convert6To8()

static int convert6To8 ( int  b )

inlinestatic

Definition at line 147 of file etc1.cpp.

                              {
    int c = b & 0x3f;
    return (c << 2) | (c >> 4);
}

convert8To4()

static int convert8To4 ( int  b )

inlinestatic

Definition at line 158 of file etc1.cpp.

                              {
    int c = b & 0xff;
    return divideBy255(c * 15);
}

convert8To5()

static int convert8To5 ( int  b )

inlinestatic

Definition at line 164 of file etc1.cpp.

                              {
    int c = b & 0xff;
    return divideBy255(c * 31);
}

convertDiff()

static int convertDiff ( int  base, int  diff  )

inlinestatic

Definition at line 170 of file etc1.cpp.

                                           {
    return convert5To8((0x1f & base) + kLookup[0x7 & diff]);
}

decode_subblock()

static void decode_subblock ( etc1_byte *  pOut, int  r, int  g, int  b, const int *  table, etc1_uint32  low, bool  second, bool  flipped  )

static

Definition at line 175 of file etc1.cpp.

                                                    {
    int baseX = 0;
    int baseY = 0;
    if (second) {
        if (flipped) {
            baseY = 2;
        } else {
            baseX = 2;
        }
    }
    for (int i = 0; i < 8; i++) {
        int x, y;
        if (flipped) {
            x = baseX + (i >> 1);
            y = baseY + (i & 1);
        } else {
            x = baseX + (i >> 2);
            y = baseY + (i & 3);
        }
        int k = y + (x * 4);
        int offset = ((low >> k) & 1) | ((low >> (k + 15)) & 2);
        int delta = table[offset];
        etc1_byte* q = pOut + 3 * (x + 4 * y);
        *q++ = clamp(r + delta);
        *q++ = clamp(g + delta);
        *q++ = clamp(b + delta);
    }
}

divideBy255()

static int divideBy255 ( int  d )

inlinestatic

Definition at line 153 of file etc1.cpp.

                              {
    return (d + 128 + (d >> 8)) >> 8;
}

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	inMask,
		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;
}

etc_average_colors_subblock()

static void etc_average_colors_subblock ( const etc1_byte *  pIn, etc1_uint32  inMask, etc1_byte *  pColors, bool  flipped, bool  second  )

static

Definition at line 255 of file etc1.cpp.

                                                       {
    int r = 0;
    int g = 0;
    int b = 0;
 
    if (flipped) {
        int by = 0;
        if (second) {
            by = 2;
        }
        for (int y = 0; y < 2; y++) {
            int yy = by + y;
            for (int x = 0; x < 4; x++) {
                int i = x + 4 * yy;
                if (inMask & (1 << i)) {
                    const etc1_byte* p = pIn + i * 3;
                    r += *(p++);
                    g += *(p++);
                    b += *(p++);
                }
            }
        }
    } else {
        int bx = 0;
        if (second) {
            bx = 2;
        }
        for (int y = 0; y < 4; y++) {
            for (int x = 0; x < 2; x++) {
                int xx = bx + x;
                int i = xx + 4 * y;
                if (inMask & (1 << i)) {
                    const etc1_byte* p = pIn + i * 3;
                    r += *(p++);
                    g += *(p++);
                    b += *(p++);
                }
            }
        }
    }
    pColors[0] = (etc1_byte)((r + 4) >> 3);
    pColors[1] = (etc1_byte)((g + 4) >> 3);
    pColors[2] = (etc1_byte)((b + 4) >> 3);
}

etc_encode_block_helper()

static void etc_encode_block_helper ( const etc1_byte *  pIn, etc1_uint32  inMask, const etc1_byte *  pColors, etc_compressed *  pCompressed, bool  flipped  )

static

Definition at line 438 of file etc1.cpp.

                                                                             {
    pCompressed->score = ~0;
    pCompressed->high = (flipped ? 1 : 0);
    pCompressed->low = 0;
 
    etc1_byte pBaseColors[6];
 
    etc_encodeBaseColors(pBaseColors, pColors, pCompressed);
 
    int originalHigh = pCompressed->high;
 
    const int* pModifierTable = kModifierTable;
    for (int i = 0; i < 8; i++, pModifierTable += 4) {
        etc_compressed temp;
        temp.score = 0;
        temp.high = originalHigh | (i << 5);
        temp.low = 0;
        etc_encode_subblock_helper(pIn, inMask, &temp, flipped, false,
                pBaseColors, pModifierTable);
        take_best(pCompressed, &temp);
    }
    pModifierTable = kModifierTable;
    etc_compressed firstHalf = *pCompressed;
    for (int i = 0; i < 8; i++, pModifierTable += 4) {
        etc_compressed temp;
        temp.score = firstHalf.score;
        temp.high = firstHalf.high | (i << 2);
        temp.low = firstHalf.low;
        etc_encode_subblock_helper(pIn, inMask, &temp, flipped, true,
                pBaseColors + 3, pModifierTable);
        if (i == 0) {
            *pCompressed = temp;
        } else {
            take_best(pCompressed, &temp);
        }
    }
}

etc_encode_subblock_helper()

static void etc_encode_subblock_helper ( const etc1_byte *  pIn, etc1_uint32  inMask, etc_compressed *  pCompressed, bool  flipped, bool  second, const etc1_byte *  pBaseColors, const int *  pModifierTable  )

static

Definition at line 343 of file etc1.cpp.

                                                                 {
    int score = pCompressed->score;
    if (flipped) {
        int by = 0;
        if (second) {
            by = 2;
        }
        for (int y = 0; y < 2; y++) {
            int yy = by + y;
            for (int x = 0; x < 4; x++) {
                int i = x + 4 * yy;
                if (inMask & (1 << i)) {
                    score += chooseModifier(pBaseColors, pIn + i * 3,
                            &pCompressed->low, yy + x * 4, pModifierTable);
                }
            }
        }
    } else {
        int bx = 0;
        if (second) {
            bx = 2;
        }
        for (int y = 0; y < 4; y++) {
            for (int x = 0; x < 2; x++) {
                int xx = bx + x;
                int i = xx + 4 * y;
                if (inMask & (1 << i)) {
                    score += chooseModifier(pBaseColors, pIn + i * 3,
                            &pCompressed->low, y + xx * 4, pModifierTable);
                }
            }
        }
    }
    pCompressed->score = score;
}

etc_encodeBaseColors()

static void etc_encodeBaseColors ( etc1_byte *  pBaseColors, const etc1_byte *  pColors, etc_compressed *  pCompressed  )

static

Definition at line 385 of file etc1.cpp.

                                                               {
    int r1, g1, b1, r2, g2, b2; // 8 bit base colors for sub-blocks
    bool differential;
 
    int r51 = convert8To5(pColors[0]);
    int g51 = convert8To5(pColors[1]);
    int b51 = convert8To5(pColors[2]);
    int r52 = convert8To5(pColors[3]);
    int g52 = convert8To5(pColors[4]);
    int b52 = convert8To5(pColors[5]);
 
    r1 = convert5To8(r51);
    g1 = convert5To8(g51);
    b1 = convert5To8(b51);
 
    int dr = r52 - r51;
    int dg = g52 - g51;
    int db = b52 - b51;
 
    differential = inRange4bitSigned(dr) && inRange4bitSigned(dg)
            && inRange4bitSigned(db);
    if (differential) {
        r2 = convert5To8(r51 + dr);
        g2 = convert5To8(g51 + dg);
        b2 = convert5To8(b51 + db);
        pCompressed->high |= (r51 << 27) | ((7 & dr) << 24) | (g51 << 19)
                | ((7 & dg) << 16) | (b51 << 11) | ((7 & db) << 8) | 2;
    } else {
        int r41 = convert8To4(pColors[0]);
        int g41 = convert8To4(pColors[1]);
        int b41 = convert8To4(pColors[2]);
        int r42 = convert8To4(pColors[3]);
        int g42 = convert8To4(pColors[4]);
        int b42 = convert8To4(pColors[5]);
        r1 = convert4To8(r41);
        g1 = convert4To8(g41);
        b1 = convert4To8(b41);
        r2 = convert4To8(r42);
        g2 = convert4To8(g42);
        b2 = convert4To8(b42);
        pCompressed->high |= (r41 << 28) | (r42 << 24) | (g41 << 20) | (g42
                << 16) | (b41 << 12) | (b42 << 8);
    }
    pBaseColors[0] = r1;
    pBaseColors[1] = g1;
    pBaseColors[2] = b1;
    pBaseColors[3] = r2;
    pBaseColors[4] = g2;
    pBaseColors[5] = b2;
}

inRange4bitSigned()

static bool inRange4bitSigned ( int  color )

static

Definition at line 381 of file etc1.cpp.

                                         {
    return color >= -4 && color <= 3;
}

readBEUint16()

static etc1_uint32 readBEUint16 ( const etc1_byte *  pIn )

static

Definition at line 632 of file etc1.cpp.

                                                      {
    return (pIn[0] << 8) | pIn[1];
}

square()

static int square ( int  x )

inlinestatic

Definition at line 302 of file etc1.cpp.

                         {
    return x * x;
}

take_best()

static void take_best ( etc_compressed *  a, const etc_compressed *  b  )

inlinestatic

Definition at line 248 of file etc1.cpp.

                                                                  {
    if (a->score > b->score) {
        *a = *b;
    }
}

writeBEUint16()

static void writeBEUint16 ( etc1_byte *  pOut, etc1_uint32  data  )

static

Definition at line 627 of file etc1.cpp.

                                                             {
    pOut[0] = (etc1_byte) (data >> 8);
    pOut[1] = (etc1_byte) data;
}

writeBigEndian()

static void writeBigEndian ( etc1_byte *  pOut, etc1_uint32  d  )

static

Definition at line 477 of file etc1.cpp.

                                                           {
    pOut[0] = (etc1_byte) (d >> 24);
    pOut[1] = (etc1_byte)((d >> 16) & 0xFF);
    pOut[2] = (etc1_byte)((d >>  8) & 0xFF);
    pOut[3] = (etc1_byte)((d >>  0) & 0xFF);
}

Variable Documentation

ETC1_PKM_ENCODED_HEIGHT_OFFSET

const etc1_uint32 ETC1_PKM_ENCODED_HEIGHT_OFFSET = 10

static

Definition at line 621 of file etc1.cpp.

ETC1_PKM_ENCODED_WIDTH_OFFSET

const etc1_uint32 ETC1_PKM_ENCODED_WIDTH_OFFSET = 8

static

Definition at line 620 of file etc1.cpp.

ETC1_PKM_FORMAT_OFFSET

const etc1_uint32 ETC1_PKM_FORMAT_OFFSET = 6

static

Definition at line 619 of file etc1.cpp.

ETC1_PKM_HEIGHT_OFFSET

const etc1_uint32 ETC1_PKM_HEIGHT_OFFSET = 14

static

Definition at line 623 of file etc1.cpp.

ETC1_PKM_WIDTH_OFFSET

const etc1_uint32 ETC1_PKM_WIDTH_OFFSET = 12

static

Definition at line 622 of file etc1.cpp.

ETC1_RGB_NO_MIPMAPS

const etc1_uint32 ETC1_RGB_NO_MIPMAPS = 0

static

Definition at line 625 of file etc1.cpp.

kLookup

const int kLookup[8] = { 0, 1, 2, 3, -4, -3, -2, -1 }

static

Definition at line 128 of file etc1.cpp.

kMagic

const char kMagic[] = { 'P', 'K', 'M', ' ', '1', '0' }

static

Definition at line 617 of file etc1.cpp.

kModifierTable

const int kModifierTable[]

static

Initial value:

= {
2, 8, -2, -8,
5, 17, -5, -17,
9, 29, -9, -29,
13, 42, -13, -42,
18, 60, -18, -60,
24, 80, -24, -80,
33, 106, -33, -106,
47, 183, -47, -183 }

Definition at line 118 of file etc1.cpp.