void Texture::Create( int width, int height, bool palettized, const unsigned char* pal, const unsigned char* data, ResizeMode resize_mode, bool build_palettized_lods )
{
original_size_x= width;
original_size_y= height;
is_palettized_texture= palettized;
if( resize_mode != RESIZE_NO )
ResizeToNearestPOTCeil( data, resize_mode );//resize and allocate memory
else
{
size_x= width;
size_y= height;
size_x_log2= Log2Ceil( size_x );
size_y_log2= Log2Ceil( size_y );
if( (1<<size_x_log2) > size_x ) size_x_log2--;
if( (1<<size_y_log2) > size_y ) size_y_log2--;
if(this->data!=NULL) delete[] this->data;
int data_size= width * height;
if(!palettized)
data_size<<=2;
this->data= new unsigned char[data_size];
memcpy(this->data, data, data_size);
}
if( is_palettized_texture )
{
this->palette= new unsigned char[ 4 * 256 ];
//this->palette= (unsigned char*) malloc( 1024 + 4 * 256 );
memcpy( this->palette, pal, 4 * 256 );
}
lods_data[0]= this->data;
int i;
for( i= 1; i< size_x_log2 && i< size_y_log2; i++ )
{
int sx= size_x>>i;
int sy= size_y>>i;
if( is_palettized_texture )
{
if( lods_data[i] != NULL ) delete[] lods_data[i];
lods_data[i]= new unsigned char[ sx * sy ];
if( data != NULL )
{
if( build_palettized_lods )
GenLodPlaettized( sx<<1, sy<<1, lods_data[i-1], lods_data[i] );
}
}
else
{
if( lods_data[i] != NULL ) delete[] lods_data[i];
lods_data[i]= new unsigned char[ sx * sy * 4 ];
if( data != NULL )
GenLod( sx<<1, sy<<1, lods_data[i-1], lods_data[i] );
}
}
max_lod= FastIntMin( size_x_log2, size_y_log2 )-1;
}
FFTHelper::FFTHelper ( UInt32 inMaxFramesPerSlice )
: mSpectrumAnalysis(NULL),
mFFTNormFactor(1.0/(2*inMaxFramesPerSlice)),
mFFTLength(inMaxFramesPerSlice/2),
mLog2N(Log2Ceil(inMaxFramesPerSlice))
{
mDspSplitComplex.realp = (Float32*) calloc(mFFTLength,sizeof(Float32));
mDspSplitComplex.imagp = (Float32*) calloc(mFFTLength, sizeof(Float32));
mSpectrumAnalysis = vDSP_create_fftsetup(mLog2N, kFFTRadix2);
}
FFTBufferManager::FFTBufferManager(UInt32 inNumberFrames) :
mNeedsAudioData(0),
mHasAudioData(0),
mFFTNormFactor(1.0/(2*inNumberFrames)),
mAdjust0DB(1.5849e-13),
m24BitFracScale(16777216.0f),
mFFTLength(inNumberFrames/2),
mLog2N(Log2Ceil(inNumberFrames)),
mNumberFrames(inNumberFrames),
mAudioBufferSize(inNumberFrames * sizeof(Float32)),
mAudioBufferCurrentIndex(0)
{
mAudioBuffer = (Float32*) calloc(mNumberFrames,sizeof(Float32));
mDspSplitComplex.realp = (Float32*) calloc(mFFTLength,sizeof(Float32));
mDspSplitComplex.imagp = (Float32*) calloc(mFFTLength, sizeof(Float32));
mSpectrumAnalysis = vDSP_create_fftsetup(mLog2N, kFFTRadix2);
OSAtomicIncrement32Barrier(&mNeedsAudioData);
}
void Texture::ResizeToNearestPOTCeil( const unsigned char* in_data, ResizeMode resize_mode )
{
size_x_log2= Log2Ceil( original_size_x );
size_y_log2= Log2Ceil( original_size_y );
size_x= 1<<size_x_log2;
size_y= 1<<size_y_log2;
int tex_data_size= is_palettized_texture ? (size_x * size_y) : (size_x * size_y * 4);
//data= (unsigned char*) malloc( tex_data_size);
if( data != NULL ) delete[] data;
data= new unsigned char[ tex_data_size ];
if( in_data == NULL )
return;//nothing to do
if( size_x == original_size_x && size_y == original_size_y )
{//simple copying of src texture data
memcpy( data, in_data, tex_data_size );
return;
}
//int x2x_new= 65536 * original_size_x / size_x;
//int y2y_new= 65536 * original_size_y / size_y;
int x2x_new= ( 65536 * original_size_x )>> size_x_log2;
int y2y_new= ( 65536 * original_size_y )>> size_y_log2;
if( ! is_palettized_texture )
{//copy per int
if( resize_mode == RESIZE_STRETCH )
{
for( int y= 0; y< size_y; y++ )
for( int x= 0; x< size_x; x++ )
{
//make linear color interpolation
int old_x= (x*x2x_new);
int old_y= (y*y2y_new);
int dx= (old_x>>8)&0xFF;
int dy= (old_y>>8)&0xFF;
old_x>>=16; old_y>>= 16;
int old_x1= old_x+1, old_y1= old_y+1;
int dx1= 255 - dx, dy1= 255 - dy;
int colors[16];
int mixed_colors[8];
int addr= (old_x + old_y *original_size_x)<<2;
colors[0 ]= in_data[addr ];
colors[1 ]= in_data[addr+1];
colors[2 ]= in_data[addr+2];
colors[3 ]= in_data[addr+3];
addr= (old_x1 + old_y *original_size_x)<<2;
colors[4 ]= in_data[addr ];
colors[5 ]= in_data[addr+1];
colors[6 ]= in_data[addr+2];
colors[7 ]= in_data[addr+3];
addr= (old_x + old_y1 *original_size_x)<<2;
colors[8 ]= in_data[addr ];
colors[9 ]= in_data[addr+1];
colors[10]= in_data[addr+2];
colors[11]= in_data[addr+3];
addr= (old_x1 + old_y1 *original_size_x)<<2;
colors[12]= in_data[addr ];
colors[13]= in_data[addr+1];
colors[14]= in_data[addr+2];
colors[15]= in_data[addr+3];
mixed_colors[0]= ( colors[ 0] * dx1 + colors[ 4] * dx );
mixed_colors[1]= ( colors[ 1] * dx1 + colors[ 5] * dx );
mixed_colors[2]= ( colors[ 2] * dx1 + colors[ 6] * dx );
mixed_colors[3]= ( colors[ 3] * dx1 + colors[ 7] * dx );
mixed_colors[4]= ( colors[ 8] * dx1 + colors[12] * dx );
mixed_colors[5]= ( colors[ 9] * dx1 + colors[13] * dx );
mixed_colors[6]= ( colors[10] * dx1 + colors[14] * dx );
mixed_colors[7]= ( colors[11] * dx1 + colors[15] * dx );
unsigned char* out_color= data + (x + (y<<size_x_log2));
out_color[0]= ( mixed_colors[0] * dy1 + mixed_colors[4] * dy ) >> 16;
out_color[1]= ( mixed_colors[1] * dy1 + mixed_colors[5] * dy ) >> 16;
out_color[2]= ( mixed_colors[2] * dy1 + mixed_colors[6] * dy ) >> 16;
out_color[3]= ( mixed_colors[3] * dy1 + mixed_colors[7] * dy ) >> 16;
//nearest filter
/*((int*)data)[ x + (y<<size_x_log2) ]=
((int*)in_data)[ ((x*x2x_new)>>16) + ((y*y2y_new)>>16) * original_size_x ];*/
}
}//if stretch resize
else
{
for( int y= 0; y< original_size_y; y++ )
for( int x= 0; x< original_size_x; x++ )
{
((int*)data)[ x + (y<<size_x_log2) ]=
((int*)in_data)[ x + y * original_size_x ];
}
int border_color;
for( int x= 0; x< original_size_x; x++ )
{
border_color= ((int*)in_data)[ x + (original_size_y-1) * original_size_x ];
for( int y= original_size_y; y< size_y; y++ )
((int*)data)[ x + (y<<size_x_log2) ]= border_color;
}
for( int y= 0; y< original_size_y; y++ )
{
border_color= ((int*)in_data)[ (original_size_x-1) + y * original_size_x ];
for( int x= original_size_x; x< size_x; x++ )
((int*)data)[ x + (y<<size_x_log2) ]= border_color;
}
border_color= ((int*)in_data)[ (original_size_x-1) + (original_size_y-1) * original_size_x ];
for( int y= original_size_y; y< size_y; y++ )
for( int x= original_size_x; x< size_x; x++ )
((int*)data)[ x + (y<<size_x_log2) ]= border_color;
}
}
