int darkenColor( int c, int percent )
{
int r = (GET_RED( c ) * percent) / 100;
int g = (GET_GREEN( c ) * percent) / 100;
int b = (GET_BLUE( c ) * percent) / 100;
return RGB(r,g,b);
}
static void RedrawCanvasImage(Canvas *C,
int FromX,
int ToX,
int FromY,
int ToY) {
CanvasExtension *CE=CExt(C);
int SwapRedAndBlue = CE->Image->red_mask != ONLY_RED;
for (int Y=FromY; Y<=ToY; Y++)
for (int X=FromX; X<=ToX; X++)
if (TestImage)
XPutPixel(CE->Image,X,Y,X%(1<<BitPlanes));
else if (BitPlanes==24) {
if(SwapRedAndBlue) {
unsigned p = (CE->Mask)&PIXEL(C,X,Y);
unsigned p1 = (GET_RED(p) << 16) | (GET_GREEN(p) << 8) | GET_BLUE(p);
XPutPixel(CE->Image,X,Y,p1);
} else {
XPutPixel(CE->Image,X,Y,(CE->Mask)&PIXEL(C,X,Y));
}
} else if (BitPlanes==16) {
unsigned p = (CE->Mask)&PIXEL(C,X,Y);
unsigned p_r = GET_RED(p) >> 3;
unsigned p_g = GET_GREEN(p) >> 2;
unsigned p_b = GET_BLUE(p) >> 3;
unsigned short p1 = (p_r << 11) | (p_g << 5) | (p_b);
XPutPixel(CE->Image,X,Y,p1);
} else if (BitPlanes==15) {
int bitmap_save( struct bitmap *m, const char *path )
{
FILE *file;
struct bmp_header header;
int i, j;
unsigned char *scanline, *s;
file = fopen(path,"wb");
if(!file) return 0;
memset(&header,0,sizeof(header));
header.magic1 = 'B';
header.magic2 = 'M';
header.size = m->width*m->height*3;
header.offset = sizeof(header);
header.infosize = sizeof(header)-14;
header.width = m->width;
header.height = m->height;
header.planes = 1;
header.bits = 24;
header.compression = 0;
header.imagesize = m->width*m->height*3;
header.xres = 1000;
header.yres = 1000;
fwrite(&header,1,sizeof(header),file);
/* if the scanline is not a multiple of four, round it up. */
int padlength = 4 - (m->width*3)%4;
if(padlength==4) padlength=0;
scanline = malloc(header.width*3);
for(j=0;j<m->height;j++) {
s = scanline;
for(i=0;i<m->width;i++) {
int rgba = bitmap_get(m,i,j);
*s++ = GET_BLUE(rgba);
*s++ = GET_GREEN(rgba);
*s++ = GET_RED(rgba);
}
fwrite(scanline,1,m->width*3,file);
fwrite(scanline,1,padlength,file);
}
free(scanline);
fclose(file);
return 1;
}
/**
* CParticleEffect::updateParticle
* @date Modified Jun 01, 2006
*/
bool CParticleEffect::updateParticle(float fTime, CParticleManager::SParticle* pParticle)
{
CParticleManager::SParticle* p = pParticle;
p->LivingTime += fTime;
// Check for dead particles
if(p->LivingTime >= m_fEffectLength)
{
return false;
}
else
{
D3DXVECTOR3 vVel = p->Velocity * fTime;
D3DXVECTOR3 vAccel = p->Acceleration * fTime;
D3DXVec3Add(&p->Position, &p->Position, &vVel);
D3DXVec3Add(&p->Velocity, &p->Velocity, &vAccel);
if(m_bBounce && p->Position.y < 0.0f)
{
p->Position.y = 0.0f;
p->Velocity.x /= m_fInvRestitution;
p->Velocity.y = (-p->Velocity.y) / m_fInvRestitution;
p->Velocity.z /= m_fInvRestitution;
}
}
// Update attributes
BYTE cR = GET_RED(p->Color), cG = GET_GREEN(p->Color), cB = GET_BLUE(p->Color), cA = GET_ALPHA(p->Color);
for(size_t j = 0; j < m_vAttributes.size(); ++j)
{
float fScale = m_vAttributes[j]->getValue(p->LivingTime / m_fEffectLength);
switch(m_vAttributes[j]->getType())
{
case CParticleAttribute::ATR_COLORRED: cR = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_COLORGREEN: cG = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_COLORBLUE: cB = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_COLORALPHA: cA = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_SIZE: p->Size = fScale; break;
case CParticleAttribute::ATR_ROTATION: p->Rotation = degreesToRadians(fScale); break;
case CParticleAttribute::ATR_ACCELX: p->Acceleration.x = fScale; break;
case CParticleAttribute::ATR_ACCELY: p->Acceleration.y = fScale; break;
case CParticleAttribute::ATR_ACCELZ: p->Acceleration.z = fScale; break;
}
}
p->Color = D3DCOLOR_ARGB(cA, cR, cG, cB);
return true;
}
Lightpack::RGBCOLOR CLightpack::meanColorFromNV12(BYTE* src, Lightpack::Rect& rect) {
ASSERT(mStride >= mWidth || mStride == 0);
const unsigned int sampleWidth = mStride == 0 ? mWidth : mStride;
const unsigned int pixel_total = sampleWidth * mHeight;
const unsigned int totalPixels = rect.area();
BYTE* Y = src;
BYTE* U = src + pixel_total;
BYTE* V = src + pixel_total + 1;
const int dUV = 2;
BYTE* U_pos = U;
BYTE* V_pos = V;
// YUV420 to RGB
unsigned int totalR = 0, totalG = 0, totalB = 0;
for (int r = 0; r < rect.height; r++) {
int y = r + rect.y;
Y = src + y * sampleWidth + rect.x;
U = src + pixel_total + (y / 2) * sampleWidth + (rect.x & 0x1 ? rect.x - 1 : rect.x);
V = U + 1;
for (int c = 0; c < rect.width; c++) {
Lightpack::RGBCOLOR color = YUVToRGB(*(Y++), *U, *V);
totalR += GET_RED(color);
totalG += GET_GREEN(color);
totalB += GET_BLUE(color);
if ((rect.x + c) & 0x1) {
U += dUV;
V += dUV;
}
}
}
return RGB((int)floor(totalR / totalPixels), (int)floor(totalG / totalPixels), (int)floor(totalB / totalPixels));
}
void http_settings(char *rx, unsigned int rx_len)
{
unsigned int item, found, len;
int i;
char buf[16];
MAC_Addr mac;
IP_Addr ip;
unsigned int rgb;
for(; rx_len!=0;)
{
len = strlen("restartwebradio=");
if(strncmpi(rx, "restartwebradio=", len) == 0)
{
rx += len; rx_len -= len;
cpu_reset();
}
for(item=0, found=0; item<SETTINGSITEMS; item++)
{
if(settingsmenu[item].ini[0] == 0)
{
continue;
}
len = sprintf(buf, "%s=", settingsmenu[item].ini);
if(strncmpi(rx, buf, len) == 0)
{
rx += len; rx_len -= len;
len = url_decode(rx, rx, rx_len);
i = 0;
switch(settingsmenu[item].format)
{
case F_NR: //p1-p2, p3=step size
i = atoi(rx);
if(i < settingsmenu[item].p1){ i = settingsmenu[item].p1; }
else if(i > settingsmenu[item].p2){ i = settingsmenu[item].p2; }
itoa(i, buf, 10);
ini_setentry(SETTINGS_FILE, settingsmenu[item].ini, buf);
if(settingsmenu[item].set){ settingsmenu[item].set((void*)(int)i); }
break;
case F_OR: //p1 or p2
i = atoi(rx);
if((i != settingsmenu[item].p1) &&
(i != settingsmenu[item].p2)){ i = settingsmenu[item].p1; }
itoa(i, buf, 10);
ini_setentry(SETTINGS_FILE, settingsmenu[item].ini, buf);
if(settingsmenu[item].set){ settingsmenu[item].set((void*)(int)i); }
break;
case F_STR: //p1=max len
if((settingsmenu[item].p1 != 0) &&
(strlen(rx) > (unsigned)settingsmenu[item].p1))
{
rx[settingsmenu[item].p1] = 0;
}
ini_setentry(SETTINGS_FILE, settingsmenu[item].ini, rx);
if(settingsmenu[item].set){ settingsmenu[item].set(rx); }
break;
case F_MAC:
mac = atomac(rx);
ini_setentry(SETTINGS_FILE, settingsmenu[item].ini, mactoa(mac));
//if(settingsmenu[item].set){ settingsmenu[item].set((void*)(MAC_Addr)mac); }
break;
case F_IP:
ip = atoip(rx);
ini_setentry(SETTINGS_FILE, settingsmenu[item].ini, iptoa(ip));
if(settingsmenu[item].set){ settingsmenu[item].set((void*)(IP_Addr)atoip(rx)); }
break;
case F_RGB:
rgb = atorgb(rx);
sprintf(buf, "%03i,%03i,%03i", GET_RED(rgb), GET_GREEN(rgb), GET_BLUE(rgb));
ini_setentry(SETTINGS_FILE, settingsmenu[item].ini, buf);
if(settingsmenu[item].set){ settingsmenu[item].set((void*)(unsigned int)rgb); }
break;
}
rx += len; rx_len -= len;
found = 1;
break;
}
}
if(found == 0)
{
rx++; rx_len--;
}
}
menu_drawwnd(1);
return;
}
/**
* CParticleEffect::initParticle
* @date Modified June 01, 2006
*/
void CParticleEffect::initParticle(CParticleManager::SParticle* pParticle, D3DXMATRIX* mOffset)
{
D3DXMATRIX mPosOffset, mOrientation = *mOffset;
D3DXMatrixIdentity(&mPosOffset);
mPosOffset._41 = mOffset->_41;
mPosOffset._42 = mOffset->_42;
mPosOffset._43 = mOffset->_43;
mOrientation._41 = mOrientation._42 = mOrientation._43 = 0.0f;
mOrientation._44 = 1.0f;
float fMinVel, fMaxVel;
D3DXVec3Normalize(&fMinVel, &m_vMinVelocity, &m_vMinVelocity);
D3DXVec3Normalize(&fMaxVel, &m_vMaxVelocity, &m_vMaxVelocity);
D3DXVec3TransformCoord(&m_vMinVelocityTrans, &m_vMinVelocity, &mOrientation);
D3DXVec3TransformCoord(&m_vMaxVelocityTrans, &m_vMaxVelocity, &mOrientation);
m_vMinVelocity *= fMinVel;
m_vMaxVelocity *= fMaxVel;
// Update attributes
BYTE cR = GET_RED(pParticle->Color),
cG = GET_GREEN(pParticle->Color),
cB = GET_BLUE(pParticle->Color),
cA = GET_ALPHA(pParticle->Color);
for(size_t j = 0; j < m_vAttributes.size(); ++j)
{
float fScale = m_vAttributes[j]->getValue(0.0f);
switch(m_vAttributes[j]->getType())
{
case CParticleAttribute::ATR_COLORRED: cR = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_COLORGREEN: cG = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_COLORBLUE: cB = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_COLORALPHA: cA = (BYTE)(fScale * 255.0f); break;
case CParticleAttribute::ATR_SIZE: pParticle->Size = fScale; break;
case CParticleAttribute::ATR_ROTATION: pParticle->Rotation = degreesToRadians(fScale); break;
case CParticleAttribute::ATR_ACCELX: pParticle->Acceleration.x = fScale; break;
case CParticleAttribute::ATR_ACCELY: pParticle->Acceleration.y = fScale; break;
case CParticleAttribute::ATR_ACCELZ: pParticle->Acceleration.z = fScale; break;
}
}
pParticle->Color = D3DCOLOR_ARGB(cA, cR, cG, cB);
getRandomVector(&pParticle->Velocity, &m_vMinVelocityTrans, &m_vMaxVelocityTrans);
pParticle->Velocity *= getRandomFloat(fMinVel, fMaxVel);
m_vMinVelocityTrans *= fMinVel;
m_vMaxVelocityTrans *= fMaxVel;
D3DXVECTOR3 vMin(0.0f, 0.0f, 0.0f), vMax(0.0f, 0.0f, 0.0f);
switch(m_eSpawnShape)
{
case SH_CUBE:
vMin.x = -m_vSpawnRadius.x;
vMin.y = -m_vSpawnRadius.y;
vMin.z = -m_vSpawnRadius.z;
getRandomVector(&pParticle->Position, &vMin, &m_vSpawnRadius);
break;
case SH_SQUARE:
vMin.x = -m_vSpawnRadius.x;
vMin.z = -m_vSpawnRadius.z;
vMax.x = m_vSpawnRadius.x;
vMax.z = m_vSpawnRadius.z;
getRandomVector(&pParticle->Position, &vMin, &vMax);
break;
case SH_SPHERE:
getRandomVector(&vMin, -1.0f, 1.0f);
D3DXVec3Normalize(&vMin, &vMin);
pParticle->Position.x = vMin.x * m_vSpawnRadius.x;
pParticle->Position.y = vMin.y * m_vSpawnRadius.x;
pParticle->Position.z = vMin.z * m_vSpawnRadius.x;
break;
case SH_CIRCLE:
getRandomVector(&vMin, -1.0f, 1.0f);
D3DXVec3Normalize(&vMin, &vMin);
pParticle->Position.x = vMin.x * m_vSpawnRadius.x;
pParticle->Position.y = 0.0f;
pParticle->Position.z = vMin.z * m_vSpawnRadius.x;
break;
}
D3DXVec3TransformCoord(&pParticle->Position, &pParticle->Position, &mPosOffset);
}
string PrintColor(uint32 color)
{
char st[128];
sprintf(st, "%d, %d, %d, %d", GET_RED(color), GET_GREEN(color), GET_BLUE(color), GET_ALPHA(color));
return string(st);
}
KisImportExportFilter::ConversionStatus KisXCFImport::loadFromDevice(QIODevice* device, KisDocument* doc)
{
dbgFile << "Start decoding file";
// Read the file into memory
device->open(QIODevice::ReadOnly);
QByteArray data = device->readAll();
xcf_file = (uint8_t*)data.data();
xcf_length = data.size();
device->close();
// Decode the data
getBasicXcfInfo() ;
initColormap();
dbgFile << XCF.version << "width = " << XCF.width << "height = " << XCF.height << "layers = " << XCF.numLayers;
// Create the image
KisImageSP image = new KisImage(doc->createUndoStore(), XCF.width, XCF.height, KoColorSpaceRegistry::instance()->rgb8(), "built image");
QVector<Layer> layers;
uint maxDepth = 0;
// Read layers
for (int i = 0; i < XCF.numLayers; ++i) {
Layer layer;
xcfLayer& xcflayer = XCF.layers[i];
dbgFile << i << " name = " << xcflayer.name << " opacity = " << xcflayer.opacity << "group:" << xcflayer.isGroup << xcflayer.pathLength;
dbgFile << ppVar(xcflayer.dim.width) << ppVar(xcflayer.dim.height) << ppVar(xcflayer.dim.tilesx) << ppVar(xcflayer.dim.tilesy) << ppVar(xcflayer.dim.ntiles) << ppVar(xcflayer.dim.c.t) << ppVar(xcflayer.dim.c.l) << ppVar(xcflayer.dim.c.r) << ppVar(xcflayer.dim.c.b);
maxDepth = qMax(maxDepth, xcflayer.pathLength);
bool isRgbA = false;
// Select the color space
const KoColorSpace* colorSpace = 0;
switch (xcflayer.type) {
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
case GIMP_RGB_IMAGE:
case GIMP_RGBA_IMAGE:
colorSpace = KoColorSpaceRegistry::instance()->rgb8();
isRgbA = true;
break;
case GIMP_GRAY_IMAGE:
case GIMP_GRAYA_IMAGE:
colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id(), "");
isRgbA = false;
break;
}
// Create the layer
KisLayerSP kisLayer;
if (xcflayer.isGroup) {
kisLayer = new KisGroupLayer(image, QString::fromUtf8(xcflayer.name), xcflayer.opacity);
}
else {
kisLayer = new KisPaintLayer(image, QString::fromUtf8(xcflayer.name), xcflayer.opacity, colorSpace);
}
// Set some properties
kisLayer->setCompositeOpId(layerModeG2K(xcflayer.mode));
kisLayer->setVisible(xcflayer.isVisible);
kisLayer->disableAlphaChannel(xcflayer.mode != GIMP_NORMAL_MODE);
layer.layer = kisLayer;
layer.depth = xcflayer.pathLength;
// Copy the data in the image
initLayer(&xcflayer);
int left = xcflayer.dim.c.l;
int top = xcflayer.dim.c.t;
if (!xcflayer.isGroup) {
// Copy the data;
for (unsigned int x = 0; x < xcflayer.dim.width; x += TILE_WIDTH) {
for (unsigned int y = 0; y < xcflayer.dim.height; y += TILE_HEIGHT) {
rect want;
want.l = x + left;
want.t = y + top;
want.b = want.t + TILE_HEIGHT;
want.r = want.l + TILE_WIDTH;
Tile* tile = getMaskOrLayerTile(&xcflayer.dim, &xcflayer.pixels, want);
KisHLineIteratorSP it = kisLayer->paintDevice()->createHLineIteratorNG(x, y, TILE_WIDTH);
rgba* data = tile->pixels;
for (int v = 0; v < TILE_HEIGHT; ++v) {
if (isRgbA) {
// RGB image
do {
KoBgrTraits<quint8>::setRed(it->rawData(), GET_RED(*data));
KoBgrTraits<quint8>::setGreen(it->rawData(), GET_GREEN(*data));
KoBgrTraits<quint8>::setBlue(it->rawData(), GET_BLUE(*data));
KoBgrTraits<quint8>::setOpacity(it->rawData(), quint8(GET_ALPHA(*data)), 1);
++data;
} while (it->nextPixel());
} else {
// Grayscale image
do {
it->rawData()[0] = GET_RED(*data);
it->rawData()[1] = GET_ALPHA(*data);
++data;
} while (it->nextPixel());
}
it->nextRow();
}
}
}
// Move the layer to its position
kisLayer->paintDevice()->setX(left);
kisLayer->paintDevice()->setY(top);
}
// Create the mask
if (xcflayer.hasMask) {
KisTransparencyMaskSP mask = new KisTransparencyMask();
layer.mask = mask;
mask->initSelection(kisLayer);
for (unsigned int x = 0; x < xcflayer.dim.width; x += TILE_WIDTH) {
for (unsigned int y = 0; y < xcflayer.dim.height; y += TILE_HEIGHT) {
rect want;
want.l = x + left;
want.t = y + top;
want.b = want.t + TILE_HEIGHT;
want.r = want.l + TILE_WIDTH;
Tile* tile = getMaskOrLayerTile(&xcflayer.dim, &xcflayer.mask, want);
KisHLineIteratorSP it = mask->paintDevice()->createHLineIteratorNG(x, y, TILE_WIDTH);
rgba* data = tile->pixels;
for (int v = 0; v < TILE_HEIGHT; ++v) {
do {
it->rawData()[0] = GET_ALPHA(*data);
++data;
} while (it->nextPixel());
it->nextRow();
}
}
}
mask->paintDevice()->setX(left);
mask->paintDevice()->setY(top);
image->addNode(mask, kisLayer);
}
dbgFile << xcflayer.pixels.tileptrs;
layers.append(layer);
}
for (int i = 0; i <= maxDepth; ++i) {
addLayers(layers, image, i);
}
doc->setCurrentImage(image);
return KisImportExportFilter::OK;
}
