mirror of
https://github.com/gligli/nulldc-360.git
synced 2025-04-02 11:11:56 -04:00
638 lines
16 KiB
C++
638 lines
16 KiB
C++
#pragma once
|
|
#include "drkPvr.h"
|
|
|
|
extern u8* vq_codebook;
|
|
extern u32 palette_index;
|
|
extern u32 palette_lut[1024];
|
|
extern bool pal_needs_update;
|
|
extern u32 pal_rev_256[4];
|
|
extern u32 pal_rev_16[64];
|
|
extern u32 _pal_rev_256[4];
|
|
extern u32 _pal_rev_16[64];
|
|
|
|
#define max(a,b) (((a)>(b))?(a):(b))
|
|
#define min(a,b) (((a)<(b))?(a):(b))
|
|
|
|
//Generic texture cache list class =P
|
|
template <class TexEntryType>
|
|
class TexCacheList
|
|
{
|
|
public:
|
|
class TexCacheEntry
|
|
{
|
|
public:
|
|
TexCacheEntry(TexCacheEntry* prevt,TexCacheEntry* nextt,TexEntryType* textt)
|
|
{
|
|
prev=prevt;
|
|
next=nextt;
|
|
if (textt)
|
|
data=*textt;
|
|
}
|
|
TexCacheEntry* prev;
|
|
TexCacheEntry* next;
|
|
TexEntryType data;
|
|
};
|
|
u32 textures;
|
|
TexCacheEntry* pfirst;
|
|
TexCacheEntry* plast;
|
|
|
|
TexCacheList()
|
|
{
|
|
pfirst=0;
|
|
plast=0;
|
|
textures=0;
|
|
}
|
|
|
|
|
|
TexEntryType* __fastcall Find(u32 tcw,u32 tsp)
|
|
{
|
|
TexCacheEntry* pl= this->pfirst;
|
|
while (pl)
|
|
{
|
|
if (pl->data.tcw.full==tcw && pl->data.tsp.full==tsp)
|
|
{
|
|
if (pl->prev!=0)//its not the first one
|
|
{
|
|
if (pl->next==0)
|
|
{
|
|
//if last one then , the last one is the previous
|
|
plast=pl->prev;
|
|
}
|
|
|
|
//remove the texture from the list
|
|
textures++;//one is counted down by remove ;)
|
|
Remove(pl);
|
|
|
|
//add it on top
|
|
pl->prev=0; //no prev , we are first
|
|
pl->next=pfirst; //after us is the old first
|
|
pfirst->prev=pl; //we are before the old first
|
|
|
|
//replace pfirst pointer
|
|
pfirst=pl;
|
|
|
|
}
|
|
return &pl->data;
|
|
}
|
|
else
|
|
pl=pl->next;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
TexCacheEntry* Add(TexEntryType* text )
|
|
{
|
|
if (pfirst==0)
|
|
{
|
|
if (plast!=0)
|
|
{
|
|
printf("Texture Cache Error , pfirst!=0 && plast==0\n");
|
|
}
|
|
pfirst=plast=new TexCacheEntry(0,0,text);
|
|
}
|
|
else
|
|
{
|
|
pfirst=new TexCacheEntry(0,pfirst,text);
|
|
pfirst->next->prev=pfirst;
|
|
}
|
|
|
|
textures++;
|
|
return pfirst;
|
|
}
|
|
void Remove(TexCacheEntry* texture)
|
|
{
|
|
textures--;
|
|
if (texture==pfirst)
|
|
{
|
|
if (texture->next)
|
|
pfirst=texture->next;
|
|
else
|
|
pfirst=0;
|
|
}
|
|
if (texture==plast)
|
|
{
|
|
if (texture->prev)
|
|
plast=texture->prev;
|
|
else
|
|
plast=0;
|
|
}
|
|
|
|
//if not last one , remove it from next
|
|
if (texture->next!=0)
|
|
texture->next->prev=texture->prev;
|
|
//if not first one , remove it from prev
|
|
if (texture->prev!=0)
|
|
texture->prev->next=texture->next;
|
|
}
|
|
};
|
|
|
|
|
|
//Pixel buffer class (realy helpfull ;) )
|
|
struct PixelBuffer
|
|
{
|
|
u32* p_buffer_start;
|
|
u32* p_current_line;
|
|
u32* p_current_pixel;
|
|
|
|
u32 pixels_per_line;
|
|
|
|
void init(void* data,u32 ppl_bytes)
|
|
{
|
|
p_buffer_start=p_current_line=p_current_pixel=(u32*)data;
|
|
pixels_per_line=ppl_bytes/sizeof(u32);
|
|
}
|
|
INLINE void prel(u32 x,u32 value)
|
|
{
|
|
p_current_pixel[x]=value;
|
|
}
|
|
|
|
INLINE void prel(u32 x,u32 y,u32 value)
|
|
{
|
|
p_current_pixel[y*pixels_per_line+x]=value;
|
|
}
|
|
|
|
INLINE void rmovex(u32 value)
|
|
{
|
|
p_current_pixel+=value;
|
|
}
|
|
INLINE void rmovey(u32 value)
|
|
{
|
|
p_current_line+=pixels_per_line*value;
|
|
p_current_pixel=p_current_line;
|
|
}
|
|
INLINE void amove(u32 x_m,u32 y_m)
|
|
{
|
|
//p_current_pixel=p_buffer_start;
|
|
p_current_line=p_buffer_start+pixels_per_line*y_m;
|
|
p_current_pixel=p_current_line + x_m;
|
|
}
|
|
};
|
|
|
|
//Generic texture cache / texture format conevertion code / macros
|
|
extern u32 unpack_4_to_8_tw[16];
|
|
extern u32 unpack_5_to_8_tw[32];
|
|
extern u32 unpack_6_to_8_tw[64];
|
|
|
|
void palette_update();
|
|
|
|
const u32 unpack_1_to_8[2]={0,0xFF};
|
|
|
|
#define clamp(minv,maxv,x) min(maxv,max(minv,x))
|
|
|
|
#define ARGB8888(A,R,G,B) \
|
|
PixelPacker::pack(A,R,G,B)
|
|
|
|
#define ARGB1555_PL( word ) \
|
|
ARGB8888(unpack_1_to_8[(word>>15)&1],((word>>10) & 0x1F)<<3, \
|
|
((word>>5) & 0x1F)<<3,(word&0x1F)<<3)
|
|
|
|
#define ARGB565_PL( word ) \
|
|
ARGB8888(0xFF,((word>>11) & 0x1F)<<3, \
|
|
((word>>5) & 0x3F)<<2,(word&0x1F)<<3)
|
|
|
|
#define ARGB4444_PL( word ) \
|
|
ARGB8888( (word&0xF000)>>(12-4),(word&0xF00)>>(8-4),(word&0xF0)>>(4-4),(word&0xF)<<4 )
|
|
|
|
|
|
#define ARGB1555_TW( word ) \
|
|
ARGB8888(unpack_1_to_8[(word>>15)&1],unpack_5_to_8_tw[(word>>10) & 0x1F], \
|
|
unpack_5_to_8_tw[(word>>5) & 0x1F],unpack_5_to_8_tw[word&0x1F])
|
|
|
|
#define ARGB565_TW( word ) \
|
|
ARGB8888(0xFF,unpack_5_to_8_tw[(word>>11) & 0x1F], \
|
|
unpack_6_to_8_tw[(word>>5) & 0x3F],unpack_5_to_8_tw[word&0x1F])
|
|
//( 0xFF000000 | unpack_5_to_8[(word>>11) & 0x1F] | unpack_5_to_8[(word>>5) & 0x3F]<<8 | unpack_5_to_8[word&0x1F]<<16 )
|
|
|
|
#define ARGB4444_TW( word ) \
|
|
ARGB8888( unpack_4_to_8_tw[(word&0xF000)>>(12)],unpack_4_to_8_tw[(word&0xF00)>>(8)],unpack_4_to_8_tw[(word&0xF0)>>(4)],unpack_4_to_8_tw[(word&0xF)] )
|
|
|
|
template<class PixelPacker>
|
|
INLINE u32 YUV422(s32 Y,s32 Yu,s32 Yv)
|
|
{
|
|
Yu-=128;
|
|
Yv-=128;
|
|
|
|
//s32 B = (76283*(Y - 16) + 132252*(Yu - 128))>>16;
|
|
//s32 G = (76283*(Y - 16) - 53281 *(Yv - 128) - 25624*(Yu - 128))>>16;
|
|
//s32 R = (76283*(Y - 16) + 104595*(Yv - 128))>>16;
|
|
|
|
s32 R = Y + Yv*11/8; // Y + (Yv-128) * (11/8) ?
|
|
s32 G = Y - (Yu*11 + Yv*22)/32; // Y - (Yu-128) * (11/8) * 0.25 - (Yv-128) * (11/8) * 0.5 ?
|
|
s32 B = Y + Yu*110/64; // Y + (Yu-128) * (11/8) * 1.25 ?
|
|
|
|
return ARGB8888(255,clamp(0,255,R),clamp(0,255,G),clamp(0,255,B));
|
|
}
|
|
|
|
u32 fastcall twiddle_fast(u32 x,u32 y,u32 x_sz,u32 y_sz);
|
|
#define twop twiddle_fast
|
|
|
|
//pixel packers !
|
|
struct pp_dx
|
|
{
|
|
INLINE
|
|
static u32 pack(u8 A,u8 R,u8 G,u8 B)
|
|
{
|
|
return ( ((A)<<24) | ((R)<<16) | ((G)<<8) | ((B)<<0));
|
|
}
|
|
};
|
|
struct pp_gl
|
|
{
|
|
INLINE
|
|
static u32 pack(u8 A,u8 R,u8 G,u8 B)
|
|
{
|
|
return ( ((A)<<24) | ((B)<<16) | ((G)<<8) | ((R)<<0));
|
|
}
|
|
};
|
|
|
|
//pixel convertors !
|
|
#define pixelcvt_start(name,x,y) template<class PixelPacker> \
|
|
struct name \
|
|
{ \
|
|
static const u32 xpp=x;\
|
|
static const u32 ypp=y; \
|
|
INLINE static void fastcall Convert(PixelBuffer* pb,u8* data) \
|
|
{
|
|
|
|
#define pixelcvt_end } }
|
|
#define pixelcvt_next(name,x,y) pixelcvt_end; pixelcvt_start(name,x,y)
|
|
//Non twiddled
|
|
pixelcvt_start(conv565_PL,4,1)
|
|
{
|
|
//convert 4x1 565 to 4x1 8888
|
|
u16* p_in=(u16*)data;
|
|
//0,0
|
|
pb->prel(0,ARGB565_PL(p_in[0^1]));
|
|
//1,0
|
|
pb->prel(1,ARGB565_PL(p_in[1^1]));
|
|
//2,0
|
|
pb->prel(2,ARGB565_PL(p_in[2^1]));
|
|
//3,0
|
|
pb->prel(3,ARGB565_PL(p_in[3^1]));
|
|
}
|
|
pixelcvt_next(conv1555_PL,4,1) //ok
|
|
{
|
|
//convert 4x1 1555 to 4x1 8888
|
|
u16* p_in=(u16*)data;
|
|
//0,0
|
|
pb->prel(0,ARGB1555_PL(p_in[0^1]));
|
|
//1,0
|
|
pb->prel(1,ARGB1555_PL(p_in[1^1]));
|
|
//2,0
|
|
pb->prel(2,ARGB1555_PL(p_in[2^1]));
|
|
//3,0
|
|
pb->prel(3,ARGB1555_PL(p_in[3^1]));
|
|
}
|
|
pixelcvt_next(conv4444_PL,4,1) //ok
|
|
{
|
|
//convert 4x1 4444 to 4x1 8888
|
|
u16* p_in=(u16*)data;
|
|
//0,0
|
|
pb->prel(0,ARGB4444_PL(p_in[0^1]));
|
|
//1,0
|
|
pb->prel(1,ARGB4444_PL(p_in[1^1]));
|
|
//2,0
|
|
pb->prel(2,ARGB4444_PL(p_in[2^1]));
|
|
//3,0
|
|
pb->prel(3,ARGB4444_PL(p_in[3^1]));
|
|
}
|
|
pixelcvt_next(convYUV_PL,4,1)
|
|
{
|
|
//convert 4x1 4444 to 4x1 8888
|
|
u32* p_in=(u32*)data;
|
|
|
|
|
|
s32 Y0 = (p_in[0]>>8) &255; //
|
|
s32 Yu = (p_in[0]>>0) &255; //p_in[0]
|
|
s32 Y1 = (p_in[0]>>24) &255; //p_in[3]
|
|
s32 Yv = (p_in[0]>>16) &255; //p_in[2]
|
|
|
|
//0,0
|
|
pb->prel(0,YUV422<PixelPacker>(Y0,Yu,Yv));
|
|
//1,0
|
|
pb->prel(1,YUV422<PixelPacker>(Y1,Yu,Yv));
|
|
|
|
//next 4 bytes
|
|
p_in+=1;
|
|
|
|
Y0 = (p_in[0]>>8) &255; //
|
|
Yu = (p_in[0]>>0) &255; //p_in[0]
|
|
Y1 = (p_in[0]>>24) &255; //p_in[3]
|
|
Yv = (p_in[0]>>16) &255; //p_in[2]
|
|
|
|
//0,0
|
|
pb->prel(2,YUV422<PixelPacker>(Y0,Yu,Yv));
|
|
//1,0
|
|
pb->prel(3,YUV422<PixelPacker>(Y1,Yu,Yv));
|
|
}
|
|
pixelcvt_end;
|
|
//twiddled
|
|
pixelcvt_start(conv565_TW,2,2) //ok?
|
|
{
|
|
//convert 4x1 565 to 4x1 8888
|
|
u16* p_in=(u16*)data;
|
|
//0,0
|
|
pb->prel(0,0,ARGB565_TW(p_in[0^1]));
|
|
//0,1
|
|
pb->prel(0,1,ARGB565_TW(p_in[1^1]));
|
|
//1,0
|
|
pb->prel(1,0,ARGB565_TW(p_in[2^1]));
|
|
//1,1
|
|
pb->prel(1,1,ARGB565_TW(p_in[3^1]));
|
|
}
|
|
pixelcvt_next(conv1555_TW,2,2) //ok?
|
|
{
|
|
//convert 4x1 1555 to 4x1 8888
|
|
u16* p_in=(u16*)data;
|
|
//0,0
|
|
pb->prel(0,0,ARGB1555_TW(p_in[0^1]));
|
|
//0,1
|
|
pb->prel(0,1,ARGB1555_TW(p_in[1^1]));
|
|
//1,0
|
|
pb->prel(1,0,ARGB1555_TW(p_in[2^1]));
|
|
//1,1
|
|
pb->prel(1,1,ARGB1555_TW(p_in[3^1]));
|
|
}
|
|
pixelcvt_next(conv4444_TW,2,2) //ok
|
|
{
|
|
//convert 4x1 4444 to 4x1 8888
|
|
u16* p_in=(u16*)data;
|
|
//0,0
|
|
pb->prel(0,0,ARGB4444_TW(p_in[0^1]));
|
|
//0,1
|
|
pb->prel(0,1,ARGB4444_TW(p_in[1^1]));
|
|
//1,0
|
|
pb->prel(1,0,ARGB4444_TW(p_in[2^1]));
|
|
//1,1
|
|
pb->prel(1,1,ARGB4444_TW(p_in[3^1]));
|
|
}
|
|
pixelcvt_next(convYUV_TW,2,2)
|
|
{
|
|
//convert 4x1 4444 to 4x1 8888
|
|
u16* p_in=(u16*)data;
|
|
|
|
|
|
s32 Y0 = (p_in[0^1]>>8) &255; //
|
|
s32 Yu = (p_in[0^1]>>0) &255; //p_in[0]
|
|
s32 Y1 = (p_in[2^1]>>8) &255; //p_in[3]
|
|
s32 Yv = (p_in[2^1]>>0) &255; //p_in[2]
|
|
|
|
//0,0
|
|
pb->prel(0,0,YUV422<PixelPacker>(Y0,Yu,Yv));
|
|
//1,0
|
|
pb->prel(1,0,YUV422<PixelPacker>(Y1,Yu,Yv));
|
|
|
|
//next 4 bytes
|
|
//p_in+=2;
|
|
|
|
Y0 = (p_in[1^1]>>8) &255; //
|
|
Yu = (p_in[1^1]>>0) &255; //p_in[0]
|
|
Y1 = (p_in[3^1]>>8) &255; //p_in[3]
|
|
Yv = (p_in[3^1]>>0) &255; //p_in[2]
|
|
|
|
//0,1
|
|
pb->prel(0,1,YUV422<PixelPacker>(Y0,Yu,Yv));
|
|
//1,1
|
|
pb->prel(1,1,YUV422<PixelPacker>(Y1,Yu,Yv));
|
|
}
|
|
pixelcvt_end;
|
|
|
|
pixelcvt_start(convPAL4_TW,4,4)
|
|
{
|
|
u8* p_in=(u8*)data;
|
|
u32* pal=&palette_lut[palette_index];
|
|
|
|
pb->prel(0^1,0^2,pal[p_in[0]&0xF]);
|
|
pb->prel(0^1,1^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
pb->prel(1^1,0^2,pal[p_in[0]&0xF]);
|
|
pb->prel(1^1,1^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
|
|
pb->prel(0^1,2^2,pal[p_in[0]&0xF]);
|
|
pb->prel(0^1,3^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
pb->prel(1^1,2^2,pal[p_in[0]&0xF]);
|
|
pb->prel(1^1,3^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
|
|
pb->prel(2^1,0^2,pal[p_in[0]&0xF]);
|
|
pb->prel(2^1,1^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
pb->prel(3^1,0^2,pal[p_in[0]&0xF]);
|
|
pb->prel(3^1,1^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
|
|
pb->prel(2^1,2^2,pal[p_in[0]&0xF]);
|
|
pb->prel(2^1,3^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
pb->prel(3^1,2^2,pal[p_in[0]&0xF]);
|
|
pb->prel(3^1,3^2,pal[(p_in[0]>>4)&0xF]);p_in++;
|
|
}
|
|
pixelcvt_next(convPAL8_TW,2,4)
|
|
{
|
|
u8* p_in=(u8*)data;
|
|
u32* pal=&palette_lut[palette_index];
|
|
|
|
pb->prel(0^1,0^1,pal[p_in[0]]);p_in++;
|
|
pb->prel(0^1,1^1,pal[p_in[0]]);p_in++;
|
|
pb->prel(1^1,0^1,pal[p_in[0]]);p_in++;
|
|
pb->prel(1^1,1^1,pal[p_in[0]]);p_in++;
|
|
|
|
pb->prel(0^1,2^1,pal[p_in[0]]);p_in++;
|
|
pb->prel(0^1,3^1,pal[p_in[0]]);p_in++;
|
|
pb->prel(1^1,2^1,pal[p_in[0]]);p_in++;
|
|
pb->prel(1^1,3^1,pal[p_in[0]]);p_in++;
|
|
}
|
|
pixelcvt_next(convPAL4_X_TW,4,4)
|
|
{
|
|
u8* p_in=(u8*)data;
|
|
//20 -> 16 + 4 (*16 to fixup step size)
|
|
//goes to red
|
|
pb->prel(0^1,0^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(0^1,1^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
pb->prel(1^1,0^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(1^1,1^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
|
|
pb->prel(0^1,2^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(0^1,3^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
pb->prel(1^1,2^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(1^1,3^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
|
|
pb->prel(2^1,0^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(2^1,1^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
pb->prel(3^1,0^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(3^1,1^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
|
|
pb->prel(2^1,2^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(2^1,3^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
pb->prel(3^1,2^2,(p_in[0]&0xF)<<20);
|
|
pb->prel(3^1,3^2,(p_in[0]&0xF0)<<16);p_in++;
|
|
}
|
|
pixelcvt_next(convPAL8_X_TW,2,4)
|
|
{
|
|
u8* p_in=(u8*)data;
|
|
// 4+16 (red) | 4+6 (2+8) green
|
|
#define COL ((p_in[0]&0xF)<<20) | ((p_in[0]&0xF0)<<6)
|
|
pb->prel(0^1,0^1,COL);p_in++;
|
|
pb->prel(0^1,1^1,COL);p_in++;
|
|
pb->prel(1^1,0^1,COL);p_in++;
|
|
pb->prel(1^1,1^1,COL);p_in++;
|
|
|
|
pb->prel(0^1,2^1,COL);p_in++;
|
|
pb->prel(0^1,3^1,COL);p_in++;
|
|
pb->prel(1^1,2^1,COL);p_in++;
|
|
pb->prel(1^1,3^1,COL);p_in++;
|
|
}
|
|
pixelcvt_end;
|
|
//hanlder functions
|
|
template<class PixelConvertor>
|
|
void fastcall texture_PL(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height)
|
|
{
|
|
//u32 p=0;
|
|
pb->amove(0,0);
|
|
|
|
Height/=PixelConvertor::ypp;
|
|
Width/=PixelConvertor::xpp;
|
|
|
|
for (u32 y=0;y<Height;y++)
|
|
{
|
|
for (u32 x=0;x<Width;x++)
|
|
{
|
|
u8* p = p_in;
|
|
////if ((u32)p>=0x07200000)
|
|
// p=(u8*)0x07100000;
|
|
PixelConvertor::Convert(pb,p);
|
|
p_in+=8;
|
|
|
|
pb->rmovex(PixelConvertor::xpp);
|
|
}
|
|
pb->rmovey(PixelConvertor::ypp);
|
|
}
|
|
}
|
|
template <int bore_level>
|
|
void fastcall texture_PL_RAW(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height)
|
|
{
|
|
u32 sz=Width*2;
|
|
Height>>=1; //half
|
|
|
|
pb->amove(0,0);
|
|
pb->pixels_per_line>>=1; //half y res , since we use 16 bit color
|
|
|
|
for (u32 y=0;y<Height;y++)
|
|
{
|
|
memcpy(pb->p_current_line,p_in,sz);
|
|
p_in+=sz;
|
|
pb->rmovey(1);
|
|
}
|
|
}
|
|
|
|
template<class PixelConvertor>
|
|
void fastcall texture_TW(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height)
|
|
{
|
|
//u32 p=0;
|
|
pb->amove(0,0);
|
|
|
|
const u32 divider=PixelConvertor::xpp*PixelConvertor::ypp;
|
|
|
|
unsigned long bcx_,bcy_;
|
|
_BitScanReverse(&bcx_,Width);
|
|
_BitScanReverse(&bcy_,Height);
|
|
const u32 bcx=bcx_-3;
|
|
const u32 bcy=bcy_-3;
|
|
|
|
for (u32 y=0;y<Height;y+=PixelConvertor::ypp)
|
|
{
|
|
for (u32 x=0;x<Width;x+=PixelConvertor::xpp)
|
|
{
|
|
u8* p = &p_in[(twop(x,y,bcx,bcy)/divider)<<3];
|
|
PixelConvertor::Convert(pb,p);
|
|
|
|
pb->rmovex(PixelConvertor::xpp);
|
|
}
|
|
pb->rmovey(PixelConvertor::ypp);
|
|
}
|
|
}
|
|
|
|
template<class PixelConvertor>
|
|
void fastcall texture_VQ(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height)
|
|
{
|
|
p_in+=256*4*2;
|
|
//u32 p=0;
|
|
pb->amove(0,0);
|
|
|
|
const u32 divider=PixelConvertor::xpp*PixelConvertor::ypp;
|
|
unsigned long bcx_,bcy_;
|
|
_BitScanReverse(&bcx_,Width);
|
|
_BitScanReverse(&bcy_,Height);
|
|
const u32 bcx=bcx_-3;
|
|
const u32 bcy=bcy_-3;
|
|
|
|
for (u32 y=0;y<Height;y+=PixelConvertor::ypp)
|
|
{
|
|
for (u32 x=0;x<Width;x+=PixelConvertor::xpp)
|
|
{
|
|
u8 p = p_in[twop(x,y,bcx,bcy)/divider];
|
|
PixelConvertor::Convert(pb,&vq_codebook[p*8]);
|
|
|
|
pb->rmovex(PixelConvertor::xpp);
|
|
}
|
|
pb->rmovey(PixelConvertor::ypp);
|
|
}
|
|
}
|
|
|
|
//We ask the compiler to generate the templates here
|
|
//;)
|
|
//planar formats !
|
|
template void fastcall texture_PL<conv4444_PL<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_PL<conv565_PL<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_PL<conv1555_PL<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_PL<convYUV_PL<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
|
|
//twiddled formats !
|
|
template void fastcall texture_TW<conv4444_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_TW<conv565_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_TW<conv1555_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_TW<convYUV_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_TW<convPAL4_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_TW<convPAL8_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
|
|
//VQ formats !
|
|
template void fastcall texture_VQ<conv4444_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_VQ<conv565_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_VQ<conv1555_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
template void fastcall texture_VQ<convYUV_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
//template void fastcall texture_VQ<convPAL4_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
//template void fastcall texture_VQ<convPAL8_TW<pp_dx> >(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
|
|
//Planar
|
|
#define argb1555to8888 texture_PL<conv1555_PL<pp_dx> >
|
|
#define argb565to8888 texture_PL<conv565_PL<pp_dx> >
|
|
#define argb4444to8888 texture_PL<conv4444_PL<pp_dx> >
|
|
#define YUV422to8888 texture_PL<convYUV_PL<pp_dx> >
|
|
#define ANYtoRAW texture_PL_RAW<1>
|
|
|
|
//Twiddle
|
|
#define argb1555to8888_TW texture_TW<conv1555_TW<pp_dx> >
|
|
#define argb565to8888_TW texture_TW<conv565_TW<pp_dx> >
|
|
#define argb4444to8888_TW texture_TW<conv4444_TW<pp_dx> >
|
|
#define YUV422to8888_TW texture_TW<convYUV_TW<pp_dx> >
|
|
#define PAL4to8888_TW texture_TW<convPAL4_TW<pp_dx> >
|
|
#define PAL8to8888_TW texture_TW<convPAL8_TW<pp_dx> >
|
|
#define PAL4toX444_TW texture_TW<convPAL4_X_TW<pp_dx> >
|
|
#define PAL8toX444_TW texture_TW<convPAL8_X_TW<pp_dx> >
|
|
|
|
//VQ
|
|
#define argb1555to8888_VQ texture_VQ<conv1555_TW<pp_dx> >
|
|
#define argb565to8888_VQ texture_VQ<conv565_TW<pp_dx> >
|
|
#define argb4444to8888_VQ texture_VQ<conv4444_TW<pp_dx> >
|
|
#define YUV422to8888_VQ texture_VQ<convYUV_TW<pp_dx> >
|
|
//#define PAL4to8888_VQ texture_VQ<convPAL4_TW<pp_dx> >
|
|
//#define PAL8to8888_VQ texture_VQ<convPAL8_TW<pp_dx> >
|
|
|
|
/*
|
|
void fastcall texture_VQ_argb565(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
void fastcall texture_VQ_argb1555(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
void fastcall texture_VQ_argb4444(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
void fastcall texture_VQ_YUV422(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
void fastcall texture_VQ_PAL4(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
void fastcall texture_VQ_PAL8(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
*/
|
|
|
|
void fastcall texture_PAL4(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
void fastcall texture_PAL8(PixelBuffer* pb,u8* p_in,u32 Width,u32 Height);
|
|
|
|
|