pixel_t compose_over(pixel_t fg, pixel_t bg)
{
double mul;
double mul_cmp;
double res_a;
double res_r;
double res_g;
double res_b;
if (ALPHA(bg) == 255) {
res_a = 1;
mul = ((double) ALPHA(fg)) / 255.0;
mul_cmp = 1 - mul;
} else {
double fg_a = ((double) ALPHA(fg)) / 255.0;
double bg_a = ((double) ALPHA(bg)) / 255.0;
res_a = 1 - (1 - fg_a) * (1 - bg_a);
mul = fg_a / res_a;
mul_cmp = 1 - mul;
}
res_r = mul * ((double) RED(fg)) + mul_cmp * ((double) RED(bg));
res_g = mul * ((double) GREEN(fg)) + mul_cmp * ((double) GREEN(bg));
res_b = mul * ((double) BLUE(fg)) + mul_cmp * ((double) BLUE(bg));
return PIXEL((unsigned) (res_a * 255),
(unsigned) res_r, (unsigned) res_g, (unsigned) res_b);
}
void PointSet::Draw ( float* view_mat, float rad )
{
char* dat;
Point* p;
glEnable ( GL_NORMALIZE );
if ( m_Param[PNT_DRAWMODE] == 0 ) {
glLoadMatrixf ( view_mat );
dat = mBuf[0].data;
for (int n = 0; n < NumPoints(); n++) {
p = (Point*) dat;
glPushMatrix ();
glTranslatef ( p->pos.x, p->pos.y, p->pos.z );
glScalef ( 0.2, 0.2, 0.2 );
if(p->type == 0)
glColor4f ( 0.1,0.3,1.0,1.0 );//glColor4f ( RED(p->clr), GRN(p->clr), BLUE(p->clr), ALPH(p->clr) );
else
glColor4f ( RED(p->clr), GRN(p->clr), BLUE(p->clr), 0.0 );
drawSphere ();
glPopMatrix ();
dat += mBuf[0].stride;
}
} else if ( m_Param[PNT_DRAWMODE] == 1 ) {
glLoadMatrixf ( view_mat );
dat = mBuf[0].data;
glBegin ( GL_POINTS );
for (int n=0; n < NumPoints(); n++) {
p = (Point*) dat;
glColor3f ( RED(p->clr), GRN(p->clr), BLUE(p->clr) );
glVertex3f ( p->pos.x, p->pos.y, p->pos.z );
dat += mBuf[0].stride;
}
glEnd ();
}
}
static int
rain_init(video_adapter_t *adp)
{
video_info_t info;
int i;
if (!vidd_get_info(adp, M_VGA_CG320, &info)) {
scrmode = M_VGA_CG320;
} else if (!vidd_get_info(adp, M_PC98_PEGC640x480, &info)) {
scrmode = M_PC98_PEGC640x480;
} else if (!vidd_get_info(adp, M_PC98_PEGC640x400, &info)) {
scrmode = M_PC98_PEGC640x400;
} else {
log(LOG_NOTICE,
"%s: the console does not support M_VGA_CG320\n",
SAVER_NAME);
return (ENODEV);
}
scrw = info.vi_width;
scrh = info.vi_height;
/* intialize the palette */
for (i = 1; i < MAX; i++)
rain_pal[BLUE(i)] = rain_pal[BLUE(i - 1)] + INCREMENT;
return (0);
}
int normalize(int width, int height, unsigned char* rgb)
{
int
x,y,
red_min=255, red_max=0,
blue_min=255, blue_max=0,
green_min=255, green_max=0;
double
min, max, amplify;
/* determine min and max per color... */
for( y=0; y<height; y++){
for( x=0; x<width; x++ ){
MINMAX( RED(rgb,x,y,width), red_min, red_max );
MINMAX( GREEN(rgb,x,y,width), green_min, green_max);
MINMAX( BLUE(rgb,x,y,width), blue_min, blue_max );
}
}
/* determine min and max per color... */
for( y=0; y<height; y++){
for( x=0; x<width; x++ ){
MINMAX( RED(rgb,x,y,width), red_min, red_max );
MINMAX( GREEN(rgb,x,y,width), green_min, green_max);
MINMAX( BLUE(rgb,x,y,width), blue_min, blue_max );
}
}
/* Normalize brightness ... */
max = MAX( MAX( red_max, green_max ), blue_max);
min = MIN( MIN( red_min, green_min ), blue_min);
amplify = 255.0/(max-min);
printf("min=%f max=%f amplify=%f\n",min,max,amplify);
if (max == 255)
printf("max is already max'ed at 255. Exiting from normalize()\n");
return 0;
for( y=0; y<height; y++){
for( x=0; x<width; x++ ){
RED(rgb,x,y,width)= MIN(amplify*(double)(RED(rgb,x,y,width)-min),255);
GREEN(rgb,x,y,width)= MIN(amplify*(double)(GREEN(rgb,x,y,width)-min),255);
BLUE(rgb,x,y,width)= MIN(amplify*(double)(BLUE(rgb,x,y,width)-min),255);
}
}
return 0;
}
ColorARGB GifTranscoder::computeAverage(ColorARGB c1, ColorARGB c2, ColorARGB c3, ColorARGB c4) {
char avgAlpha = (char)(((int) ALPHA(c1) + (int) ALPHA(c2) +
(int) ALPHA(c3) + (int) ALPHA(c4)) / 4);
char avgRed = (char)(((int) RED(c1) + (int) RED(c2) +
(int) RED(c3) + (int) RED(c4)) / 4);
char avgGreen = (char)(((int) GREEN(c1) + (int) GREEN(c2) +
(int) GREEN(c3) + (int) GREEN(c4)) / 4);
char avgBlue = (char)(((int) BLUE(c1) + (int) BLUE(c2) +
(int) BLUE(c3) + (int) BLUE(c4)) / 4);
return MAKE_COLOR_ARGB(avgAlpha, avgRed, avgGreen, avgBlue);
}
static void
rain_update(video_adapter_t *adp)
{
int i, t;
t = rain_pal[BLUE(MAX)];
for (i = MAX; i > 1; i--)
rain_pal[BLUE(i)] = rain_pal[BLUE(i - 1)];
rain_pal[BLUE(1)] = t;
vidd_load_palette(adp, rain_pal);
}
internal void
PT_CopyBlend(u32 *destPixels, PT_Rect *destRect, u32 destPixelsPerRow,
u32 *srcPixels, PT_Rect *srcRect, u32 srcPixelsPerRow,
u32 *newColor)
{
// If src and dest rects are not the same size ==> bad things
assert(destRect->w == srcRect->w && destRect->h == srcRect->h);
// For each pixel in the destination rect, alpha blend to it the
// corresponding pixel in the source rect.
// ref: https://en.wikipedia.org/wiki/Alpha_compositing
u32 stopX = destRect->x + destRect->w;
u32 stopY = destRect->y + destRect->h;
for (u32 dstY = destRect->y, srcY = srcRect->y;
dstY < stopY;
dstY++, srcY++) {
for (u32 dstX = destRect->x, srcX = srcRect->x;
dstX < stopX;
dstX++, srcX++) {
u32 srcColor = srcPixels[(srcY * srcPixelsPerRow) + srcX];
u32 *destPixel = &destPixels[(dstY * destPixelsPerRow) + dstX];
u32 destColor = *destPixel;
// Colorize our source pixel before we blend it
srcColor = PT_ColorizePixel(srcColor, *newColor);
if (ALPHA(srcColor) == 0) {
// Source is transparent - so do nothing
continue;
} else if (ALPHA(srcColor) == 255) {
// Just copy the color, no blending necessary
*destPixel = srcColor;
} else {
// Do alpha blending
float srcA = ALPHA(srcColor) / 255.0;
float invSrcA = (1.0 - srcA);
float destA = ALPHA(destColor) / 255.0;
float outAlpha = srcA + (destA * invSrcA);
u8 fRed = ((RED(srcColor) * srcA) + (RED(destColor) * destA * invSrcA)) / outAlpha;
u8 fGreen = ((GREEN(srcColor) * srcA) + (GREEN(destColor) * destA * invSrcA)) / outAlpha;
u8 fBlue = ((BLUE(srcColor) * srcA) + (BLUE(destColor) * destA * invSrcA)) / outAlpha;
u8 fAlpha = outAlpha * 255;
*destPixel = COLOR_FROM_RGBA(fRed, fGreen, fBlue, fAlpha);
}
}
}
}
void
hippo_cairo_set_source_rgba32(cairo_t *cr,
guint32 color)
{
/* trying to avoid alpha 255 becoming a double alpha that isn't quite opaque ?
* not sure this is needed.
*/
if ((color & 0xff) == 0xff) {
cairo_set_source_rgb(cr, RED(color), GREEN(color), BLUE(color));
} else {
cairo_set_source_rgba(cr, RED(color), GREEN(color), BLUE(color), ALPHA(color));
}
}
uint32_t getBilinearInterpolatedPixel(const void *pixels, int width, int height, int stride, float x, float y) {
int x1 = (int) x;
int x2 = x1+1;
int y1 = (int) y;
int y2 = y1+1;
uint32_t pixel1 = getPixelRGBA(pixels, stride, x1%width, y1%height);
uint32_t pixel2 = getPixelRGBA(pixels, stride, x2%width, y1%height);
uint32_t pixel3 = getPixelRGBA(pixels, stride ,x1%width, y2%height);
uint32_t pixel4 = getPixelRGBA(pixels, stride, x2%width, y2%height);
int red1 = RED(pixel1);
int green1 = GREEN(pixel1);
int blue1 = BLUE(pixel1);
int red2 = RED(pixel2);
int green2 = GREEN(pixel2);
int blue2 = BLUE(pixel2);
int red3 = RED(pixel3);
int green3 = GREEN(pixel3);
int blue3 = BLUE(pixel3);
int red4 = RED(pixel4);
int green4 = GREEN(pixel4);
int blue4 = BLUE(pixel4);
float w1 = x2-x;
float w2 = x-x1;
float red1_2 = w1*red1 + w2*red2;
float red2_3 = w1*red3 + w2*red4;
float green1_2 = w1*green1 + w2*green2;
float green2_3 = w1*green3 + w2*green4;
float blue1_2 = w1*blue1 + w2*blue2;
float blue2_3 = w1*blue3 + w2*blue4;
w1 = y2-y;
w2 = y-y1;
int red = (int) (w1*red1_2 + w2*red2_3 + 0.5);
int green = (int) (w1*green1_2 + w2*green2_3 + 0.5);
int blue = (int) (w1*blue1_2 + w2*blue2_3 + 0.5);
return createRGBAPixel(red, green, blue, 0);
}
void TermCMD::help(cTerm & t,int argc,char *argv[])
{
t<<(GREEN("TermCMD commands:\n"));
cmd_table_t* t_ptr = NULL;
char txt[16];
int k = 0;
do
{
t_ptr = &mCmdTable[k++];
if(!t_ptr->cmd)
break;
if(t_ptr->f)
{
sprintf(txt,"%s %s", t_ptr->cmd, t_ptr->argDesc);
t<<" "<<t.format("%-10s - ",txt)<<t.format("%s\n",t_ptr->desc);
}
else
{
//this is a caption
t<<t.format(BLUE("%s\n"), t_ptr->cmd);
}
}while(t_ptr->cmd);
}
/*
void draw2DBox(int top, int left, int right, int bottom, DWORD colour[4])
{
CONTROLVERTEX Vertices[4] = {
// x, y, z, rhw, colour, tu,tv
{ left, bottom, 0.0f, 1.0f, colour[0], 0.0f, 1.0f }, // BL
{ right, bottom, 0.0f, 1.0f, colour[2], 1.0f, 1.0f }, // BR
{ left, top, 0.0f, 1.0f, colour[1], 0.0f, 0.0f }, // TL
{ right, top, 0.0f, 1.0f, colour[3], 1.0f, 0.0f }, // TR
};
glBegin(GL_TRIANGLE_STRIP);
for (int i = 0; i < 4; )
{
DWORD &c = Vertices[i].diffuse;
float c1[4] ={
((float)RED(c)) / 255.0,
((float)GREEN(c)) / 255.0,
((float)BLUE(c)) / 255.0,
((float)ALPHA(c)) / 255.0
};
glColor4fv(c1);
glTexCoord2d(Vertices[i].tu0,Vertices[i].tv0);
glVertex3f(Vertices[i].x, Vertices[i].y, Vertices[i].z);
i++;
}
glEnd();
}
*/
void draw2DBox(float top, float left, float right, float bottom, DWORD colour[4])
{
CONTROLVERTEX Vertices[4] = {
// x, y, z, rhw, colour, tu,tv
{ left, bottom, 0.0f, 1.0f, colour[0], 0.0f, 1.0f }, // BL
{ right, bottom, 0.0f, 1.0f, colour[2], 1.0f, 1.0f }, // BR
{ left, top, 0.0f, 1.0f, colour[1], 0.0f, 0.0f }, // TL
{ right, top, 0.0f, 1.0f, colour[3], 1.0f, 0.0f }, // TR
};
glBegin(GL_TRIANGLE_STRIP);
for (int i = 0; i < 4; )
{
DWORD &c = Vertices[i].diffuse;
float c1[4] ={
((float)RED(c)) / 255.0f,
((float)GREEN(c)) / 255.0f,
((float)BLUE(c)) / 255.0f,
((float)ALPHA(c)) / 255.0f
};
glColor4fv(c1);
glTexCoord2d(Vertices[i].tu0,Vertices[i].tv0);
glVertex3f(Vertices[i].x, Vertices[i].y, Vertices[i].z);
i++;
}
glEnd();
}
char *region_of_interest (NEURON_LAYER *nl_input, int x_center, int y_center, int width, int height)
{
int xi, yi, wi, hi, xo, yo, wo, ho;
NEURON_OUTPUT value;
char * output = malloc(width * height * 3 * sizeof(char));
wi = nl_input->dimentions.x;
hi = nl_input->dimentions.y;
wo = width;
ho = height;
for (yo = 0; yo < ho; yo++)
{
for (xo = 0; xo < wo; xo++)
{
xi = (int) ((double) xo + .5) + x_center - wo/2;
yi = (int) ((double) yo + .5) + y_center - ho/2;
if (xi >= 0 && xi < wi && yi >= 0 && yi < hi)
value = nl_input->neuron_vector[xi + wi * yi].output;
else
value.ival = 0;
output[3 * (yo * wo + xo) + 0] = RED(value.ival);
output[3 * (yo * wo + xo) + 1] = GREEN(value.ival);
output[3 * (yo * wo + xo) + 2] = BLUE(value.ival);
}
}
return output;
}
bool RGBLinearQuantizationFilter::Apply(til::Image &image) const
{
if (image.GetBitDepth() != til::Image::BPP_32B_R8G8B8) return false;
til::uint32 *image_pixels = reinterpret_cast<til::uint32*>(image.GetPixels());
std::vector<til::byte> palette[3] = {
std::vector<til::byte>(max(((til::byte)(_palette_quants)), 1), 0x00),
std::vector<til::byte>(max(((til::byte)(_palette_quants >> 8)), 1), 0x00),
std::vector<til::byte>(max(((til::byte)(_palette_quants >> 16)), 1), 0x00)
};
til::byte index[] = {
static_cast<til::byte>(0x100 / palette[0].size()) + (palette[0].size() % 2 * static_cast<til::byte>(palette[0].size() > 1)),
static_cast<til::byte>(0x100 / palette[1].size()) + (palette[1].size() % 2 * static_cast<til::byte>(palette[1].size() > 1)),
static_cast<til::byte>(0x100 / palette[2].size()) + (palette[2].size() % 2 * static_cast<til::byte>(palette[2].size() > 1))
};
for(std::vector<til::byte>::size_type i = 0, max = palette[0].size(); i < max; ++i) palette[0][i] = static_cast<til::byte>(i * index[0]);
for(std::vector<til::byte>::size_type i = 0, max = palette[1].size(); i < max; ++i) palette[1][i] = static_cast<til::byte>(i * index[1]);
for(std::vector<til::byte>::size_type i = 0, max = palette[2].size(); i < max; ++i) palette[2][i] = static_cast<til::byte>(i * index[2]);
for (til::uint64 i = 0, max = image.GetWidth() * image.GetHeight(); i < max; ++i)
{
image_pixels[i] = RGB(
palette[0][index[0] == 0x00 ? 0 : RED(image_pixels[i]) / index[0]],
palette[1][index[1] == 0x00 ? 0 : GREEN(image_pixels[i]) / index[1]],
palette[2][index[2] == 0x00 ? 0 : BLUE(image_pixels[i]) / index[2]]
);
}
return true;
}
void draw3DLine(float sx, float sy, float sz, float ex, float ey, float ez, DWORD colour)
{
glLoadIdentity();
/*D3DXMATRIX mat;
D3DXMatrixIdentity(&mat);
g_pd3dDevice->SetTransform( D3DTS_WORLD, &mat ); // Move object
*/
DWORD &c = colour;
float c1[4] ={
((float)RED(c)) / 255.0f,
((float)GREEN(c)) / 255.0f,
((float)BLUE(c)) / 255.0f,
((float)ALPHA(c)) / 255.0f
};
glColor4fv(c1);
glBegin(GL_LINES);
// glColor4f(RED(colour), GREEN(colour), BLUE(colour), ALPHA(colour));
glVertex3f(sx, sy, sz);
glVertex3f(ex, ey, ez);
glEnd();
/*
#define D3DFVF_LVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)
struct LVERTEX { float x, y, z; DWORD diffuse; };
LVERTEX line[2] = {
{ sx, sy, sz, colour },
{ ex, ey, ez, colour }
};
SetVertexShader( D3DFVF_LVERTEX );
g_pd3dDevice->DrawPrimitiveUP(D3DPT_LINELIST, 2, line, sizeof(LVERTEX));
*/
}
void GEQuad::drawVisual(vector_t unit_size)
{
float hx, hy, hz;
hx = (this->dimensions.x * unit_size.x) / 2;
hy = (this->dimensions.y * unit_size.y) / 2;
hz = (this->dimensions.z * unit_size.z) / 2;
glBegin(GL_QUADS);
glColor3ub(RED(bg_color), GREEN(bg_color), BLUE(bg_color));
glVertex3f( hx, hy,-hz);
glVertex3f(-hx, hy,-hz);
glVertex3f(-hx, hy, hz);
glVertex3f( hx, hy, hz);
glVertex3f( hx,-hy, hz);
glVertex3f(-hx,-hy, hz);
glVertex3f(-hx,-hy,-hz);
glVertex3f( hx,-hy,-hz);
glVertex3f( hx, hy, hz);
glVertex3f(-hx, hy, hz);
glVertex3f(-hx,-hy, hz);
glVertex3f( hx,-hy, hz);
glVertex3f( hx,-hy,-hz);
glVertex3f(-hx,-hy,-hz);
glVertex3f(-hx, hy,-hz);
glVertex3f( hx, hy,-hz);
glEnd();
}
/*
* Enforces all pixels to grayscale.
*/
void compute_gray(struct jpeg_data *jpeg)
{
if (jpeg == NULL || jpeg->raw_data == NULL)
return;
uint32_t nb_pixels, pixel;
uint32_t *image = jpeg->raw_data;
uint32_t R, G, B, gray;
/* Compute the buffer size */
if (jpeg->is_plain_image)
nb_pixels = jpeg->width * jpeg->height;
else
nb_pixels = jpeg->mcu.size * jpeg->mcu.nb;
/* Convert each pixel */
for (uint32_t i = 0; i < nb_pixels; i++) {
pixel = image[i];
R = RED(pixel);
G = GREEN(pixel);
B = BLUE(pixel);
gray = (R + G + B) / 3;
image[i] = gray << 16 | gray << 8 | gray;
}
}
/*
* InitPixelShade:
* Fills the PixelShade array with precomputed shades of every possible pixel (32 shades)
*/
void InitPixelShade(void)
{
int i, j;
int r, g, b;
int dr, dg, db;
const double alpha[32] = { 0.0, 0.03, 0.06, 0.09,
0.13, 0.17, 0.21, 0.24,
0.27, 0.31, 0.34, 0.37,
0.41, 0.44, 0.47, 0.49,
0.51, 0.53, 0.56, 0.59,
0.63, 0.66, 0.69, 0.73,
0.76, 0.79, 0.83, 0.87,
0.91, 0.94, 0.97, 1.0
};
for (i = 0; i < 32; i++) {
for (j = 0; j < 65536; j++) {
r = RED(j);
g = GREEN(j);
b = BLUE(j);
dr = (int)(r * alpha[i]);
dg = (int)(g * alpha[i]);
db = (int)(b * alpha[i]);
PixelShade[i][j] = RGB16(dr, dg, db);
}
}
}
void omb_draw_rect(int x, int y, int width, int height, int color)
{
int i, j;
long int location = 0;
unsigned char alpha = ALPHA(color);
unsigned char red = RED(color);
unsigned char green = GREEN(color);
unsigned char blue = BLUE(color);
for (i = y; i < y + height; i++) {
for (j = x; j < x + width; j++) {
if (i < 0 || j < 0 || i > omb_var_screen_info.yres || j > omb_var_screen_info.xres)
continue;
location = ((j + omb_var_screen_info.xoffset) * (omb_var_screen_info.bits_per_pixel / 8)) +
((i + omb_var_screen_info.yoffset) * omb_fix_screen_info.line_length);
*(omb_fb_map + location) = blue;
*(omb_fb_map + location + 1) = green;
*(omb_fb_map + location + 2) = red;
*(omb_fb_map + location + 3) = alpha;
}
}
}
void GEMapCell::drawVisual(vector_t unit_size)
{
float hx, hy, hz;
hx = (this->parent->cell_size.x * unit_size.x) / 2 - unit_size.x/20;
hy = (this->parent->cell_size.y * unit_size.y) / 2 - unit_size.y/20;
hz = (this->height * unit_size.z) + 0.01;
if (visual)
visual->draw(unit_size);
glBegin(GL_QUADS);
glColor3ub(RED(bg_color), GREEN(bg_color), BLUE(bg_color));
glVertex3f( hx, hy, 0);
glVertex3f(-hx, hy, 0);
glVertex3f(-hx, hy, hz);
glVertex3f( hx, hy, hz);
glVertex3f( hx,-hy, hz);
glVertex3f(-hx,-hy, hz);
glVertex3f(-hx,-hy, 0);
glVertex3f( hx,-hy, 0);
glVertex3f( hx, hy, hz);
glVertex3f(-hx, hy, hz);
glVertex3f(-hx,-hy, hz);
glVertex3f( hx,-hy, hz);
glVertex3f( hx,-hy, 0);
glVertex3f(-hx,-hy, 0);
glVertex3f(-hx, hy, 0);
glVertex3f( hx, hy, 0);
glEnd();
}
void ColorQuantizer::shrink(cube_t *cube)
{
byte r, g, b;
word i,color;
cube->rmin = 255;
cube->rmax = 0;
cube->gmin = 255;
cube->gmax = 0;
cube->bmin = 255;
cube->bmax = 0;
for (i = cube->lower; i <= cube->upper; i++)
{
color = histPtr[i];
r = RED(color);
if (r > cube->rmax) cube->rmax = r;
if (r < cube->rmin) cube->rmin = r;
g = GREEN(color);
if (g > cube->gmax) cube->gmax = g;
if (g < cube->gmin) cube->gmin = g;
b = BLUE(color);
if (b > cube->bmax) cube->bmax = b;
if (b < cube->bmin) cube->bmin = b;
}
}
INT BndStrg_SetInfFlags(PRTMP_ADAPTER pAd, PBND_STRG_CLI_TABLE table, BOOLEAN bInfReady)
{
INT ret_val = BND_STRG_SUCCESS;
BNDSTRG_MSG msg;
if (WMODE_CAP_5G(pAd->CommonCfg.PhyMode) &&
(table->b5GInfReady ^ bInfReady))
{
table->b5GInfReady = bInfReady;
msg.Action = INF_STATUS_RSP_5G;
msg.b5GInfReady = table->b5GInfReady;
RtmpOSWrielessEventSend(
pAd->net_dev,
RT_WLAN_EVENT_CUSTOM,
OID_BNDSTRG_MSG,
NULL,
(UCHAR *)&msg,
sizeof(msg));
BND_STRG_DBGPRINT(RT_DEBUG_OFF,
(BLUE("%s(): BSS (%02x:%02x:%02x:%02x:%02x:%02x)")
BLUE(" set 5G Inf %s.\n")
, __FUNCTION__, PRINT_MAC(pAd->ApCfg.MBSSID[0].wdev.bssid),
bInfReady ? "ready" : "not ready"));
}
else if (table->b2GInfReady ^ bInfReady)
{
table->b2GInfReady = bInfReady;
msg.Action = INF_STATUS_RSP_2G;
msg.b2GInfReady = table->b2GInfReady;
RtmpOSWrielessEventSend(
pAd->net_dev,
RT_WLAN_EVENT_CUSTOM,
OID_BNDSTRG_MSG,
NULL,
(UCHAR *)&msg,
sizeof(msg));
BND_STRG_DBGPRINT(RT_DEBUG_OFF,
(BLUE("%s(): BSS (%02x:%02x:%02x:%02x:%02x:%02x)")
BLUE(" set 2G Inf %s.\n")
, __FUNCTION__, PRINT_MAC(pAd->ApCfg.MBSSID[0].wdev.bssid),
bInfReady ? "ready" : "not ready"));
}
return ret_val;
}
void print_to_file(const char * userfile, int lineno, T obj, ADDON addon =
ADDON()) {
tagset.insert("notag");
(*OS) << DIV("notag") << br << BLUE( obj) << NBSP << CALLINFO << NBSP
<< BROWN(addon.getString()) << NBSP << EDIV;
(*OS).flush();
}
void
hsv_v_filter(FILTER_DESC *filter_desc)
{
// http://en.wikipedia.org/wiki/HSL_and_HSV
// http://cs.haifa.ac.il/hagit/courses/ist/Lectures/Demos/ColorApplet2/t_convert.html
PARAM_LIST *p_list = NULL;
NEURON_LAYER_LIST *n_list = NULL;
NEURON_LAYER *nl_output = NULL, *nl_input = NULL;
int nl_number, p_number;
int xo, yo, wi, hi, wo, ho;
int r, g, b;
// Checks the Neuron Layers Number
for (nl_number = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, nl_number++)
;
// Checks the Parameters Number
for (p_number = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, p_number++)
;
if (p_number != 1)
{
Erro ("Error: Wrong number of parameters. The blue_mask_filter must have no parameters.", "", "");
return;
}
// Gets the Input Neuron Layer
nl_input = filter_desc->neuron_layer_list->neuron_layer;
// Gets the Filter Output
nl_output = filter_desc->output;
// Input-Output width
wi = nl_input->dimentions.x;
hi = nl_input->dimentions.y;
wo = nl_output->dimentions.x;
ho = nl_output->dimentions.y;
if (wi != wo || hi != ho)
{
Erro ("Error: Input and output layers on blue_channel_mask filter must have the same 2D size.", "", "");
return;
}
for (yo = 0; yo < ho; yo++)
{
for (xo = 0; xo < wo; xo++)
{
r = RED(nl_input->neuron_vector[xo + yo * wo].output.ival);
g = GREEN(nl_input->neuron_vector[xo + yo * wo].output.ival);
b = BLUE(nl_input->neuron_vector[xo + yo * wo].output.ival);
nl_output->neuron_vector[xo + yo * wo].output.ival = max_value(r, g, b);
}
}
}
static rgb_color sample_rgb(uint16_t x, uint16_t y) {
RGBQUAD quad;
rgb_color ret;
FreeImage_GetPixelColor(dib,x,y,&quad);
ret.r = RED(&quad);
ret.g = GREEN(&quad);
ret.b = BLUE(&quad);
return ret;
}
void
Cr_filter(FILTER_DESC *filter_desc)
{
// http://www.equasys.de/colorconversion.html
PARAM_LIST *p_list = NULL;
NEURON_LAYER_LIST *n_list = NULL;
NEURON_LAYER *nl_output = NULL, *nl_input = NULL;
int nl_number, p_number;
int xo, yo, wi, hi, wo, ho;
double r, g, b;
// Checks the Neuron Layers Number
for (nl_number = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, nl_number++)
;
// Checks the Parameters Number
for (p_number = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, p_number++)
;
if (p_number != 1)
{
Erro ("Error: Wrong number of parameters. The blue_mask_filter must have no parameters.", "", "");
return;
}
// Gets the Input Neuron Layer
nl_input = filter_desc->neuron_layer_list->neuron_layer;
// Gets the Filter Output
nl_output = filter_desc->output;
// Input-Output width
wi = nl_input->dimentions.x;
hi = nl_input->dimentions.y;
wo = nl_output->dimentions.x;
ho = nl_output->dimentions.y;
if (wi != wo || hi != ho)
{
Erro ("Error: Input and output layers on blue_channel_mask filter must have the same 2D size.", "", "");
return;
}
for (yo = 0; yo < ho; yo++)
{
for (xo = 0; xo < wo; xo++)
{
r = (double) RED(nl_input->neuron_vector[xo + yo * wo].output.ival);
g = (double) GREEN(nl_input->neuron_vector[xo + yo * wo].output.ival);
b = (double) BLUE(nl_input->neuron_vector[xo + yo * wo].output.ival);
nl_output->neuron_vector[xo + yo * wo].output.ival = (int) (0.500 * r - 0.419 * g - 0.081 * b + 128.0);
}
}
}
uint32 rgb565_to_rgb32(uint16 rgb565)
{
uint8 r, g, b;
uint32 rgb;
r = (uint8)RED(rgb565);
g = (uint8)GREEN(rgb565);
b = (uint8)BLUE(rgb565);
rgb = (((r << 8) + g) << 8) + b;
return rgb;
}
//scale using area averaging
void scale_area_avg(struct image* src, struct image* dest){
int m, n, i, j;
for (i = 0; i < dest->height; i++){
for (j = 0; j < dest->width; j++){
int rval = 0, gval = 0, bval = 0;
for (m = i * SCALE_FACTOR; m < (i + 1) * SCALE_FACTOR; m++){
for (n = j * SCALE_FACTOR; n < (j + 1) * SCALE_FACTOR; n++){
rval += RED(src, m, n);
gval += GREEN(src, m, n);
bval += BLUE(src, m, n);
}
}
RED(dest, i, j) = rval / SCALE_FACTOR / SCALE_FACTOR;
GREEN(dest, i, j) = gval / SCALE_FACTOR / SCALE_FACTOR;
BLUE(dest, i, j) = bval / SCALE_FACTOR / SCALE_FACTOR;
}
}
}
void omb_draw_rounded_rect(int x, int y, int width, int height, int color, int radius)
{
int i, j;
long int location = 0;
unsigned char alpha = ALPHA(color);
unsigned char red = RED(color);
unsigned char green = GREEN(color);
unsigned char blue = BLUE(color);
for (i = y; i < y + height; i++) {
for (j = x; j < x + width; j++) {
if (i < 0 || j < 0 || i > omb_var_screen_info.yres || j > omb_var_screen_info.xres)
continue;
int relative_x = j - x;
int relative_y = i - y;
// top left corner
if (relative_y < radius && relative_x < radius) {
if (!omb_is_point_inside_circle(relative_x, relative_y, radius)) {
continue;
}
}
// top right corner
else if (relative_y < radius && width - relative_x < radius) {
if (!omb_is_point_inside_circle(width - relative_x, relative_y, radius)) {
continue;
}
}
// bottom left corner
else if (height - relative_y < radius && relative_x < radius) {
if (!omb_is_point_inside_circle(relative_x, height - relative_y, radius)) {
continue;
}
}
// bottom right corner
else if (height - relative_y < radius && width - relative_x < radius) {
if (!omb_is_point_inside_circle(width - relative_x, height - relative_y, radius)) {
continue;
}
}
location = ((j + omb_var_screen_info.xoffset) * (omb_var_screen_info.bits_per_pixel / 8)) +
((i + omb_var_screen_info.yoffset) * omb_fix_screen_info.line_length);
*(omb_fb_map + location) = blue;
*(omb_fb_map + location + 1) = green;
*(omb_fb_map + location + 2) = red;
*(omb_fb_map + location + 3) = alpha;
}
}
}
internal void
PT_FillBlend(u32 *pixels, u32 pixelsPerRow, PT_Rect *destRect, u32 color)
{
// For each pixel in the destination rect, alpha blend the
// bgColor to the existing color.
// ref: https://en.wikipedia.org/wiki/Alpha_compositing
u32 stopX = destRect->x + destRect->w;
u32 stopY = destRect->y + destRect->h;
// If the color we're trying to blend is transparent, then bail
if (ALPHA(color) == 0) return;
float srcA = ALPHA(color) / 255.0;
float invSrcA = 1.0 - srcA;
// Otherwise, blend each pixel in the dest rect
for (u32 dstY = destRect->y; dstY < stopY; dstY++) {
for (u32 dstX = destRect->x; dstX < stopX; dstX++) {
u32 *pixel = &pixels[(dstY * pixelsPerRow) + dstX];
if (ALPHA(color) == 255) {
// Just copy the color, no blending necessary
*pixel = color;
} else {
// Do alpha blending
u32 pixelColor = *pixel;
float destA = ALPHA(pixelColor) / 255.0;
float outAlpha = srcA + (destA * invSrcA);
u8 fRed = ((RED(color) * srcA) + (RED(pixelColor) * destA * invSrcA)) / outAlpha;
u8 fGreen = ((GREEN(color) * srcA) + (GREEN(pixelColor) * destA * invSrcA)) / outAlpha;
u8 fBlue = ((BLUE(color) * srcA) + (BLUE(pixelColor) * destA * invSrcA)) / outAlpha;
u8 fAlpha = outAlpha * 255;
*pixel = COLOR_FROM_RGBA(fRed, fGreen, fBlue, fAlpha);
}
}
}
}
int ColorQuantizer::compare(const void *a1, const void *a2)
{
word color1, color2;
byte c_1, c_2;
color1 = (word)*(word *)a1;
color2 = (word)*(word *)a2;
switch (longdim)
{
case 0:
c_1 = RED(color1), c_2 = RED(color2);
break;
case 1:
c_1 = GREEN(color1), c_2 = GREEN(color2);
break;
case 2:
c_1 = BLUE(color1), c_2 = BLUE(color2);
break;
}
return ((int)(c_1 - c_2));
}
