void
util_format_dxt3_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
{
uint8_t tmp[4];
util_format_dxt3_rgba_fetch(0, src, i, j, tmp);
dst[0] = ubyte_to_float(tmp[0]);
dst[1] = ubyte_to_float(tmp[1]);
dst[2] = ubyte_to_float(tmp[2]);
dst[3] = ubyte_to_float(tmp[3]);
}
void
util_format_rgtc2_unorm_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
{
uint8_t tmp_r, tmp_g;
u_format_unsigned_fetch_texel_rgtc(0, src, i, j, &tmp_r, 2);
u_format_unsigned_fetch_texel_rgtc(0, src + 8, i, j, &tmp_g, 2);
dst[0] = ubyte_to_float(tmp_r);
dst[1] = ubyte_to_float(tmp_g);
dst[2] = 0.0;
dst[3] = 1.0;
}
void
util_format_etc1_rgb8_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
{
struct etc1_block block;
uint8_t tmp[3];
assert(i < 4 && j < 4); /* check i, j against 4x4 block size */
etc1_parse_block(&block, src);
etc1_fetch_texel(&block, i, j, tmp);
dst[0] = ubyte_to_float(tmp[0]);
dst[1] = ubyte_to_float(tmp[1]);
dst[2] = ubyte_to_float(tmp[2]);
dst[3] = 1.0f;
}
void
util_format_etc1_rgb8_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
{
const unsigned bw = 4, bh = 4;
struct etc1_block block;
uint8_t tmp[3];
assert(i < bw && j < bh);
etc1_parse_block(&block, src);
etc1_fetch_texel(&block, i, j, tmp);
dst[0] = ubyte_to_float(tmp[0]);
dst[1] = ubyte_to_float(tmp[1]);
dst[2] = ubyte_to_float(tmp[2]);
dst[3] = 1.0f;
}
void
util_format_rgtc1_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
{
unsigned x, y, i, j;
int block_size = 8;
for(y = 0; y < height; y += 4) {
const uint8_t *src = src_row;
for(x = 0; x < width; x += 4) {
for(j = 0; j < 4; ++j) {
for(i = 0; i < 4; ++i) {
float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
uint8_t tmp_r;
u_format_unsigned_fetch_texel_rgtc(0, src, i, j, &tmp_r, 1);
dst[0] = ubyte_to_float(tmp_r);
dst[1] = 0.0;
dst[2] = 0.0;
dst[3] = 1.0;
}
}
src += block_size;
}
src_row += src_stride;
}
}
static void
logicop_quad(struct quad_stage *qs,
float (*quadColor)[4],
float (*dest)[4])
{
struct softpipe_context *softpipe = qs->softpipe;
ubyte src[4][4], dst[4][4], res[4][4];
uint *src4 = (uint *) src;
uint *dst4 = (uint *) dst;
uint *res4 = (uint *) res;
uint j;
/* convert to ubyte */
for (j = 0; j < 4; j++) { /* loop over R,G,B,A channels */
dst[j][0] = float_to_ubyte(dest[j][0]); /* P0 */
dst[j][1] = float_to_ubyte(dest[j][1]); /* P1 */
dst[j][2] = float_to_ubyte(dest[j][2]); /* P2 */
dst[j][3] = float_to_ubyte(dest[j][3]); /* P3 */
src[j][0] = float_to_ubyte(quadColor[j][0]); /* P0 */
src[j][1] = float_to_ubyte(quadColor[j][1]); /* P1 */
src[j][2] = float_to_ubyte(quadColor[j][2]); /* P2 */
src[j][3] = float_to_ubyte(quadColor[j][3]); /* P3 */
}
switch (softpipe->blend->logicop_func) {
case PIPE_LOGICOP_CLEAR:
for (j = 0; j < 4; j++)
res4[j] = 0;
break;
case PIPE_LOGICOP_NOR:
for (j = 0; j < 4; j++)
res4[j] = ~(src4[j] | dst4[j]);
break;
case PIPE_LOGICOP_AND_INVERTED:
for (j = 0; j < 4; j++)
res4[j] = ~src4[j] & dst4[j];
break;
case PIPE_LOGICOP_COPY_INVERTED:
for (j = 0; j < 4; j++)
res4[j] = ~src4[j];
break;
case PIPE_LOGICOP_AND_REVERSE:
for (j = 0; j < 4; j++)
res4[j] = src4[j] & ~dst4[j];
break;
case PIPE_LOGICOP_INVERT:
for (j = 0; j < 4; j++)
res4[j] = ~dst4[j];
break;
case PIPE_LOGICOP_XOR:
for (j = 0; j < 4; j++)
res4[j] = dst4[j] ^ src4[j];
break;
case PIPE_LOGICOP_NAND:
for (j = 0; j < 4; j++)
res4[j] = ~(src4[j] & dst4[j]);
break;
case PIPE_LOGICOP_AND:
for (j = 0; j < 4; j++)
res4[j] = src4[j] & dst4[j];
break;
case PIPE_LOGICOP_EQUIV:
for (j = 0; j < 4; j++)
res4[j] = ~(src4[j] ^ dst4[j]);
break;
case PIPE_LOGICOP_NOOP:
for (j = 0; j < 4; j++)
res4[j] = dst4[j];
break;
case PIPE_LOGICOP_OR_INVERTED:
for (j = 0; j < 4; j++)
res4[j] = ~src4[j] | dst4[j];
break;
case PIPE_LOGICOP_COPY:
for (j = 0; j < 4; j++)
res4[j] = src4[j];
break;
case PIPE_LOGICOP_OR_REVERSE:
for (j = 0; j < 4; j++)
res4[j] = src4[j] | ~dst4[j];
break;
case PIPE_LOGICOP_OR:
for (j = 0; j < 4; j++)
res4[j] = src4[j] | dst4[j];
break;
case PIPE_LOGICOP_SET:
for (j = 0; j < 4; j++)
res4[j] = ~0;
break;
default:
assert(0);
}
for (j = 0; j < 4; j++) {
quadColor[j][0] = ubyte_to_float(res[j][0]);
quadColor[j][1] = ubyte_to_float(res[j][1]);
quadColor[j][2] = ubyte_to_float(res[j][2]);
quadColor[j][3] = ubyte_to_float(res[j][3]);
}
}
ILboolean PsdGetData(ILimage* image, PSDHEAD *Head, void *Buffer, ILboolean Compressed, ILushort& ChannelNum)
{
ILuint c, x, y, i, Size, ReadResult, NumChan;
ILubyte *Channel = NULL;
ILushort *ShortPtr;
ILuint *ChanLen = NULL;
// Added 01-07-2009: This is needed to correctly load greyscale and
// paletted images.
switch (Head->Mode)
{
case 1:
case 2:
NumChan = 1;
break;
default:
NumChan = 3;
}
Channel = (ILubyte*)ialloc(Head->Width * Head->Height * image->Bpc);
if (Channel == NULL) {
return IL_FALSE;
}
ShortPtr = (ILushort*)Channel;
// @TODO: Add support for this in, though I have yet to run across a .psd
// file that uses this.
if (Compressed && image->Type == IL_UNSIGNED_SHORT) {
il2SetError(IL_FORMAT_NOT_SUPPORTED);
return IL_FALSE;
}
if (!Compressed) {
if (image->Bpc == 1) {
for (c = 0; c < NumChan; c++) {
i = 0;
if (image->io.read(&image->io, Channel, Head->Width * Head->Height, 1) != 1) {
ifree(Channel);
return IL_FALSE;
}
for (y = 0; y < Head->Height * image->Bps; y += image->Bps) {
for (x = 0; x < image->Bps; x += image->Bpp, i++) {
image->Data[y + x + c] = Channel[i];
}
}
}
// Accumulate any remaining channels into a single alpha channel
//@TODO: This needs to be changed for greyscale images.
for (; c < Head->Channels; c++) {
i = 0;
if (image->io.read(&image->io, Channel, Head->Width * Head->Height, 1) != 1) {
ifree(Channel);
return IL_FALSE;
}
for (y = 0; y < Head->Height * image->Bps; y += image->Bps) {
for (x = 0; x < image->Bps; x += image->Bpp, i++) {
float curVal = ubyte_to_float(image->Data[y + x + 3]);
float newVal = ubyte_to_float(Channel[i]);
image->Data[y + x + 3] = float_to_ubyte(curVal * newVal);
}
}
}
}
else { // image->Bpc == 2
for (c = 0; c < NumChan; c++) {
i = 0;
if (image->io.read(&image->io, Channel, Head->Width * Head->Height * 2, 1) != 1) {
ifree(Channel);
return IL_FALSE;
}
image->Bps /= 2;
for (y = 0; y < Head->Height * image->Bps; y += image->Bps) {
for (x = 0; x < image->Bps; x += image->Bpp, i++) {
#ifndef WORDS_BIGENDIAN
iSwapUShort(ShortPtr+i);
#endif
((ILushort*)image->Data)[y + x + c] = ShortPtr[i];
}
}
image->Bps *= 2;
}
// Accumulate any remaining channels into a single alpha channel
//@TODO: This needs to be changed for greyscale images.
for (; c < Head->Channels; c++) {
i = 0;
if (image->io.read(&image->io, Channel, Head->Width * Head->Height * 2, 1) != 1) {
ifree(Channel);
return IL_FALSE;
}
image->Bps /= 2;
for (y = 0; y < Head->Height * image->Bps; y += image->Bps) {
for (x = 0; x < image->Bps; x += image->Bpp, i++) {
float curVal = ushort_to_float(((ILushort*)image->Data)[y + x + 3]);
float newVal = ushort_to_float(ShortPtr[i]);
((ILushort*)image->Data)[y + x + 3] = float_to_ushort(curVal * newVal);
}
}
image->Bps *= 2;
}
}
}
else {
ChanLen = GetCompChanLen(image, Head, ChannelNum);
Size = Head->Width * Head->Height;
for (c = 0; c < NumChan; c++) {
ReadResult = ReadCompressedChannel(image, ChanLen[c], Size, Channel);
if (ReadResult == READ_COMPRESSED_ERROR_FILE_CORRUPT)
goto file_corrupt;
else if (ReadResult == READ_COMPRESSED_ERROR_FILE_READ_ERROR)
goto file_read_error;
i = 0;
for (y = 0; y < Head->Height * image->Bps; y += image->Bps) {
for (x = 0; x < image->Bps; x += image->Bpp, i++) {
image->Data[y + x + c] = Channel[i];
}
}
}
// Initialize the alpha channel to solid
//@TODO: This needs to be changed for greyscale images.
if (Head->Channels >= 4) {
for (y = 0; y < Head->Height * image->Bps; y += image->Bps) {
for (x = 0; x < image->Bps; x += image->Bpp) {
image->Data[y + x + 3] = 255;
}
}
for (; c < Head->Channels; c++) {
ReadResult = ReadCompressedChannel(image, ChanLen[c], Size, Channel);
if (ReadResult == READ_COMPRESSED_ERROR_FILE_CORRUPT)
goto file_corrupt;
else if (ReadResult == READ_COMPRESSED_ERROR_FILE_READ_ERROR)
goto file_read_error;
i = 0;
for (y = 0; y < Head->Height * image->Bps; y += image->Bps) {
for (x = 0; x < image->Bps; x += image->Bpp, i++) {
float curVal = ubyte_to_float(image->Data[y + x + 3]);
float newVal = ubyte_to_float(Channel[i]);
image->Data[y + x + 3] = float_to_ubyte(curVal * newVal);
}
}
}
}
ifree(ChanLen);
}
ifree(Channel);
return IL_TRUE;
file_corrupt:
ifree(ChanLen);
ifree(Channel);
il2SetError(IL_ILLEGAL_FILE_VALUE);
return IL_FALSE;
file_read_error:
ifree(ChanLen);
ifree(Channel);
return IL_FALSE;
}