void BitKey::ReAllocate(uint32_t i_len)
{
if(i_len > iv_Capacity) // never shrink
{
bool wasDirect = IsDirect();
uint32_t oldSize = iv_Capacity;
uint32_t * oldPtr = DataPtr();
uint32_t wordsize = getWordSize(i_len);
iv_Capacity = 32*wordsize;
bool isDirect = IsDirect();
if(!isDirect) // to indirect
{
uint32_t * newBuffer = new uint32_t[wordsize];
BitString dbs(iv_Capacity,newBuffer);
dbs.Pattern(0x00000000);
BitString sbs(oldSize,oldPtr);
dbs.SetBits(sbs);
iv_storage1 = 0;
if(!wasDirect) // from indirect
{
delete [] iv_rep.buffer;
}
iv_rep.buffer = newBuffer;
}
}
}
BitKey & BitKey::operator=(const BitKey & bit_list)
{
if(iv_Capacity)
{
BitString bs(iv_Capacity,DataPtr());
bs.Pattern(0x00000000);
}
ReAllocate(bit_list.iv_Capacity);
if(IsDirect()) // implies bit_list is also direct
{
iv_storage1 = bit_list.iv_storage1;
iv_rep.storage2 = bit_list.iv_rep.storage2;
}
else
{
const uint32_t * dataPtr = NULL;
if(bit_list.IsDirect())
{
dataPtr = &bit_list.iv_storage1;
} else
{
dataPtr = bit_list.iv_rep.buffer;
}
memcpy(iv_rep.buffer,dataPtr,4*getWordSize(bit_list.iv_Capacity));
}
return(*this);
}
BitKey::BitKey (const BitKey & bit_list)
: iv_Capacity(bit_list.iv_Capacity), iv_storage1(bit_list.iv_storage1)
{
if(IsDirect())
{
iv_rep.storage2 = bit_list.iv_rep.storage2;
}
else
{
uint32_t size = getWordSize(iv_Capacity);
iv_rep.buffer = new uint32_t[size];
memcpy(iv_rep.buffer,bit_list.iv_rep.buffer,4*size);
}
}
COR_EXPORT(Image*) CorConvertPalette(
Image* image,
PixelFormat palette_format)
{
// do we need to convert?
if (!image ||
palette_format == PF_DONTCARE ||
image->getPaletteFormat() == palette_format)
{
return image;
}
// do we have invalid data?
if (!IsPalettized(image->getFormat()) ||
!IsDirect(palette_format))
{
delete image;
return 0;
}
const int width = image->getWidth();
const int height = image->getHeight();
const PixelFormat format = image->getFormat();
const int palette_size = image->getPaletteSize();
// the palette indices don't change, so just make a copy
const int image_size = width * height * GetPixelSize(format);
byte* pixels = new byte[image_size];
std::memcpy(pixels, image->getPixels(), image_size);
byte* new_palette = new byte[
palette_size * GetPixelSize(palette_format)];
if (!ConvertPixels(new_palette, palette_format,
(byte*)image->getPalette(), image->getPaletteFormat(),
palette_size))
{
delete image;
delete[] pixels;
delete[] new_palette;
return 0;
}
delete image;
return new SimpleImage(
width, height, format, pixels,
new_palette, palette_size, palette_format);
}
BitKey::~BitKey(void)
{
if(!IsDirect()) delete [] iv_rep.buffer;
}
