From 34692ab826abc8f8faa61bdb2280b742424528f1 Mon Sep 17 00:00:00 2001 From: "Jasper St. Pierre" Date: Sat, 7 Dec 2013 15:14:29 -0500 Subject: Remove unnecessary Src/ folders --- .../Core/VideoBackends/Software/TextureEncoder.cpp | 1435 ++++++++++++++++++++ 1 file changed, 1435 insertions(+) create mode 100644 Source/Core/VideoBackends/Software/TextureEncoder.cpp (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp new file mode 100644 index 0000000000..07bb162cd6 --- /dev/null +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -0,0 +1,1435 @@ +// Copyright 2013 Dolphin Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include "TextureEncoder.h" +#include "EfbInterface.h" +#include "BPMemLoader.h" + +#include "LookUpTables.h" +#include "TextureDecoder.h" + + +namespace TextureEncoder +{ + +inline void RGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) +{ + u32 srcColor = *(u32*)src; + a = Convert6To8(srcColor & 0x3f); + b = Convert6To8((srcColor >> 6) & 0x3f); + g = Convert6To8((srcColor >> 12)& 0x3f); + r = Convert6To8((srcColor >> 18)& 0x3f); +} + +inline void RGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +{ + u32 srcColor = *(u32*)src; + b = Convert6To8((srcColor >> 6) & 0x3f); + g = Convert6To8((srcColor >> 12)& 0x3f); + r = Convert6To8((srcColor >> 18)& 0x3f); +} + +inline u8 RGB8_to_I(u8 r, u8 g, u8 b) +{ + // values multiplied by 256 to keep math integer + u16 val = 4096 + 66 * r + 129 * g + 25 * b; + return val >> 8; +} + +// box filter sampling averages 4 samples with the source texel being the top left of the box +// components are scaled to the range 0-255 after all samples are taken + +inline void boxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) +{ + u16 r16 = 0, g16 = 0, b16 = 0, a16 = 0; + + for (int y = 0; y < 2; y++) + { + for (int x = 0; x < 2; x++) + { + u32 srcColor = *(u32*)src; + + a16 += srcColor & 0x3f; + b16 += (srcColor >> 6) & 0x3f; + g16 += (srcColor >> 12) & 0x3f; + r16 += (srcColor >> 18) & 0x3f; + + src += 3; // move to next pixel + } + src += (640 - 2) * 3; // move to next line + } + + r = r16 + (r16 >> 6); + g = g16 + (g16 >> 6); + b = b16 + (b16 >> 6); + a = a16 + (a16 >> 6); +} + +inline void boxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +{ + u16 r16 = 0, g16 = 0, b16 = 0; + + for (int y = 0; y < 2; y++) + { + for (int x = 0; x < 2; x++) + { + u32 srcColor = *(u32*)src; + + b16 += (srcColor >> 6) & 0x3f; + g16 += (srcColor >> 12) & 0x3f; + r16 += (srcColor >> 18) & 0x3f; + + src += 3; // move to next pixel + } + src += (640 - 2) * 3; // move to next line + } + + r = r16 + (r16 >> 6); + g = g16 + (g16 >> 6); + b = b16 + (b16 >> 6); +} + +inline void boxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) +{ + u16 x16 = 0; + + for (int y = 0; y < 2; y++) + { + for (int x = 0; x < 2; x++) + { + u32 srcColor = *(u32*)src; + + x16 += (srcColor >> shift) & 0x3f; + + src += 3; // move to next pixel + } + src += (640 - 2) * 3; // move to next line + } + + x8 = x16 + (x16 >> 6); +} + +inline void boxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2) +{ + u16 x16_1 = 0; + u16 x16_2 = 0; + + for (int y = 0; y < 2; y++) + { + for (int x = 0; x < 2; x++) + { + u32 srcColor = *(u32*)src; + + x16_1 += (srcColor >> shift1) & 0x3f; + x16_2 += (srcColor >> shift2) & 0x3f; + + src += 3; // move to next pixel + } + src += (640 - 2) * 3; // move to next line + } + + x1 = x16_1 + (x16_1 >> 6); + x2 = x16_2 + (x16_2 >> 6); +} + +inline void boxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +{ + u16 r16 = 0, g16 = 0, b16 = 0; + + for (int y = 0; y < 2; y++) + { + for (int x = 0; x < 2; x++) + { + b16 += src[0]; + g16 += src[1]; + r16 += src[2]; + + src += 3; // move to next pixel + } + src += (640 - 2) * 3; // move to next line + } + + r = r16 >> 2; + g = g16 >> 2; + b = b16 >> 2; +} + +inline void boxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) +{ + u16 x16 = 0; + + for (int y = 0; y < 2; y++) + { + for (int x = 0; x < 2; x++) + { + + x16 += src[comp]; + + src += 3; // move to next pixel + } + src += (640 - 2) * 3; // move to next line + } + + x8 = x16 >> 2; +} + +inline void boxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int comp2) +{ + u16 x16_1 = 0; + u16 x16_2 = 0; + + for (int y = 0; y < 2; y++) + { + for (int x = 0; x < 2; x++) + { + + x16_1 += src[comp1]; + x16_2 += src[comp2]; + + src += 3; // move to next pixel + } + src += (640 - 2) * 3; // move to next line + } + + x1 = x16_1 >> 2; + x2 = x16_2 >> 2; +} + +void SetBlockDimensions(int blkWidthLog2, int blkHeightLog2, u16 &sBlkCount, u16 &tBlkCount, u16 &sBlkSize, u16 &tBlkSize) +{ + // if half_scale is 1 then the size is cut in half + u32 width = bpmem.copyTexSrcWH.x >> bpmem.triggerEFBCopy.half_scale; + u32 height = bpmem.copyTexSrcWH.y >> bpmem.triggerEFBCopy.half_scale; + + sBlkCount = (width >> blkWidthLog2) + 1; + tBlkCount = (height >> blkHeightLog2) + 1; + + sBlkSize = 1 << blkWidthLog2; + tBlkSize = 1 << blkHeightLog2; +} + +void SetSpans(int sBlkSize, int tBlkSize, s32 &tSpan, s32 &sBlkSpan, s32 &tBlkSpan, s32 &writeStride) +{ + // width is 1 less than the number of pixels of width + u32 width = bpmem.copyTexSrcWH.x >> bpmem.triggerEFBCopy.half_scale; + u32 alignedWidth = (width + sBlkSize) & (~(sBlkSize-1)); + + u32 readStride = 3 << bpmem.triggerEFBCopy.half_scale; + + tSpan = (640 - sBlkSize) * readStride; // bytes to advance src pointer after each row of texels in a block + sBlkSpan = ((-640 * tBlkSize) + sBlkSize) * readStride; // bytes to advance src pointer after each block + tBlkSpan = ((640 * tBlkSize) - alignedWidth) * readStride; // bytes to advance src pointer after each row of blocks + + writeStride = bpmem.copyMipMapStrideChannels * 32; +} + +#define ENCODE_LOOP_BLOCKS \ + for (int tBlk = 0; tBlk < tBlkCount; tBlk++) { \ + dst = dstBlockStart; \ + for (int sBlk = 0; sBlk < sBlkCount; sBlk++) { \ + for (int t = 0; t < tBlkSize; t++) { \ + for (int s = 0; s < sBlkSize; s++) { \ + + +#define ENCODE_LOOP_SPANS \ + } \ + src += tSpan; \ + } \ + src += sBlkSpan; \ + } \ + src += tBlkSpan; \ + dstBlockStart += writeStride; \ + } \ + +#define ENCODE_LOOP_SPANS2 \ + } \ + src += tSpan; \ + } \ + src += sBlkSpan; \ + dst += 32; \ + } \ + src += tBlkSpan; \ + dstBlockStart += writeStride; \ + } \ + +void EncodeRGBA6(u8 *dst, u8 *src, u32 format) +{ + u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; + s32 tSpan, sBlkSpan, tBlkSpan, writeStride; + u8 r, g, b, a; + u32 readStride = 3; + u8 *dstBlockStart = dst; + + switch(format) + { + case GX_TF_I4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + RGBA_to_RGB8(src, r, g, b); + src += readStride; + *dst = RGB8_to_I(r, g, b) & 0xf0; + + RGBA_to_RGB8(src, r, g, b); + src += readStride; + *dst |= RGB8_to_I(r, g, b) >> 4; + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_I8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + RGBA_to_RGB8(src, r, g, b); + src += readStride; + *dst++ = RGB8_to_I(r, g, b); + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + RGBA_to_RGBA8(src, r, g, b, a); + src += readStride; + *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4); + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + RGBA_to_RGBA8(src, r, g, b, a); + src += readStride; + *dst++ = a; + *dst++ = RGB8_to_I(r, g, b); + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB565: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + src += readStride; + + u16 val = ((srcColor >> 8) & 0xf800) | ((srcColor >> 7) & 0x07e0) | ((srcColor >> 7) & 0x001e); + *(u16*)dst = Common::swap16(val); + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB5A3: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + src += readStride; + + u16 alpha = (srcColor << 9) & 0x7000; + u16 val; + if (alpha == 0x7000) // 555 + val = 0x8000 | ((srcColor >> 9) & 0x7c00) | ((srcColor >> 8) & 0x03e0) | ((srcColor >> 7) & 0x001e); + else // 4443 + val = alpha | ((srcColor >> 12) & 0x0f00) | ((srcColor >> 10) & 0x00f0) | ((srcColor >> 8) & 0x000f); + + *(u16*)dst = Common::swap16(val); + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGBA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + RGBA_to_RGBA8(src, dst[1], dst[32], dst[33], dst[0]); + src += readStride; + dst += 2; + } + ENCODE_LOOP_SPANS2 + break; + + case GX_CTF_R4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + src += readStride; + *dst = (srcColor >> 16) & 0xf0; + + srcColor = *(u32*)src; + src += readStride; + *dst |= (srcColor >> 20) & 0x0f; + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + src += readStride; + *dst++ = ((srcColor << 2) & 0xf0) | ((srcColor >> 20) & 0x0f); + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + src += readStride; + *dst++ = Convert6To8(srcColor & 0x3f); + *dst++ = Convert6To8((srcColor >> 18) & 0x3f); + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_A8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + *dst++ = Convert6To8(srcColor & 0x3f); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_R8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + *dst++ = Convert6To8((srcColor >> 18) & 0x3f); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_G8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + *dst++ = Convert6To8((srcColor >> 12) & 0x3f); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_B8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + *dst++ = Convert6To8((srcColor >> 6) & 0x3f); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RG8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + src += readStride; + *dst++ = Convert6To8((srcColor >> 12) & 0x3f); + *dst++ = Convert6To8((srcColor >> 18) & 0x3f); + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_GB8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u32 srcColor = *(u32*)src; + src += readStride; + *dst++ = Convert6To8((srcColor >> 6) & 0x3f); + *dst++ = Convert6To8((srcColor >> 12) & 0x3f); + } + ENCODE_LOOP_SPANS + break; + + default: + PanicAlert("Unknown texture copy format: 0x%x\n", format); + break; + } +} + + +void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) +{ + u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; + s32 tSpan, sBlkSpan, tBlkSpan, writeStride; + u8 r, g, b, a; + u32 readStride = 6; + u8 *dstBlockStart = dst; + + switch(format) + { + case GX_TF_I4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_RGB8(src, r, g, b); + src += readStride; + *dst = RGB8_to_I(r, g, b) & 0xf0; + + boxfilterRGBA_to_RGB8(src, r, g, b); + src += readStride; + *dst |= RGB8_to_I(r, g, b) >> 4; + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_I8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_RGB8(src, r, g, b); + src += readStride; + *dst++ = RGB8_to_I(r, g, b); + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_RGBA8(src, r, g, b, a); + src += readStride; + *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4); + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_RGBA8(src, r, g, b, a); + src += readStride; + *dst++ = a; + *dst++ = RGB8_to_I(r, g, b); + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB565: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_RGB8(src, r, g, b); + src += readStride; + + u16 val = ((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | ((b >> 3) & 0x001e); + *(u16*)dst = Common::swap16(val); + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB5A3: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_RGBA8(src, r, g, b, a); + src += readStride; + + u16 val; + if (a >= 224) // 5551 + val = 0x8000 | ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001e); + else // 4443 + val = ((a << 7) & 0x7000) | ((r << 4) & 0x0f00) | (g & 0x00f0) | ((b >> 4) & 0x000f); + + *(u16*)dst = Common::swap16(val); + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGBA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_RGBA8(src, dst[1], dst[32], dst[33], dst[0]); + src += readStride; + dst += 2; + } + ENCODE_LOOP_SPANS2 + break; + + case GX_CTF_R4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_x8(src, r, 18); + src += readStride; + *dst = r & 0xf0; + + boxfilterRGBA_to_x8(src, r, 18); + src += readStride; + *dst |= r >> 4; + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_xx8(src, r, a, 18, 0); + src += readStride; + *dst++ = (a & 0xf0) | (r >> 4); + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_xx8(src, r, a, 18, 0); + src += readStride; + *dst++ = a; + *dst++ = r; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_A8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_x8(src, a, 0); + *dst++ = a; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_R8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_x8(src, r, 18); + *dst++ = r; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_G8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_x8(src, g, 12); + *dst++ = g; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_B8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_x8(src, b, 6); + *dst++ = b; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RG8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_xx8(src, r, g, 18, 12); + src += readStride; + *dst++ = g; + *dst++ = r; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_GB8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGBA_to_xx8(src, g, b, 12, 6); + src += readStride; + *dst++ = b; + *dst++ = g; + } + ENCODE_LOOP_SPANS + break; + + default: + PanicAlert("Unknown texture copy format: 0x%x\n", format); + break; + } +} + +void EncodeRGB8(u8 *dst, u8 *src, u32 format) +{ + u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; + s32 tSpan, sBlkSpan, tBlkSpan, writeStride; + u32 readStride = 3; + u8 *dstBlockStart = dst; + + switch(format) + { + case GX_TF_I4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + *dst = RGB8_to_I(src[2], src[1], src[0]) & 0xf0; + src += readStride; + + *dst |= RGB8_to_I(src[2], src[1], src[0]) >> 4; + src += readStride; + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_I8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = RGB8_to_I(src[2], src[1], src[0]); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = 0xf0 | (RGB8_to_I(src[2], src[1], src[0]) >> 4); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = 0xff; + *dst++ = RGB8_to_I(src[2], src[1], src[0]); + + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB565: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u16 val = ((src[2] << 8) & 0xf800) | ((src[1] << 3) & 0x07e0) | ((src[0] >> 3) & 0x001e); + *(u16*)dst = Common::swap16(val); + src += readStride; + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB5A3: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + u16 val = 0x8000 | ((src[2] << 7) & 0x7c00) | ((src[1] << 2) & 0x03e0) | ((src[0] >> 3) & 0x001e); + *(u16*)dst = Common::swap16(val); + src += readStride; + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGBA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + dst[0] = 0xff; + dst[1] = src[2]; + dst[32] = src[1]; + dst[33] = src[0]; + src += readStride; + dst += 2; + } + ENCODE_LOOP_SPANS2 + break; + + case GX_CTF_R4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + *dst = src[2] & 0xf0; + src += readStride; + + *dst |= src[2] >> 4; + src += readStride; + + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = 0xf0 | (src[2] >> 4); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = 0xff; + *dst++ = src[2]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_A8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = 0xff; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_R8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[2]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_G8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[1]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_B8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[0]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RG8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[1]; + *dst++ = src[2]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_GB8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[0]; + *dst++ = src[1]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + default: + PanicAlert("Unknown texture copy format: 0x%x\n", format); + break; + } +} + +void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) +{ + u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; + s32 tSpan, sBlkSpan, tBlkSpan, writeStride; + u8 r, g, b; + u32 readStride = 6; + u8 *dstBlockStart = dst; + + switch(format) + { + case GX_TF_I4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, r, g, b); + *dst = RGB8_to_I(r, g, b) & 0xf0; + src += readStride; + + boxfilterRGB_to_RGB8(src, r, g, b); + *dst |= RGB8_to_I(r, g, b) >> 4; + src += readStride; + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_I8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, r, g, b); + *dst++ = RGB8_to_I(r, g, b); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, r, g, b); + *dst++ = 0xf0 | (RGB8_to_I(r, g, b) >> 4); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_IA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, r, g, b); + *dst++ = 0xff; + *dst++ = RGB8_to_I(r, g, b); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB565: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, r, g, b); + u16 val = ((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | ((b >> 3) & 0x001e); + *(u16*)dst = Common::swap16(val); + src += readStride; + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGB5A3: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, r, g, b); + u16 val = 0x8000 | ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001e); + *(u16*)dst = Common::swap16(val); + src += readStride; + dst+=2; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_RGBA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, r, g, b); + dst[0] = 0xff; + dst[1] = r; + dst[32] = g; + dst[33] = b; + src += readStride; + dst += 2; + } + ENCODE_LOOP_SPANS2 + break; + + case GX_CTF_R4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, r, 2); + *dst = r & 0xf0; + src += readStride; + + boxfilterRGB_to_x8(src, r, 2); + *dst |= r >> 4; + src += readStride; + + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA4: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, r, 2); + *dst++ = 0xf0 | (r >> 4); + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RA8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, r, 2); + *dst++ = 0xff; + *dst++ = r; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_A8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = 0xff; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_R8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, r, 2); + *dst++ = r; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_G8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, g, 1); + *dst++ = g; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_B8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, b, 0); + *dst++ = b; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_RG8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_xx8(src, r, g, 2, 1); + *dst++ = g; + *dst++ = r; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_GB8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_xx8(src, g, b, 1, 0); + *dst++ = b; + *dst++ = g; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + default: + PanicAlert("Unknown texture copy format: 0x%x\n", format); + break; + } +} + +void EncodeZ24(u8 *dst, u8 *src, u32 format) +{ + u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; + s32 tSpan, sBlkSpan, tBlkSpan, writeStride; + u32 readStride = 3; + u8 *dstBlockStart = dst; + + switch(format) + { + case GX_TF_Z8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[2]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_Z16: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[1]; + *dst++ = src[2]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_Z24X8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + dst[0] = 0xff; + dst[1] = src[2]; + dst[32] = src[1]; + dst[33] = src[0]; + src += readStride; + dst += 2; + } + ENCODE_LOOP_SPANS2 + break; + + case GX_CTF_Z4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + *dst = src[2] & 0xf0; + src += readStride; + + *dst |= src[2] >> 4; + src += readStride; + + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_Z8M: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[1]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_Z8L: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[0]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_Z16L: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + *dst++ = src[0]; + *dst++ = src[1]; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + default: + PanicAlert("Unknown texture copy format: 0x%x\n", format); + break; + } +} + +void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) +{ + u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; + s32 tSpan, sBlkSpan, tBlkSpan, writeStride; + u32 readStride = 6; + u8 r, g, b; + u8 *dstBlockStart = dst; + + switch(format) + { + case GX_TF_Z8: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, b, 2); + *dst++ = b; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_Z16: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_xx8(src, g, b, 1, 2); + *dst++ = b; + *dst++ = g; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_TF_Z24X8: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_RGB8(src, dst[33], dst[32], dst[1]); + dst[0] = 255; + src += readStride; + dst += 2; + } + ENCODE_LOOP_SPANS2 + break; + + case GX_CTF_Z4: + SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + sBlkSize /= 2; + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, b, 2); + *dst = b & 0xf0; + src += readStride; + + boxfilterRGB_to_x8(src, b, 2); + *dst |= b >> 4; + src += readStride; + + dst++; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_Z8M: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, g, 1); + *dst++ = g; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_Z8L: + SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_x8(src, r, 0); + *dst++ = r; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + case GX_CTF_Z16L: + SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); + SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + ENCODE_LOOP_BLOCKS + { + boxfilterRGB_to_xx8(src, r, g, 0, 1); + *dst++ = g; + *dst++ = r; + src += readStride; + } + ENCODE_LOOP_SPANS + break; + + default: + PanicAlert("Unknown texture copy format: 0x%x\n", format); + break; + } +} + +void Encode(u8 *dest_ptr) +{ + int pixelformat = bpmem.zcontrol.pixel_format; + bool bFromZBuffer = pixelformat == PIXELFMT_Z24; + bool bIsIntensityFmt = bpmem.triggerEFBCopy.intensity_fmt > 0; + u32 copyfmt = ((bpmem.triggerEFBCopy.target_pixel_format / 2) + ((bpmem.triggerEFBCopy.target_pixel_format & 1) * 8)); + + // pack copy format information into a single variable + u32 format = copyfmt; + if (bFromZBuffer) + { + format |= _GX_TF_ZTF; + if (copyfmt == 11) + format = GX_TF_Z16; + else if (format < GX_TF_Z8 || format > GX_TF_Z24X8) + format |= _GX_TF_CTF; + } + else + if (copyfmt > GX_TF_RGBA8 || (copyfmt < GX_TF_RGB565 && !bIsIntensityFmt)) + format |= _GX_TF_CTF; + + u8 *src = EfbInterface::GetPixelPointer(bpmem.copyTexSrcXY.x, bpmem.copyTexSrcXY.y, bFromZBuffer); + + if (bpmem.triggerEFBCopy.half_scale) + { + if (pixelformat == PIXELFMT_RGBA6_Z24) + EncodeRGBA6halfscale(dest_ptr, src, format); + else if (pixelformat == PIXELFMT_RGB8_Z24) + EncodeRGB8halfscale(dest_ptr, src, format); + else if (pixelformat == PIXELFMT_RGB565_Z16) // not supported + EncodeRGB8halfscale(dest_ptr, src, format); + else if (pixelformat == PIXELFMT_Z24) + EncodeZ24halfscale(dest_ptr, src, format); + } + else + { + if (pixelformat == PIXELFMT_RGBA6_Z24) + EncodeRGBA6(dest_ptr, src, format); + else if (pixelformat == PIXELFMT_RGB8_Z24) + EncodeRGB8(dest_ptr, src, format); + else if (pixelformat == PIXELFMT_RGB565_Z16) // not supported + EncodeRGB8(dest_ptr, src, format); + else if (pixelformat == PIXELFMT_Z24) + EncodeZ24(dest_ptr, src, format); + } +} + + +} -- cgit v1.2.3 From 2afe2152712981e21d6bda6f029292ed2b1cf91e Mon Sep 17 00:00:00 2001 From: Lioncash Date: Mon, 17 Feb 2014 05:18:15 -0500 Subject: Convert all includes to relative paths. --- Source/Core/VideoBackends/Software/TextureEncoder.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index 07bb162cd6..6c24257fe3 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -2,12 +2,12 @@ // Licensed under GPLv2 // Refer to the license.txt file included. -#include "TextureEncoder.h" -#include "EfbInterface.h" -#include "BPMemLoader.h" +#include "VideoBackends/Software/BPMemLoader.h" +#include "VideoBackends/Software/EfbInterface.h" +#include "VideoBackends/Software/TextureEncoder.h" -#include "LookUpTables.h" -#include "TextureDecoder.h" +#include "VideoCommon/LookUpTables.h" +#include "VideoCommon/TextureDecoder.h" namespace TextureEncoder -- cgit v1.2.3 From 31cfc73a09a8685cbab20502b4bc132e98e2feb5 Mon Sep 17 00:00:00 2001 From: Matthew Parlane Date: Tue, 11 Mar 2014 00:30:55 +1300 Subject: Fixes spacing for "for", "while", "switch" and "if" Also moved && and || to ends of lines instead of start. Fixed misc vertical alignments and some { needed newlining. --- Source/Core/VideoBackends/Software/TextureEncoder.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index 6c24257fe3..cf99dbf911 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -261,7 +261,7 @@ void EncodeRGBA6(u8 *dst, u8 *src, u32 format) u32 readStride = 3; u8 *dstBlockStart = dst; - switch(format) + switch (format) { case GX_TF_I4: SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); @@ -498,7 +498,7 @@ void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) u32 readStride = 6; u8 *dstBlockStart = dst; - switch(format) + switch (format) { case GX_TF_I4: SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); @@ -732,7 +732,7 @@ void EncodeRGB8(u8 *dst, u8 *src, u32 format) u32 readStride = 3; u8 *dstBlockStart = dst; - switch(format) + switch (format) { case GX_TF_I4: SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); @@ -947,7 +947,7 @@ void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) u32 readStride = 6; u8 *dstBlockStart = dst; - switch(format) + switch (format) { case GX_TF_I4: SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); @@ -1177,7 +1177,7 @@ void EncodeZ24(u8 *dst, u8 *src, u32 format) u32 readStride = 3; u8 *dstBlockStart = dst; - switch(format) + switch (format) { case GX_TF_Z8: SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); @@ -1282,7 +1282,7 @@ void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) u8 r, g, b; u8 *dstBlockStart = dst; - switch(format) + switch (format) { case GX_TF_Z8: SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); -- cgit v1.2.3 From 8941f19cdb01bbe8c40851240d02019ed6e13a32 Mon Sep 17 00:00:00 2001 From: Tony Wasserka Date: Sun, 23 Mar 2014 21:44:23 +0100 Subject: BPMemory: Expose the pixel_format and zformat fields in PE_CONTROL as enumerations. --- .../Core/VideoBackends/Software/TextureEncoder.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index cf99dbf911..5913125a08 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -1386,8 +1386,8 @@ void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) void Encode(u8 *dest_ptr) { - int pixelformat = bpmem.zcontrol.pixel_format; - bool bFromZBuffer = pixelformat == PIXELFMT_Z24; + auto pixelformat = bpmem.zcontrol.pixel_format; + bool bFromZBuffer = pixelformat == PEControl::Z24; bool bIsIntensityFmt = bpmem.triggerEFBCopy.intensity_fmt > 0; u32 copyfmt = ((bpmem.triggerEFBCopy.target_pixel_format / 2) + ((bpmem.triggerEFBCopy.target_pixel_format & 1) * 8)); @@ -1409,24 +1409,24 @@ void Encode(u8 *dest_ptr) if (bpmem.triggerEFBCopy.half_scale) { - if (pixelformat == PIXELFMT_RGBA6_Z24) + if (pixelformat == PEControl::RGBA6_Z24) EncodeRGBA6halfscale(dest_ptr, src, format); - else if (pixelformat == PIXELFMT_RGB8_Z24) + else if (pixelformat == PEControl::RGB8_Z24) EncodeRGB8halfscale(dest_ptr, src, format); - else if (pixelformat == PIXELFMT_RGB565_Z16) // not supported + else if (pixelformat == PEControl::RGB565_Z16) // not supported EncodeRGB8halfscale(dest_ptr, src, format); - else if (pixelformat == PIXELFMT_Z24) + else if (pixelformat == PEControl::Z24) EncodeZ24halfscale(dest_ptr, src, format); } else { - if (pixelformat == PIXELFMT_RGBA6_Z24) + if (pixelformat == PEControl::RGBA6_Z24) EncodeRGBA6(dest_ptr, src, format); - else if (pixelformat == PIXELFMT_RGB8_Z24) + else if (pixelformat == PEControl::RGB8_Z24) EncodeRGB8(dest_ptr, src, format); - else if (pixelformat == PIXELFMT_RGB565_Z16) // not supported + else if (pixelformat == PEControl::RGB565_Z16) // not supported EncodeRGB8(dest_ptr, src, format); - else if (pixelformat == PIXELFMT_Z24) + else if (pixelformat == PEControl::Z24) EncodeZ24(dest_ptr, src, format); } } -- cgit v1.2.3 From 22e1aa5bb4a159d6d66a321f978917614aa36331 Mon Sep 17 00:00:00 2001 From: degasus Date: Tue, 8 Jul 2014 14:29:26 +0200 Subject: mark all local functions as static --- Source/Core/VideoBackends/Software/TextureEncoder.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index 5913125a08..8351d39a29 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -196,7 +196,7 @@ inline void boxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int comp2) x2 = x16_2 >> 2; } -void SetBlockDimensions(int blkWidthLog2, int blkHeightLog2, u16 &sBlkCount, u16 &tBlkCount, u16 &sBlkSize, u16 &tBlkSize) +static void SetBlockDimensions(int blkWidthLog2, int blkHeightLog2, u16 &sBlkCount, u16 &tBlkCount, u16 &sBlkSize, u16 &tBlkSize) { // if half_scale is 1 then the size is cut in half u32 width = bpmem.copyTexSrcWH.x >> bpmem.triggerEFBCopy.half_scale; @@ -209,7 +209,7 @@ void SetBlockDimensions(int blkWidthLog2, int blkHeightLog2, u16 &sBlkCount, u16 tBlkSize = 1 << blkHeightLog2; } -void SetSpans(int sBlkSize, int tBlkSize, s32 &tSpan, s32 &sBlkSpan, s32 &tBlkSpan, s32 &writeStride) +static void SetSpans(int sBlkSize, int tBlkSize, s32 &tSpan, s32 &sBlkSpan, s32 &tBlkSpan, s32 &writeStride) { // width is 1 less than the number of pixels of width u32 width = bpmem.copyTexSrcWH.x >> bpmem.triggerEFBCopy.half_scale; @@ -253,7 +253,7 @@ void SetSpans(int sBlkSize, int tBlkSize, s32 &tSpan, s32 &sBlkSpan, s32 &tBlkSp dstBlockStart += writeStride; \ } \ -void EncodeRGBA6(u8 *dst, u8 *src, u32 format) +static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) { u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; s32 tSpan, sBlkSpan, tBlkSpan, writeStride; @@ -490,7 +490,7 @@ void EncodeRGBA6(u8 *dst, u8 *src, u32 format) } -void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) +static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) { u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; s32 tSpan, sBlkSpan, tBlkSpan, writeStride; @@ -725,7 +725,7 @@ void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) } } -void EncodeRGB8(u8 *dst, u8 *src, u32 format) +static void EncodeRGB8(u8 *dst, u8 *src, u32 format) { u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; s32 tSpan, sBlkSpan, tBlkSpan, writeStride; @@ -939,7 +939,7 @@ void EncodeRGB8(u8 *dst, u8 *src, u32 format) } } -void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) +static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) { u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; s32 tSpan, sBlkSpan, tBlkSpan, writeStride; @@ -1170,7 +1170,7 @@ void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) } } -void EncodeZ24(u8 *dst, u8 *src, u32 format) +static void EncodeZ24(u8 *dst, u8 *src, u32 format) { u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; s32 tSpan, sBlkSpan, tBlkSpan, writeStride; @@ -1274,7 +1274,7 @@ void EncodeZ24(u8 *dst, u8 *src, u32 format) } } -void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) +static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) { u16 sBlkCount, tBlkCount, sBlkSize, tBlkSize; s32 tSpan, sBlkSpan, tBlkSpan, writeStride; -- cgit v1.2.3 From 568bdec5983a419dd06e9e497ec43d04677bc2df Mon Sep 17 00:00:00 2001 From: Lioncash Date: Sun, 10 Aug 2014 21:41:04 -0400 Subject: Software: Fix function casing in TextureEncoder --- .../Core/VideoBackends/Software/TextureEncoder.cpp | 100 ++++++++++----------- 1 file changed, 50 insertions(+), 50 deletions(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index 8351d39a29..a1b5670480 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -40,7 +40,7 @@ inline u8 RGB8_to_I(u8 r, u8 g, u8 b) // box filter sampling averages 4 samples with the source texel being the top left of the box // components are scaled to the range 0-255 after all samples are taken -inline void boxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) +inline void BoxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) { u16 r16 = 0, g16 = 0, b16 = 0, a16 = 0; @@ -66,7 +66,7 @@ inline void boxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) a = a16 + (a16 >> 6); } -inline void boxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +inline void BoxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) { u16 r16 = 0, g16 = 0, b16 = 0; @@ -90,7 +90,7 @@ inline void boxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) b = b16 + (b16 >> 6); } -inline void boxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) +inline void BoxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) { u16 x16 = 0; @@ -110,7 +110,7 @@ inline void boxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) x8 = x16 + (x16 >> 6); } -inline void boxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2) +inline void BoxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2) { u16 x16_1 = 0; u16 x16_2 = 0; @@ -133,7 +133,7 @@ inline void boxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2 x2 = x16_2 + (x16_2 >> 6); } -inline void boxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +inline void BoxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) { u16 r16 = 0, g16 = 0, b16 = 0; @@ -155,7 +155,7 @@ inline void boxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) b = b16 >> 2; } -inline void boxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) +inline void BoxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) { u16 x16 = 0; @@ -174,7 +174,7 @@ inline void boxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) x8 = x16 >> 2; } -inline void boxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int comp2) +inline void BoxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int comp2) { u16 x16_1 = 0; u16 x16_2 = 0; @@ -506,11 +506,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, r, g, b); src += readStride; *dst = RGB8_to_I(r, g, b) & 0xf0; - boxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, r, g, b); src += readStride; *dst |= RGB8_to_I(r, g, b) >> 4; dst++; @@ -523,7 +523,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, r, g, b); src += readStride; *dst++ = RGB8_to_I(r, g, b); } @@ -535,7 +535,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_RGBA8(src, r, g, b, a); + BoxfilterRGBA_to_RGBA8(src, r, g, b, a); src += readStride; *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4); } @@ -547,7 +547,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_RGBA8(src, r, g, b, a); + BoxfilterRGBA_to_RGBA8(src, r, g, b, a); src += readStride; *dst++ = a; *dst++ = RGB8_to_I(r, g, b); @@ -560,7 +560,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, r, g, b); src += readStride; u16 val = ((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | ((b >> 3) & 0x001e); @@ -575,7 +575,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_RGBA8(src, r, g, b, a); + BoxfilterRGBA_to_RGBA8(src, r, g, b, a); src += readStride; u16 val; @@ -595,7 +595,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_RGBA8(src, dst[1], dst[32], dst[33], dst[0]); + BoxfilterRGBA_to_RGBA8(src, dst[1], dst[32], dst[33], dst[0]); src += readStride; dst += 2; } @@ -608,11 +608,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_x8(src, r, 18); + BoxfilterRGBA_to_x8(src, r, 18); src += readStride; *dst = r & 0xf0; - boxfilterRGBA_to_x8(src, r, 18); + BoxfilterRGBA_to_x8(src, r, 18); src += readStride; *dst |= r >> 4; dst++; @@ -625,7 +625,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_xx8(src, r, a, 18, 0); + BoxfilterRGBA_to_xx8(src, r, a, 18, 0); src += readStride; *dst++ = (a & 0xf0) | (r >> 4); } @@ -637,7 +637,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_xx8(src, r, a, 18, 0); + BoxfilterRGBA_to_xx8(src, r, a, 18, 0); src += readStride; *dst++ = a; *dst++ = r; @@ -650,7 +650,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_x8(src, a, 0); + BoxfilterRGBA_to_x8(src, a, 0); *dst++ = a; src += readStride; } @@ -662,7 +662,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_x8(src, r, 18); + BoxfilterRGBA_to_x8(src, r, 18); *dst++ = r; src += readStride; } @@ -674,7 +674,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_x8(src, g, 12); + BoxfilterRGBA_to_x8(src, g, 12); *dst++ = g; src += readStride; } @@ -686,7 +686,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_x8(src, b, 6); + BoxfilterRGBA_to_x8(src, b, 6); *dst++ = b; src += readStride; } @@ -698,7 +698,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_xx8(src, r, g, 18, 12); + BoxfilterRGBA_to_xx8(src, r, g, 18, 12); src += readStride; *dst++ = g; *dst++ = r; @@ -711,7 +711,7 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGBA_to_xx8(src, g, b, 12, 6); + BoxfilterRGBA_to_xx8(src, g, b, 12, 6); src += readStride; *dst++ = b; *dst++ = g; @@ -955,11 +955,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); *dst = RGB8_to_I(r, g, b) & 0xf0; src += readStride; - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); *dst |= RGB8_to_I(r, g, b) >> 4; src += readStride; dst++; @@ -972,7 +972,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); *dst++ = RGB8_to_I(r, g, b); src += readStride; } @@ -984,7 +984,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); *dst++ = 0xf0 | (RGB8_to_I(r, g, b) >> 4); src += readStride; } @@ -996,7 +996,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); *dst++ = 0xff; *dst++ = RGB8_to_I(r, g, b); src += readStride; @@ -1009,7 +1009,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); u16 val = ((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | ((b >> 3) & 0x001e); *(u16*)dst = Common::swap16(val); src += readStride; @@ -1023,7 +1023,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); u16 val = 0x8000 | ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001e); *(u16*)dst = Common::swap16(val); src += readStride; @@ -1037,7 +1037,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, r, g, b); dst[0] = 0xff; dst[1] = r; dst[32] = g; @@ -1054,11 +1054,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, r, 2); *dst = r & 0xf0; src += readStride; - boxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, r, 2); *dst |= r >> 4; src += readStride; @@ -1072,7 +1072,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, r, 2); *dst++ = 0xf0 | (r >> 4); src += readStride; } @@ -1084,7 +1084,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, r, 2); *dst++ = 0xff; *dst++ = r; src += readStride; @@ -1107,7 +1107,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, r, 2); *dst++ = r; src += readStride; } @@ -1119,7 +1119,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, g, 1); + BoxfilterRGB_to_x8(src, g, 1); *dst++ = g; src += readStride; } @@ -1131,7 +1131,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, b, 0); + BoxfilterRGB_to_x8(src, b, 0); *dst++ = b; src += readStride; } @@ -1143,7 +1143,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_xx8(src, r, g, 2, 1); + BoxfilterRGB_to_xx8(src, r, g, 2, 1); *dst++ = g; *dst++ = r; src += readStride; @@ -1156,7 +1156,7 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_xx8(src, g, b, 1, 0); + BoxfilterRGB_to_xx8(src, g, b, 1, 0); *dst++ = b; *dst++ = g; src += readStride; @@ -1289,7 +1289,7 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, b, 2); + BoxfilterRGB_to_x8(src, b, 2); *dst++ = b; src += readStride; } @@ -1301,7 +1301,7 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_xx8(src, g, b, 1, 2); + BoxfilterRGB_to_xx8(src, g, b, 1, 2); *dst++ = b; *dst++ = g; src += readStride; @@ -1314,7 +1314,7 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_RGB8(src, dst[33], dst[32], dst[1]); + BoxfilterRGB_to_RGB8(src, dst[33], dst[32], dst[1]); dst[0] = 255; src += readStride; dst += 2; @@ -1328,11 +1328,11 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, b, 2); + BoxfilterRGB_to_x8(src, b, 2); *dst = b & 0xf0; src += readStride; - boxfilterRGB_to_x8(src, b, 2); + BoxfilterRGB_to_x8(src, b, 2); *dst |= b >> 4; src += readStride; @@ -1346,7 +1346,7 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, g, 1); + BoxfilterRGB_to_x8(src, g, 1); *dst++ = g; src += readStride; } @@ -1358,7 +1358,7 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_x8(src, r, 0); + BoxfilterRGB_to_x8(src, r, 0); *dst++ = r; src += readStride; } @@ -1370,7 +1370,7 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); ENCODE_LOOP_BLOCKS { - boxfilterRGB_to_xx8(src, r, g, 0, 1); + BoxfilterRGB_to_xx8(src, r, g, 0, 1); *dst++ = g; *dst++ = r; src += readStride; -- cgit v1.2.3 From 4129cdeb4d1e3969aba64cf2dad25b3864eedccb Mon Sep 17 00:00:00 2001 From: Lioncash Date: Sun, 10 Aug 2014 21:51:05 -0400 Subject: Software: Apply static to some functions --- .../Core/VideoBackends/Software/TextureEncoder.cpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index a1b5670480..0fe7214d2a 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -13,7 +13,7 @@ namespace TextureEncoder { -inline void RGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) +static inline void RGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) { u32 srcColor = *(u32*)src; a = Convert6To8(srcColor & 0x3f); @@ -22,7 +22,7 @@ inline void RGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) r = Convert6To8((srcColor >> 18)& 0x3f); } -inline void RGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +static inline void RGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) { u32 srcColor = *(u32*)src; b = Convert6To8((srcColor >> 6) & 0x3f); @@ -30,7 +30,7 @@ inline void RGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) r = Convert6To8((srcColor >> 18)& 0x3f); } -inline u8 RGB8_to_I(u8 r, u8 g, u8 b) +static inline u8 RGB8_to_I(u8 r, u8 g, u8 b) { // values multiplied by 256 to keep math integer u16 val = 4096 + 66 * r + 129 * g + 25 * b; @@ -40,7 +40,7 @@ inline u8 RGB8_to_I(u8 r, u8 g, u8 b) // box filter sampling averages 4 samples with the source texel being the top left of the box // components are scaled to the range 0-255 after all samples are taken -inline void BoxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) +static inline void BoxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) { u16 r16 = 0, g16 = 0, b16 = 0, a16 = 0; @@ -66,7 +66,7 @@ inline void BoxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) a = a16 + (a16 >> 6); } -inline void BoxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +static inline void BoxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) { u16 r16 = 0, g16 = 0, b16 = 0; @@ -90,7 +90,7 @@ inline void BoxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) b = b16 + (b16 >> 6); } -inline void BoxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) +static inline void BoxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) { u16 x16 = 0; @@ -110,7 +110,7 @@ inline void BoxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) x8 = x16 + (x16 >> 6); } -inline void BoxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2) +static inline void BoxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2) { u16 x16_1 = 0; u16 x16_2 = 0; @@ -133,7 +133,7 @@ inline void BoxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2 x2 = x16_2 + (x16_2 >> 6); } -inline void BoxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +static inline void BoxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) { u16 r16 = 0, g16 = 0, b16 = 0; @@ -155,7 +155,7 @@ inline void BoxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) b = b16 >> 2; } -inline void BoxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) +static inline void BoxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) { u16 x16 = 0; @@ -174,7 +174,7 @@ inline void BoxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) x8 = x16 >> 2; } -inline void BoxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int comp2) +static inline void BoxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int comp2) { u16 x16_1 = 0; u16 x16_2 = 0; -- cgit v1.2.3 From 7f6284c2fcea9d543b0eec44ea0f3ad36bd0c0aa Mon Sep 17 00:00:00 2001 From: comex Date: Thu, 2 Oct 2014 02:20:46 -0400 Subject: Change a bunch of reference function arguments to pointers. Per the coding style and sanity. --- .../Core/VideoBackends/Software/TextureEncoder.cpp | 494 ++++++++++----------- 1 file changed, 247 insertions(+), 247 deletions(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index 0fe7214d2a..69a2a37dd4 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -13,21 +13,21 @@ namespace TextureEncoder { -static inline void RGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) +static inline void RGBA_to_RGBA8(const u8 *src, u8* r, u8* g, u8* b, u8* a) { u32 srcColor = *(u32*)src; - a = Convert6To8(srcColor & 0x3f); - b = Convert6To8((srcColor >> 6) & 0x3f); - g = Convert6To8((srcColor >> 12)& 0x3f); - r = Convert6To8((srcColor >> 18)& 0x3f); + *a = Convert6To8(srcColor & 0x3f); + *b = Convert6To8((srcColor >> 6) & 0x3f); + *g = Convert6To8((srcColor >> 12)& 0x3f); + *r = Convert6To8((srcColor >> 18)& 0x3f); } -static inline void RGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +static inline void RGBA_to_RGB8(const u8 *src, u8* r, u8* g, u8* b) { u32 srcColor = *(u32*)src; - b = Convert6To8((srcColor >> 6) & 0x3f); - g = Convert6To8((srcColor >> 12)& 0x3f); - r = Convert6To8((srcColor >> 18)& 0x3f); + *b = Convert6To8((srcColor >> 6) & 0x3f); + *g = Convert6To8((srcColor >> 12)& 0x3f); + *r = Convert6To8((srcColor >> 18)& 0x3f); } static inline u8 RGB8_to_I(u8 r, u8 g, u8 b) @@ -40,7 +40,7 @@ static inline u8 RGB8_to_I(u8 r, u8 g, u8 b) // box filter sampling averages 4 samples with the source texel being the top left of the box // components are scaled to the range 0-255 after all samples are taken -static inline void BoxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) +static inline void BoxfilterRGBA_to_RGBA8(const u8* src, u8* r, u8* g, u8* b, u8* a) { u16 r16 = 0, g16 = 0, b16 = 0, a16 = 0; @@ -60,13 +60,13 @@ static inline void BoxfilterRGBA_to_RGBA8(u8 *src, u8 &r, u8 &g, u8 &b, u8 &a) src += (640 - 2) * 3; // move to next line } - r = r16 + (r16 >> 6); - g = g16 + (g16 >> 6); - b = b16 + (b16 >> 6); - a = a16 + (a16 >> 6); + *r = r16 + (r16 >> 6); + *g = g16 + (g16 >> 6); + *b = b16 + (b16 >> 6); + *a = a16 + (a16 >> 6); } -static inline void BoxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +static inline void BoxfilterRGBA_to_RGB8(const u8* src, u8* r, u8* g, u8* b) { u16 r16 = 0, g16 = 0, b16 = 0; @@ -85,12 +85,12 @@ static inline void BoxfilterRGBA_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) src += (640 - 2) * 3; // move to next line } - r = r16 + (r16 >> 6); - g = g16 + (g16 >> 6); - b = b16 + (b16 >> 6); + *r = r16 + (r16 >> 6); + *g = g16 + (g16 >> 6); + *b = b16 + (b16 >> 6); } -static inline void BoxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) +static inline void BoxfilterRGBA_to_x8(const u8* src, u8* x8, int shift) { u16 x16 = 0; @@ -107,10 +107,10 @@ static inline void BoxfilterRGBA_to_x8(u8 *src, u8 &x8, int shift) src += (640 - 2) * 3; // move to next line } - x8 = x16 + (x16 >> 6); + *x8 = x16 + (x16 >> 6); } -static inline void BoxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int shift2) +static inline void BoxfilterRGBA_to_xx8(const u8* src, u8* x1, u8* x2, int shift1, int shift2) { u16 x16_1 = 0; u16 x16_2 = 0; @@ -129,11 +129,11 @@ static inline void BoxfilterRGBA_to_xx8(u8 *src, u8 &x1, u8 &x2, int shift1, int src += (640 - 2) * 3; // move to next line } - x1 = x16_1 + (x16_1 >> 6); - x2 = x16_2 + (x16_2 >> 6); + *x1 = x16_1 + (x16_1 >> 6); + *x2 = x16_2 + (x16_2 >> 6); } -static inline void BoxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) +static inline void BoxfilterRGB_to_RGB8(const u8* src, u8* r, u8* g, u8* b) { u16 r16 = 0, g16 = 0, b16 = 0; @@ -150,12 +150,12 @@ static inline void BoxfilterRGB_to_RGB8(u8 *src, u8 &r, u8 &g, u8 &b) src += (640 - 2) * 3; // move to next line } - r = r16 >> 2; - g = g16 >> 2; - b = b16 >> 2; + *r = r16 >> 2; + *g = g16 >> 2; + *b = b16 >> 2; } -static inline void BoxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) +static inline void BoxfilterRGB_to_x8(u8 *src, u8* x8, int comp) { u16 x16 = 0; @@ -171,10 +171,10 @@ static inline void BoxfilterRGB_to_x8(u8 *src, u8 &x8, int comp) src += (640 - 2) * 3; // move to next line } - x8 = x16 >> 2; + *x8 = x16 >> 2; } -static inline void BoxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int comp2) +static inline void BoxfilterRGB_to_xx8(const u8* src, u8* x1, u8* x2, int comp1, int comp2) { u16 x16_1 = 0; u16 x16_2 = 0; @@ -192,24 +192,24 @@ static inline void BoxfilterRGB_to_xx8(u8 *src, u8 &x1, u8 &x2, int comp1, int c src += (640 - 2) * 3; // move to next line } - x1 = x16_1 >> 2; - x2 = x16_2 >> 2; + *x1 = x16_1 >> 2; + *x2 = x16_2 >> 2; } -static void SetBlockDimensions(int blkWidthLog2, int blkHeightLog2, u16 &sBlkCount, u16 &tBlkCount, u16 &sBlkSize, u16 &tBlkSize) +static void SetBlockDimensions(int blkWidthLog2, int blkHeightLog2, u16* sBlkCount, u16* tBlkCount, u16* sBlkSize, u16* tBlkSize) { // if half_scale is 1 then the size is cut in half u32 width = bpmem.copyTexSrcWH.x >> bpmem.triggerEFBCopy.half_scale; u32 height = bpmem.copyTexSrcWH.y >> bpmem.triggerEFBCopy.half_scale; - sBlkCount = (width >> blkWidthLog2) + 1; - tBlkCount = (height >> blkHeightLog2) + 1; + *sBlkCount = (width >> blkWidthLog2) + 1; + *tBlkCount = (height >> blkHeightLog2) + 1; - sBlkSize = 1 << blkWidthLog2; - tBlkSize = 1 << blkHeightLog2; + *sBlkSize = 1 << blkWidthLog2; + *tBlkSize = 1 << blkHeightLog2; } -static void SetSpans(int sBlkSize, int tBlkSize, s32 &tSpan, s32 &sBlkSpan, s32 &tBlkSpan, s32 &writeStride) +static void SetSpans(int sBlkSize, int tBlkSize, s32* tSpan, s32* sBlkSpan, s32* tBlkSpan, s32* writeStride) { // width is 1 less than the number of pixels of width u32 width = bpmem.copyTexSrcWH.x >> bpmem.triggerEFBCopy.half_scale; @@ -217,11 +217,11 @@ static void SetSpans(int sBlkSize, int tBlkSize, s32 &tSpan, s32 &sBlkSpan, s32 u32 readStride = 3 << bpmem.triggerEFBCopy.half_scale; - tSpan = (640 - sBlkSize) * readStride; // bytes to advance src pointer after each row of texels in a block - sBlkSpan = ((-640 * tBlkSize) + sBlkSize) * readStride; // bytes to advance src pointer after each block - tBlkSpan = ((640 * tBlkSize) - alignedWidth) * readStride; // bytes to advance src pointer after each row of blocks + *tSpan = (640 - sBlkSize) * readStride; // bytes to advance src pointer after each row of texels in a block + *sBlkSpan = ((-640 * tBlkSize) + sBlkSize) * readStride; // bytes to advance src pointer after each block + *tBlkSpan = ((640 * tBlkSize) - alignedWidth) * readStride; // bytes to advance src pointer after each row of blocks - writeStride = bpmem.copyMipMapStrideChannels * 32; + *writeStride = bpmem.copyMipMapStrideChannels * 32; } #define ENCODE_LOOP_BLOCKS \ @@ -264,16 +264,16 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) switch (format) { case GX_TF_I4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - RGBA_to_RGB8(src, r, g, b); + RGBA_to_RGB8(src, &r, &g, &b); src += readStride; *dst = RGB8_to_I(r, g, b) & 0xf0; - RGBA_to_RGB8(src, r, g, b); + RGBA_to_RGB8(src, &r, &g, &b); src += readStride; *dst |= RGB8_to_I(r, g, b) >> 4; dst++; @@ -282,11 +282,11 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_TF_I8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - RGBA_to_RGB8(src, r, g, b); + RGBA_to_RGB8(src, &r, &g, &b); src += readStride; *dst++ = RGB8_to_I(r, g, b); } @@ -294,11 +294,11 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - RGBA_to_RGBA8(src, r, g, b, a); + RGBA_to_RGBA8(src, &r, &g, &b, &a); src += readStride; *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4); } @@ -306,11 +306,11 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - RGBA_to_RGBA8(src, r, g, b, a); + RGBA_to_RGBA8(src, &r, &g, &b, &a); src += readStride; *dst++ = a; *dst++ = RGB8_to_I(r, g, b); @@ -319,8 +319,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB565: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -334,8 +334,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB5A3: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -355,11 +355,11 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGBA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - RGBA_to_RGBA8(src, dst[1], dst[32], dst[33], dst[0]); + RGBA_to_RGBA8(src, &dst[1], &dst[32], &dst[33], &dst[0]); src += readStride; dst += 2; } @@ -367,8 +367,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { @@ -385,8 +385,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -397,8 +397,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -410,8 +410,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_A8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -422,8 +422,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -434,8 +434,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_G8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -446,8 +446,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_B8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -458,8 +458,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RG8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -471,8 +471,8 @@ static void EncodeRGBA6(u8 *dst, u8 *src, u32 format) break; case GX_CTF_GB8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u32 srcColor = *(u32*)src; @@ -501,16 +501,16 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) switch (format) { case GX_TF_I4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, &r, &g, &b); src += readStride; *dst = RGB8_to_I(r, g, b) & 0xf0; - BoxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, &r, &g, &b); src += readStride; *dst |= RGB8_to_I(r, g, b) >> 4; dst++; @@ -519,11 +519,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_I8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, &r, &g, &b); src += readStride; *dst++ = RGB8_to_I(r, g, b); } @@ -531,11 +531,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_RGBA8(src, r, g, b, a); + BoxfilterRGBA_to_RGBA8(src, &r, &g, &b, &a); src += readStride; *dst++ = (a & 0xf0) | (RGB8_to_I(r, g, b) >> 4); } @@ -543,11 +543,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_RGBA8(src, r, g, b, a); + BoxfilterRGBA_to_RGBA8(src, &r, &g, &b, &a); src += readStride; *dst++ = a; *dst++ = RGB8_to_I(r, g, b); @@ -556,11 +556,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB565: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_RGB8(src, r, g, b); + BoxfilterRGBA_to_RGB8(src, &r, &g, &b); src += readStride; u16 val = ((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | ((b >> 3) & 0x001e); @@ -571,11 +571,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB5A3: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_RGBA8(src, r, g, b, a); + BoxfilterRGBA_to_RGBA8(src, &r, &g, &b, &a); src += readStride; u16 val; @@ -591,11 +591,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGBA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_RGBA8(src, dst[1], dst[32], dst[33], dst[0]); + BoxfilterRGBA_to_RGBA8(src, &dst[1], &dst[32], &dst[33], &dst[0]); src += readStride; dst += 2; } @@ -603,16 +603,16 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_x8(src, r, 18); + BoxfilterRGBA_to_x8(src, &r, 18); src += readStride; *dst = r & 0xf0; - BoxfilterRGBA_to_x8(src, r, 18); + BoxfilterRGBA_to_x8(src, &r, 18); src += readStride; *dst |= r >> 4; dst++; @@ -621,11 +621,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_xx8(src, r, a, 18, 0); + BoxfilterRGBA_to_xx8(src, &r, &a, 18, 0); src += readStride; *dst++ = (a & 0xf0) | (r >> 4); } @@ -633,11 +633,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_xx8(src, r, a, 18, 0); + BoxfilterRGBA_to_xx8(src, &r, &a, 18, 0); src += readStride; *dst++ = a; *dst++ = r; @@ -646,11 +646,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_A8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_x8(src, a, 0); + BoxfilterRGBA_to_x8(src, &a, 0); *dst++ = a; src += readStride; } @@ -658,11 +658,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_x8(src, r, 18); + BoxfilterRGBA_to_x8(src, &r, 18); *dst++ = r; src += readStride; } @@ -670,11 +670,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_G8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_x8(src, g, 12); + BoxfilterRGBA_to_x8(src, &g, 12); *dst++ = g; src += readStride; } @@ -682,11 +682,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_B8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_x8(src, b, 6); + BoxfilterRGBA_to_x8(src, &b, 6); *dst++ = b; src += readStride; } @@ -694,11 +694,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RG8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_xx8(src, r, g, 18, 12); + BoxfilterRGBA_to_xx8(src, &r, &g, 18, 12); src += readStride; *dst++ = g; *dst++ = r; @@ -707,11 +707,11 @@ static void EncodeRGBA6halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_GB8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGBA_to_xx8(src, g, b, 12, 6); + BoxfilterRGBA_to_xx8(src, &g, &b, 12, 6); src += readStride; *dst++ = b; *dst++ = g; @@ -735,8 +735,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) switch (format) { case GX_TF_I4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { @@ -751,8 +751,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_TF_I8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = RGB8_to_I(src[2], src[1], src[0]); @@ -762,8 +762,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = 0xf0 | (RGB8_to_I(src[2], src[1], src[0]) >> 4); @@ -773,8 +773,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = 0xff; @@ -786,8 +786,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB565: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u16 val = ((src[2] << 8) & 0xf800) | ((src[1] << 3) & 0x07e0) | ((src[0] >> 3) & 0x001e); @@ -799,8 +799,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB5A3: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { u16 val = 0x8000 | ((src[2] << 7) & 0x7c00) | ((src[1] << 2) & 0x03e0) | ((src[0] >> 3) & 0x001e); @@ -812,8 +812,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGBA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { dst[0] = 0xff; @@ -827,8 +827,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { @@ -844,8 +844,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = 0xf0 | (src[2] >> 4); @@ -855,8 +855,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = 0xff; @@ -867,8 +867,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_A8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = 0xff; @@ -877,8 +877,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[2]; @@ -888,8 +888,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_G8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[1]; @@ -899,8 +899,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_B8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[0]; @@ -910,8 +910,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RG8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[1]; @@ -922,8 +922,8 @@ static void EncodeRGB8(u8 *dst, u8 *src, u32 format) break; case GX_CTF_GB8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[0]; @@ -950,16 +950,16 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) switch (format) { case GX_TF_I4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); *dst = RGB8_to_I(r, g, b) & 0xf0; src += readStride; - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); *dst |= RGB8_to_I(r, g, b) >> 4; src += readStride; dst++; @@ -968,11 +968,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_I8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); *dst++ = RGB8_to_I(r, g, b); src += readStride; } @@ -980,11 +980,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); *dst++ = 0xf0 | (RGB8_to_I(r, g, b) >> 4); src += readStride; } @@ -992,11 +992,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_IA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); *dst++ = 0xff; *dst++ = RGB8_to_I(r, g, b); src += readStride; @@ -1005,11 +1005,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB565: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); u16 val = ((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | ((b >> 3) & 0x001e); *(u16*)dst = Common::swap16(val); src += readStride; @@ -1019,11 +1019,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGB5A3: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); u16 val = 0x8000 | ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001e); *(u16*)dst = Common::swap16(val); src += readStride; @@ -1033,11 +1033,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_RGBA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, r, g, b); + BoxfilterRGB_to_RGB8(src, &r, &g, &b); dst[0] = 0xff; dst[1] = r; dst[32] = g; @@ -1049,16 +1049,16 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, &r, 2); *dst = r & 0xf0; src += readStride; - BoxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, &r, 2); *dst |= r >> 4; src += readStride; @@ -1068,11 +1068,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA4: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, &r, 2); *dst++ = 0xf0 | (r >> 4); src += readStride; } @@ -1080,11 +1080,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RA8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, &r, 2); *dst++ = 0xff; *dst++ = r; src += readStride; @@ -1093,8 +1093,8 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_A8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = 0xff; @@ -1103,11 +1103,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_R8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, r, 2); + BoxfilterRGB_to_x8(src, &r, 2); *dst++ = r; src += readStride; } @@ -1115,11 +1115,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_G8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, g, 1); + BoxfilterRGB_to_x8(src, &g, 1); *dst++ = g; src += readStride; } @@ -1127,11 +1127,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_B8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, b, 0); + BoxfilterRGB_to_x8(src, &b, 0); *dst++ = b; src += readStride; } @@ -1139,11 +1139,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_RG8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_xx8(src, r, g, 2, 1); + BoxfilterRGB_to_xx8(src, &r, &g, 2, 1); *dst++ = g; *dst++ = r; src += readStride; @@ -1152,11 +1152,11 @@ static void EncodeRGB8halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_GB8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_xx8(src, g, b, 1, 0); + BoxfilterRGB_to_xx8(src, &g, &b, 1, 0); *dst++ = b; *dst++ = g; src += readStride; @@ -1180,8 +1180,8 @@ static void EncodeZ24(u8 *dst, u8 *src, u32 format) switch (format) { case GX_TF_Z8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[2]; @@ -1191,8 +1191,8 @@ static void EncodeZ24(u8 *dst, u8 *src, u32 format) break; case GX_TF_Z16: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[1]; @@ -1203,8 +1203,8 @@ static void EncodeZ24(u8 *dst, u8 *src, u32 format) break; case GX_TF_Z24X8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { dst[0] = 0xff; @@ -1218,8 +1218,8 @@ static void EncodeZ24(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { @@ -1235,8 +1235,8 @@ static void EncodeZ24(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z8M: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[1]; @@ -1246,8 +1246,8 @@ static void EncodeZ24(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z8L: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[0]; @@ -1257,8 +1257,8 @@ static void EncodeZ24(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z16L: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { *dst++ = src[0]; @@ -1285,11 +1285,11 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) switch (format) { case GX_TF_Z8: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, b, 2); + BoxfilterRGB_to_x8(src, &b, 2); *dst++ = b; src += readStride; } @@ -1297,11 +1297,11 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_Z16: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_xx8(src, g, b, 1, 2); + BoxfilterRGB_to_xx8(src, &g, &b, 1, 2); *dst++ = b; *dst++ = g; src += readStride; @@ -1310,11 +1310,11 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) break; case GX_TF_Z24X8: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_RGB8(src, dst[33], dst[32], dst[1]); + BoxfilterRGB_to_RGB8(src, &dst[33], &dst[32], &dst[1]); dst[0] = 255; src += readStride; dst += 2; @@ -1323,16 +1323,16 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z4: - SetBlockDimensions(3, 3, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 3, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); sBlkSize /= 2; ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, b, 2); + BoxfilterRGB_to_x8(src, &b, 2); *dst = b & 0xf0; src += readStride; - BoxfilterRGB_to_x8(src, b, 2); + BoxfilterRGB_to_x8(src, &b, 2); *dst |= b >> 4; src += readStride; @@ -1342,11 +1342,11 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z8M: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, g, 1); + BoxfilterRGB_to_x8(src, &g, 1); *dst++ = g; src += readStride; } @@ -1354,11 +1354,11 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z8L: - SetBlockDimensions(3, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(3, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_x8(src, r, 0); + BoxfilterRGB_to_x8(src, &r, 0); *dst++ = r; src += readStride; } @@ -1366,11 +1366,11 @@ static void EncodeZ24halfscale(u8 *dst, u8 *src, u32 format) break; case GX_CTF_Z16L: - SetBlockDimensions(2, 2, sBlkCount, tBlkCount, sBlkSize, tBlkSize); - SetSpans(sBlkSize, tBlkSize, tSpan, sBlkSpan, tBlkSpan, writeStride); + SetBlockDimensions(2, 2, &sBlkCount, &tBlkCount, &sBlkSize, &tBlkSize); + SetSpans(sBlkSize, tBlkSize, &tSpan, &sBlkSpan, &tBlkSpan, &writeStride); ENCODE_LOOP_BLOCKS { - BoxfilterRGB_to_xx8(src, r, g, 0, 1); + BoxfilterRGB_to_xx8(src, &r, &g, 0, 1); *dst++ = g; *dst++ = r; src += readStride; -- cgit v1.2.3 From cefcb0ace9d363b3679b4e93bcc9ec05f1e5f4f8 Mon Sep 17 00:00:00 2001 From: Tillmann Karras Date: Mon, 18 May 2015 01:08:10 +0200 Subject: Update license headers to GPLv2+ --- Source/Core/VideoBackends/Software/TextureEncoder.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index 69a2a37dd4..cc9d72b365 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -1,5 +1,5 @@ // Copyright 2013 Dolphin Emulator Project -// Licensed under GPLv2 +// Licensed under GPLv2+ // Refer to the license.txt file included. #include "VideoBackends/Software/BPMemLoader.h" -- cgit v1.2.3 From 30ebb2459eb97ba544547183854775df8460b475 Mon Sep 17 00:00:00 2001 From: Tillmann Karras Date: Sun, 24 May 2015 06:55:12 +0200 Subject: Set copyright year to when a file was created --- Source/Core/VideoBackends/Software/TextureEncoder.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'Source/Core/VideoBackends/Software/TextureEncoder.cpp') diff --git a/Source/Core/VideoBackends/Software/TextureEncoder.cpp b/Source/Core/VideoBackends/Software/TextureEncoder.cpp index cc9d72b365..13c5973c95 100644 --- a/Source/Core/VideoBackends/Software/TextureEncoder.cpp +++ b/Source/Core/VideoBackends/Software/TextureEncoder.cpp @@ -1,4 +1,4 @@ -// Copyright 2013 Dolphin Emulator Project +// Copyright 2009 Dolphin Emulator Project // Licensed under GPLv2+ // Refer to the license.txt file included. -- cgit v1.2.3