MythFontProperties* MythYUVAPainter::GetConvertedFont(const MythFontProperties &font)
{
QString original = font.GetHash();
if (m_convertedFonts.contains(original))
{
m_expireList.remove(original);
m_expireList.push_back(original);
}
else
{
QColor yuv_color;
MythFontProperties *new_font = new MythFontProperties();
yuv_color = rgb_to_yuv(font.color());
new_font->SetFace(font.face());
new_font->SetColor(yuv_color);
if (font.hasShadow())
{
QPoint offset;
QColor color;
int alpha;
font.GetShadow(offset, color, alpha);
yuv_color = rgb_to_yuv(color);
new_font->SetShadow(true, offset, yuv_color, alpha);
}
if (font.hasOutline())
{
QColor color;
int size, alpha;
font.GetOutline(color, size, alpha);
yuv_color = rgb_to_yuv(color);
new_font->SetOutline(true, yuv_color, size, alpha);
}
m_convertedFonts.insert(original, new_font);
m_expireList.push_back(original);
if (m_convertedFonts.size() > MAX_FONT_CACHE)
{
QString expire = m_expireList.front();
m_expireList.pop_front();
if (m_convertedFonts.contains(expire))
{
delete m_convertedFonts.value(expire);
m_convertedFonts.remove(expire);
}
}
}
return m_convertedFonts.value(original);
}
void ConvertRGBToYUVOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
{
float inputColor[4];
this->m_inputOperation->read(inputColor, x, y, sampler);
rgb_to_yuv(inputColor[0], inputColor[1], inputColor[2], &output[0], &output[1], &output[2]);
output[3] = inputColor[3];
}
static void vectorscope_put_cross(unsigned char r, unsigned char g,
unsigned char b,
char * tgt, int w, int h, int size)
{
float rgb[3], yuv[3];
char * p;
int x = 0;
int y = 0;
rgb[0]= (float)r/255.0f;
rgb[1]= (float)g/255.0f;
rgb[2]= (float)b/255.0f;
rgb_to_yuv(rgb, yuv);
p = tgt + 4 * (w * (int) ((yuv[2] * (h - 3) + 1))
+ (int) ((yuv[1] * (w - 3) + 1)));
if (r == 0 && g == 0 && b == 0) {
r = 255;
}
for (y = -size; y <= size; y++) {
for (x = -size; x <= size; x++) {
char * q = p + 4 * (y * w + x);
q[0] = r; q[1] = g; q[2] = b; q[3] = 255;
}
}
}
DO_INLINE void save_sample_line(Scopes *scopes, const int idx, const float fx, const float rgb[3], const float ycc[3])
{
float yuv[3];
/* vectorscope*/
rgb_to_yuv(rgb[0], rgb[1], rgb[2], &yuv[0], &yuv[1], &yuv[2]);
scopes->vecscope[idx + 0] = yuv[1];
scopes->vecscope[idx + 1] = yuv[2];
/* waveform */
switch (scopes->wavefrm_mode) {
case SCOPES_WAVEFRM_RGB:
scopes->waveform_1[idx + 0] = fx;
scopes->waveform_1[idx + 1] = rgb[0];
scopes->waveform_2[idx + 0] = fx;
scopes->waveform_2[idx + 1] = rgb[1];
scopes->waveform_3[idx + 0] = fx;
scopes->waveform_3[idx + 1] = rgb[2];
break;
case SCOPES_WAVEFRM_LUMA:
scopes->waveform_1[idx + 0] = fx;
scopes->waveform_1[idx + 1] = ycc[0];
break;
case SCOPES_WAVEFRM_YCC_JPEG:
case SCOPES_WAVEFRM_YCC_709:
case SCOPES_WAVEFRM_YCC_601:
scopes->waveform_1[idx + 0] = fx;
scopes->waveform_1[idx + 1] = ycc[0];
scopes->waveform_2[idx + 0] = fx;
scopes->waveform_2[idx + 1] = ycc[1];
scopes->waveform_3[idx + 0] = fx;
scopes->waveform_3[idx + 1] = ycc[2];
break;
}
}
void JE_setPalette( Uint8 col, Uint8 r, Uint8 g, Uint8 b )
{
palette[col].r = r;
palette[col].g = g;
palette[col].b = b;
rgb_palette[col] = SDL_MapRGB(display_surface->format, palette[col].r, palette[col].g, palette[col].b);
yuv_palette[col] = rgb_to_yuv(palette[col]);
}
void JE_updateColorsFast( const Palette colorBuffer )
{
for (int i = 0; i < 256; ++i)
{
palette[i] = colorBuffer[i];
rgb_palette[i] = SDL_MapRGB(display_surface->format, palette[i].r, palette[i].g, palette[i].b);
yuv_palette[i] = rgb_to_yuv(palette[i]);
}
}
static void fill_bins(bNode *node, CompBuf* in, int* bins)
{
float value[4];
int ivalue=0;
int x, y;
/*fill bins */
for (y=0; y<in->y; y++) {
for (x=0; x<in->x; x++) {
/* get the pixel */
qd_getPixel(in, x, y, value);
if (value[3] > 0.0f) { /* don't count transparent pixels */
switch (node->custom1) {
case 1: { /* all colors */
value[0] = rgb_to_bw(value);
value[0]=value[0]*255; /* scale to 0-255 range */
ivalue=(int)value[0];
break;
}
case 2: { /* red channel */
value[0]=value[0]*255; /* scale to 0-255 range */
ivalue=(int)value[0];
break;
}
case 3: { /* green channel */
value[1]=value[1]*255; /* scale to 0-255 range */
ivalue=(int)value[1];
break;
}
case 4: /*blue channel */
{
value[2]=value[2]*255; /* scale to 0-255 range */
ivalue=(int)value[2];
break;
}
case 5: /* luminence */
{
rgb_to_yuv(value[0], value[1], value[2], &value[0], &value[1], &value[2]);
value[0]=value[0]*255; /* scale to 0-255 range */
ivalue=(int)value[0];
break;
}
} /*end switch */
/*clip*/
if (ivalue<0) ivalue=0;
if (ivalue>255) ivalue=255;
/*put in the correct bin*/
bins[ivalue]+=1;
} /*end if alpha */
}
}
}
void MythYUVAPainter::DrawRect(const QRect &area, const QBrush &fillBrush,
const QPen &linePen, int alpha)
{
QBrush brush(fillBrush);
switch (fillBrush.style())
{
case Qt::LinearGradientPattern:
case Qt::RadialGradientPattern:
case Qt::ConicalGradientPattern:
{
QGradient gradient = *fillBrush.gradient();
QGradientStops stops = gradient.stops();
for (QGradientStops::iterator it = stops.begin(); it != stops.end(); ++it)
{
it->second = rgb_to_yuv(it->second);
it->second.setAlpha(alpha);
}
gradient.setStops(stops);
brush = gradient;
}
break;
default:
brush.setColor(rgb_to_yuv(brush.color()));
break;
}
QPen pen(linePen);
pen.setColor(rgb_to_yuv(pen.color()));
// We pull an image here, in the hopes that when DrawRect
// pulls an image this will still be in the cache and have
// the right properties.
MythImage *im = GetImageFromRect(area, 0, 0, brush, pen);
if (im)
{
im->SetToYUV();
im->DecrRef();
im = NULL;
}
MythQImagePainter::DrawRect(area, brush, pen, alpha);
}
static float brightness_standard_deviation(bNode* node, CompBuf* in, float mean)
{
float sum=0.0;
int numPixels=0.0;
int x,y;
float value[4];
for(x=0; x< in->x; x++) {
for(y=0; y < in->y; y++) {
/* get the pixel */
qd_getPixel(in, x, y, value);
if(value[3] > 0.0) { /* don't count transparent pixels */
numPixels++;
switch(node->custom1)
{
case 1:
{
rgb_tobw(value[0],value[1],value[2], &value[0]);
sum+=(value[0]-mean)*(value[0]-mean);
break;
}
case 2:
{
sum+=value[0];
sum+=(value[0]-mean)*(value[0]-mean);
break;
}
case 3:
{
sum+=value[1];
sum+=(value[1]-mean)*(value[1]-mean);
break;
}
case 4:
{
sum+=value[2];
sum+=(value[2]-mean)*(value[2]-mean);
break;
}
case 5:
{
rgb_to_yuv(value[0],value[1],value[2], &value[0], &value[1], &value[2]);
sum+=(value[0]-mean)*(value[0]-mean);
break;
}
}
}
}
}
return sqrt(sum/(float)(numPixels-1));
}
void RGBtoYUYV(const planar_rgb_image_t* image_in, picture_t* p_pic_out)
{
for(int y = 0; y < p_pic_out->p[0].i_visible_lines; y++)
{
uint8_t* position = &(p_pic_out->p[0].p_pixels[y * p_pic_out->p[0].i_pitch]);
uint8_t* position_end = position + p_pic_out->p[0].i_visible_pitch;
const uint8_t* r_position = &(image_in->r_plane[y * image_in->pitch]);
const uint8_t* g_position = &(image_in->g_plane[y * image_in->pitch]);
const uint8_t* b_position = &(image_in->b_plane[y * image_in->pitch]);
while (position < position_end)
{
uint8_t y1,u1,v1, y2,v2,u2;
const int r1 = *r_position;
const int r2 = *(++r_position);
const int g1 = *g_position;
const int g2 = *(++g_position);
const int b1 = *b_position;
const int b2 = *(++b_position);
rgb_to_yuv(&y1, &u1, &v1, r1, g1, b1);
rgb_to_yuv(&y2, &u2, &v2, r2, g2, b2);
int sum_u = u1 + u2;
int sum_v = v1 + v2;
*(position) = y1;
*(++position) = sum_u / 2;
*(++position) = y2;
*(++position) = sum_v / 2;
++position;
++r_position;
++g_position;
++b_position;
}
}
}
static void do_sepyuva(bNode *UNUSED(node), float *out, float *in)
{
float y, u, v;
rgb_to_yuv(in[0], in[1], in[2], &y, &u, &v);
out[0]= y;
out[1]= u;
out[2]= v;
out[3]= in[3];
}
void MythYUVAPainter::DrawEllipse(const QRect &area, const QBrush &fillBrush,
const QPen &linePen, int alpha)
{
QBrush brush(fillBrush);
brush.setColor(rgb_to_yuv(brush.color()));
QPen pen(linePen);
pen.setColor(rgb_to_yuv(pen.color()));
// We pull an image here, in the hopes that when DrawRect
// pulls an image this will still be in the cache and have
// the right properties.
MythImage *im = GetImageFromRect(area, 0, 1, brush, pen);
if (im)
{
im->SetToYUV();
im->DecrRef();
im = NULL;
}
MythQImagePainter::DrawEllipse(area, brush, pen, alpha);
}
static void vectorscope_draw_target(float centerx, float centery, float diam, const float colf[3])
{
float y, u, v;
float tangle = 0.f, tampli;
float dangle, dampli, dangle2, dampli2;
rgb_to_yuv(colf[0], colf[1], colf[2], &y, &u, &v);
if (u > 0 && v >= 0) tangle = atanf(v / u);
else if (u > 0 && v < 0) tangle = atanf(v / u) + 2.0f * (float)M_PI;
else if (u < 0) tangle = atanf(v / u) + (float)M_PI;
else if (u == 0 && v > 0.0f) tangle = (float)M_PI / 2.0f;
else if (u == 0 && v < 0.0f) tangle = -(float)M_PI / 2.0f;
tampli = sqrtf(u * u + v * v);
/* small target vary by 2.5 degree and 2.5 IRE unit */
glColor4f(1.0f, 1.0f, 1.0, 0.12f);
dangle = DEG2RADF(2.5f);
dampli = 2.5f / 200.0f;
glBegin(GL_LINE_STRIP);
glVertex2f(polar_to_x(centerx, diam, tampli + dampli, tangle + dangle), polar_to_y(centery, diam, tampli + dampli, tangle + dangle));
glVertex2f(polar_to_x(centerx, diam, tampli - dampli, tangle + dangle), polar_to_y(centery, diam, tampli - dampli, tangle + dangle));
glVertex2f(polar_to_x(centerx, diam, tampli - dampli, tangle - dangle), polar_to_y(centery, diam, tampli - dampli, tangle - dangle));
glVertex2f(polar_to_x(centerx, diam, tampli + dampli, tangle - dangle), polar_to_y(centery, diam, tampli + dampli, tangle - dangle));
glVertex2f(polar_to_x(centerx, diam, tampli + dampli, tangle + dangle), polar_to_y(centery, diam, tampli + dampli, tangle + dangle));
glEnd();
/* big target vary by 10 degree and 20% amplitude */
glColor4f(1.0f, 1.0f, 1.0, 0.12f);
dangle = DEG2RADF(10.0f);
dampli = 0.2f * tampli;
dangle2 = DEG2RADF(5.0f);
dampli2 = 0.5f * dampli;
glBegin(GL_LINE_STRIP);
glVertex2f(polar_to_x(centerx, diam, tampli + dampli - dampli2, tangle + dangle), polar_to_y(centery, diam, tampli + dampli - dampli2, tangle + dangle));
glVertex2f(polar_to_x(centerx, diam, tampli + dampli, tangle + dangle), polar_to_y(centery, diam, tampli + dampli, tangle + dangle));
glVertex2f(polar_to_x(centerx, diam, tampli + dampli, tangle + dangle - dangle2), polar_to_y(centery, diam, tampli + dampli, tangle + dangle - dangle2));
glEnd();
glBegin(GL_LINE_STRIP);
glVertex2f(polar_to_x(centerx, diam, tampli - dampli + dampli2, tangle + dangle), polar_to_y(centery, diam, tampli - dampli + dampli2, tangle + dangle));
glVertex2f(polar_to_x(centerx, diam, tampli - dampli, tangle + dangle), polar_to_y(centery, diam, tampli - dampli, tangle + dangle));
glVertex2f(polar_to_x(centerx, diam, tampli - dampli, tangle + dangle - dangle2), polar_to_y(centery, diam, tampli - dampli, tangle + dangle - dangle2));
glEnd();
glBegin(GL_LINE_STRIP);
glVertex2f(polar_to_x(centerx, diam, tampli - dampli + dampli2, tangle - dangle), polar_to_y(centery, diam, tampli - dampli + dampli2, tangle - dangle));
glVertex2f(polar_to_x(centerx, diam, tampli - dampli, tangle - dangle), polar_to_y(centery, diam, tampli - dampli, tangle - dangle));
glVertex2f(polar_to_x(centerx, diam, tampli - dampli, tangle - dangle + dangle2), polar_to_y(centery, diam, tampli - dampli, tangle - dangle + dangle2));
glEnd();
glBegin(GL_LINE_STRIP);
glVertex2f(polar_to_x(centerx, diam, tampli + dampli - dampli2, tangle - dangle), polar_to_y(centery, diam, tampli + dampli - dampli2, tangle - dangle));
glVertex2f(polar_to_x(centerx, diam, tampli + dampli, tangle - dangle), polar_to_y(centery, diam, tampli + dampli, tangle - dangle));
glVertex2f(polar_to_x(centerx, diam, tampli + dampli, tangle - dangle + dangle2), polar_to_y(centery, diam, tampli + dampli, tangle - dangle + dangle2));
glEnd();
}
static float brightness_mean(bNode *node, CompBuf* in)
{
float sum=0.0;
int numPixels=0.0;
int x, y;
float value[4];
for (x=0; x< in->x; x++) {
for (y=0; y < in->y; y++) {
/* get the pixel */
qd_getPixel(in, x, y, value);
if (value[3] > 0.0f) { /* don't count transparent pixels */
numPixels++;
switch (node->custom1) {
case 1:
{
value[0] = rgb_to_bw(value);
sum+=value[0];
break;
}
case 2:
{
sum+=value[0];
break;
}
case 3:
{
sum+=value[1];
break;
}
case 4:
{
sum+=value[2];
break;
}
case 5:
{
rgb_to_yuv(value[0], value[1], value[2], &value[0], &value[1], &value[2]);
sum+=value[0];
break;
}
}
}
}
}
return sum/numPixels;
}
static struct ImBuf *make_vectorscope_view_from_ibuf_float(struct ImBuf * ibuf)
{
struct ImBuf * rval = IMB_allocImBuf(515, 515, 32, IB_rect);
int x,y;
float* src = ibuf->rect_float;
char* tgt = (char*) rval->rect;
float rgb[3], yuv[3];
int w = 515;
int h = 515;
float scope_gamma = 0.2;
unsigned char wtable[256];
for (x = 0; x < 256; x++) {
wtable[x] = (unsigned char) (pow(((float) x + 1)/256,
scope_gamma)*255);
}
for (x = 0; x <= 255; x++) {
vectorscope_put_cross(255 , 0,255 - x, tgt, w, h, 1);
vectorscope_put_cross(255 , x, 0, tgt, w, h, 1);
vectorscope_put_cross(255- x, 255, 0, tgt, w, h, 1);
vectorscope_put_cross(0, 255, x, tgt, w, h, 1);
vectorscope_put_cross(0, 255 - x, 255, tgt, w, h, 1);
vectorscope_put_cross(x, 0, 255, tgt, w, h, 1);
}
for (y = 0; y < ibuf->y; y++) {
for (x = 0; x < ibuf->x; x++) {
float * src1 = src + 4 * (ibuf->x * y + x);
char * p;
memcpy(rgb, src1, 3 * sizeof(float));
CLAMP(rgb[0], 0.0f, 1.0f);
CLAMP(rgb[1], 0.0f, 1.0f);
CLAMP(rgb[2], 0.0f, 1.0f);
rgb_to_yuv(rgb, yuv);
p = tgt + 4 * (w * (int) ((yuv[2] * (h - 3) + 1))
+ (int) ((yuv[1] * (w - 3) + 1)));
scope_put_pixel(wtable, (unsigned char*)p);
}
}
vectorscope_put_cross(0, 0, 0, tgt, w, h, 3);
return rval;
}
inline value_type convert(const value_type& v, ColorSpaceType input, ColorSpaceType output) {
if (input == ColorSpaceRGB) {
if (output == ColorSpaceRGB) return v;
if (output == ColorSpaceYUV) return rgb_to_yuv(v);
if (output == ColorSpaceLAB) return rgb_to_lab(v);
}
if (input == ColorSpaceYUV) {
if (output == ColorSpaceRGB) return yuv_to_rgb(v);
if (output == ColorSpaceYUV) return v;
if (output == ColorSpaceLAB) return yuv_to_lab(v);
}
if (input == ColorSpaceLAB) {
if (output == ColorSpaceRGB) return lab_to_rgb(v);
if (output == ColorSpaceYUV) return lab_to_yuv(v);
if (output == ColorSpaceLAB) return v;
}
return value_type::Zero();
}
static void node_composit_exec_sepyuva(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out)
{
/* stack order out: bw channels */
/* stack order in: col */
/* input no image? then only color operation */
if(in[0]->data==NULL) {
float y, u, v;
rgb_to_yuv(in[0]->vec[0], in[0]->vec[1], in[0]->vec[2], &y, &u, &v);
out[0]->vec[0] = y;
out[1]->vec[0] = u;
out[2]->vec[0] = v;
out[3]->vec[0] = in[0]->vec[3];
}
else if ((out[0]->hasoutput) || (out[1]->hasoutput) || (out[2]->hasoutput) || (out[3]->hasoutput)) {
/* make copy of buffer so input image doesn't get corrupted */
CompBuf *cbuf= dupalloc_compbuf(in[0]->data);
CompBuf *cbuf2=typecheck_compbuf(cbuf, CB_RGBA);
/* convert the RGB stackbuf to an YUV representation */
composit1_pixel_processor(node, cbuf2, cbuf2, in[0]->vec, do_sepyuva, CB_RGBA);
/* separate each of those channels */
if(out[0]->hasoutput)
out[0]->data= valbuf_from_rgbabuf(cbuf2, CHAN_R);
if(out[1]->hasoutput)
out[1]->data= valbuf_from_rgbabuf(cbuf2, CHAN_G);
if(out[2]->hasoutput)
out[2]->data= valbuf_from_rgbabuf(cbuf2, CHAN_B);
if(out[3]->hasoutput)
out[3]->data= valbuf_from_rgbabuf(cbuf2, CHAN_A);
/*not used anymore */
if(cbuf2!=cbuf)
free_compbuf(cbuf2);
free_compbuf(cbuf);
}
}
void JE_fadeColors( Palette fromColors, Palette toColors, unsigned int startColor, unsigned int numColors, int numSteps )
{
for (int s = 0; s <= numSteps; ++s)
{
setdelay(1);
for (unsigned int i = startColor; i <= startColor + numColors; ++i)
{
//long difference = toColors[i].r - fromColors[i].r;
//long each_step = difference / static_cast<long>(numSteps);
//double steps_so_far = each_step * s;
//palette[i].r = static_cast<Uint8>(steps_so_far) + fromColors[i].r;
//palette[i].r = (toColors[i].r - fromColors[i].r) / numSteps * s + fromColors[i].r;
palette[i].r = fromColors[i].r + (toColors[i].r - fromColors[i].r) * s / numSteps;
palette[i].g = fromColors[i].g + (toColors[i].g - fromColors[i].g) * s / numSteps;
palette[i].b = fromColors[i].b + (toColors[i].b - fromColors[i].b) * s / numSteps;
rgb_palette[i] = SDL_MapRGB(display_surface->format, palette[i].r, palette[i].g, palette[i].b);
yuv_palette[i] = rgb_to_yuv(palette[i]);
}
JE_showVGA();
wait_delay();
}
}
/* used by node view too */
void ED_image_draw_info(Scene *scene, ARegion *ar, int color_manage, int use_default_view, int channels, int x, int y,
const unsigned char cp[4], const float fp[4], int *zp, float *zpf)
{
char str[256];
float dx = 6;
/* text colors */
/* XXX colored text not allowed in Blender UI */
#if 0
unsigned char red[3] = {255, 50, 50};
unsigned char green[3] = {0, 255, 0};
unsigned char blue[3] = {100, 100, 255};
#else
unsigned char red[3] = {255, 255, 255};
unsigned char green[3] = {255, 255, 255};
unsigned char blue[3] = {255, 255, 255};
#endif
float hue = 0, sat = 0, val = 0, lum = 0, u = 0, v = 0;
float col[4], finalcol[4];
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* noisy, high contrast make impossible to read if lower alpha is used. */
glColor4ub(0, 0, 0, 190);
glRecti(0.0, 0.0, BLI_rcti_size_x(&ar->winrct) + 1, 20);
glDisable(GL_BLEND);
BLF_size(blf_mono_font, 11, 72);
glColor3ub(255, 255, 255);
BLI_snprintf(str, sizeof(str), "X:%-4d Y:%-4d |", x, y);
// UI_DrawString(6, 6, str); // works ok but fixed width is nicer.
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
if (zp) {
glColor3ub(255, 255, 255);
BLI_snprintf(str, sizeof(str), " Z:%-.4f |", 0.5f + 0.5f * (((float)*zp) / (float)0x7fffffff));
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
if (zpf) {
glColor3ub(255, 255, 255);
BLI_snprintf(str, sizeof(str), " Z:%-.3f |", *zpf);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
if (channels >= 3) {
glColor3ubv(red);
if (fp)
BLI_snprintf(str, sizeof(str), " R:%-.5f", fp[0]);
else if (cp)
BLI_snprintf(str, sizeof(str), " R:%-3d", cp[0]);
else
BLI_snprintf(str, sizeof(str), " R:-");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
glColor3ubv(green);
if (fp)
BLI_snprintf(str, sizeof(str), " G:%-.5f", fp[1]);
else if (cp)
BLI_snprintf(str, sizeof(str), " G:%-3d", cp[1]);
else
BLI_snprintf(str, sizeof(str), " G:-");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
glColor3ubv(blue);
if (fp)
BLI_snprintf(str, sizeof(str), " B:%-.5f", fp[2]);
else if (cp)
BLI_snprintf(str, sizeof(str), " B:%-3d", cp[2]);
else
BLI_snprintf(str, sizeof(str), " B:-");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
if (channels == 4) {
glColor3ub(255, 255, 255);
if (fp)
BLI_snprintf(str, sizeof(str), " A:%-.4f", fp[3]);
else if (cp)
BLI_snprintf(str, sizeof(str), " A:%-3d", cp[3]);
else
BLI_snprintf(str, sizeof(str), "- ");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
if (color_manage && channels == 4) {
float pixel[4];
if (use_default_view)
IMB_colormanagement_pixel_to_display_space_v4(pixel, fp, NULL, &scene->display_settings);
else
IMB_colormanagement_pixel_to_display_space_v4(pixel, fp, &scene->view_settings, &scene->display_settings);
BLI_snprintf(str, sizeof(str), " | CM R:%-.4f G:%-.4f B:%-.4f", pixel[0], pixel[1], pixel[2]);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
}
/* color rectangle */
if (channels == 1) {
if (fp) {
col[0] = col[1] = col[2] = fp[0];
}
else if (cp) {
col[0] = col[1] = col[2] = (float)cp[0] / 255.0f;
}
else {
col[0] = col[1] = col[2] = 0.0f;
}
col[3] = 1.0f;
}
else if (channels == 3) {
if (fp) {
copy_v3_v3(col, fp);
}
else if (cp) {
rgb_uchar_to_float(col, cp);
}
else {
zero_v3(col);
}
col[3] = 1.0f;
}
else if (channels == 4) {
if (fp)
copy_v4_v4(col, fp);
else if (cp) {
rgba_uchar_to_float(col, cp);
}
else {
zero_v4(col);
}
}
else {
BLI_assert(0);
zero_v4(col);
}
if (color_manage) {
if (use_default_view)
IMB_colormanagement_pixel_to_display_space_v4(finalcol, col, NULL, &scene->display_settings);
else
IMB_colormanagement_pixel_to_display_space_v4(finalcol, col, &scene->view_settings, &scene->display_settings);
}
else {
copy_v4_v4(finalcol, col);
}
glDisable(GL_BLEND);
glColor3fv(finalcol);
dx += 5;
glBegin(GL_QUADS);
glVertex2f(dx, 3);
glVertex2f(dx, 17);
glVertex2f(dx + 30, 17);
glVertex2f(dx + 30, 3);
glEnd();
/* draw outline */
glColor3ub(128, 128, 128);
glBegin(GL_LINE_LOOP);
glVertex2f(dx, 3);
glVertex2f(dx, 17);
glVertex2f(dx + 30, 17);
glVertex2f(dx + 30, 3);
glEnd();
dx += 35;
glColor3ub(255, 255, 255);
if (channels == 1) {
if (fp) {
rgb_to_hsv(fp[0], fp[0], fp[0], &hue, &sat, &val);
rgb_to_yuv(fp[0], fp[0], fp[0], &lum, &u, &v);
}
else if (cp) {
rgb_to_hsv((float)cp[0] / 255.0f, (float)cp[0] / 255.0f, (float)cp[0] / 255.0f, &hue, &sat, &val);
rgb_to_yuv((float)cp[0] / 255.0f, (float)cp[0] / 255.0f, (float)cp[0] / 255.0f, &lum, &u, &v);
}
BLI_snprintf(str, sizeof(str), "V:%-.4f", val);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
BLI_snprintf(str, sizeof(str), " L:%-.4f", lum);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
else if (channels >= 3) {
if (fp) {
rgb_to_hsv(fp[0], fp[1], fp[2], &hue, &sat, &val);
rgb_to_yuv(fp[0], fp[1], fp[2], &lum, &u, &v);
}
else if (cp) {
rgb_to_hsv((float)cp[0] / 255.0f, (float)cp[1] / 255.0f, (float)cp[2] / 255.0f, &hue, &sat, &val);
rgb_to_yuv((float)cp[0] / 255.0f, (float)cp[1] / 255.0f, (float)cp[2] / 255.0f, &lum, &u, &v);
}
BLI_snprintf(str, sizeof(str), "H:%-.4f", hue);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
BLI_snprintf(str, sizeof(str), " S:%-.4f", sat);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
BLI_snprintf(str, sizeof(str), " V:%-.4f", val);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
BLI_snprintf(str, sizeof(str), " L:%-.4f", lum);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
(void)dx;
}
static void combine_side_by_side_yuv420(picture_t *p_inpic, picture_t *p_outpic,
int left, int right)
{
uint8_t *y1inl = p_inpic->p[Y_PLANE].p_pixels;
uint8_t *y2inl;
uint8_t *uinl = p_inpic->p[U_PLANE].p_pixels;
uint8_t *vinl = p_inpic->p[V_PLANE].p_pixels;
uint8_t *y1out = p_outpic->p[Y_PLANE].p_pixels;
uint8_t *y2out;
uint8_t *uout = p_outpic->p[U_PLANE].p_pixels;
uint8_t *vout = p_outpic->p[V_PLANE].p_pixels;
const int in_pitch = p_inpic->p[Y_PLANE].i_pitch;
const int out_pitch = p_outpic->p[Y_PLANE].i_pitch;
const int visible_pitch = p_inpic->p[Y_PLANE].i_visible_pitch;
const int visible_lines = p_inpic->p[Y_PLANE].i_visible_lines;
const int uv_visible_pitch = p_inpic->p[U_PLANE].i_visible_pitch;
const uint8_t *yend = y1inl + visible_lines * in_pitch;
while (y1inl < yend)
{
uint8_t *y1inr = y1inl + visible_pitch/2;
uint8_t *y2inr;
uint8_t *uinr = uinl + uv_visible_pitch/2;
uint8_t *vinr = vinl + uv_visible_pitch/2;
const uint8_t *y1end = y1inr;
y2inl = y1inl + in_pitch;
y2inr = y1inr + in_pitch;
y2out = y1out + out_pitch;
while (y1inl < y1end)
{
int rl, gl, bl, rr, gr, br, r, g, b;
int rshift = !!((0xff0000&left) && (0xff0000&right));
int gshift = !!((0x00ff00&left) && (0x00ff00&right));
int bshift = !!((0x0000ff&left) && (0x0000ff&right));
yuv_to_rgb(&rl, &gl, &bl, *y1inl, *uinl, *vinl);
yuv_to_rgb(&rr, &gr, &br, *y1inr, *uinr, *vinr);
r = ((!!(0xff0000&left))*rl + (!!(0xff0000&right))*rr)>>rshift;
g = ((!!(0x00ff00&left))*gl + (!!(0x00ff00&right))*gr)>>gshift;
b = ((!!(0x0000ff&left))*bl + (!!(0x0000ff&right))*br)>>bshift;
rgb_to_yuv(y1out, uout++, vout++, r, g, b);
y1out[1] = *y1out;
y1out+=2;
y1inl++;
y1inr++;
yuv_to_rgb(&rl, &gl, &bl, *y1inl, *uinl, *vinl);
yuv_to_rgb(&rr, &gr, &br, *y1inr, *uinr, *vinr);
r = ((!!(0xff0000&left))*rl + (!!(0xff0000&right))*rr)>>rshift;
g = ((!!(0x00ff00&left))*gl + (!!(0x00ff00&right))*gr)>>gshift;
b = ((!!(0x0000ff&left))*bl + (!!(0x0000ff&right))*br)>>bshift;
rgb_to_yuv(y1out, uout++, vout++, r, g, b);
y1out[1] = *y1out;
y1out+=2;
y1inl++;
y1inr++;
yuv_to_rgb(&rl, &gl, &bl, *y2inl, *uinl, *vinl);
yuv_to_rgb(&rr, &gr, &br, *y2inr, *uinr, *vinr);
r = ((!!(0xff0000&left))*rl + (!!(0xff0000&right))*rr)>>rshift;
g = ((!!(0x00ff00&left))*gl + (!!(0x00ff00&right))*gr)>>gshift;
b = ((!!(0x0000ff&left))*bl + (!!(0x0000ff&right))*br)>>bshift;
rgb_to_yuv(y2out, uout/*will be overwritten later, as will vout*/, vout, r, g, b);
y2out[1] = *y2out;
y2out+=2;
y2inl++;
y2inr++;
yuv_to_rgb(&rl, &gl, &bl, *y2inl, *uinl, *vinl);
yuv_to_rgb(&rr, &gr, &br, *y2inr, *uinr, *vinr);
r = ((!!(0xff0000&left))*rl + (!!(0xff0000&right))*rr)>>rshift;
g = ((!!(0x00ff00&left))*gl + (!!(0x00ff00&right))*gr)>>gshift;
b = ((!!(0x0000ff&left))*bl + (!!(0x0000ff&right))*br)>>bshift;
rgb_to_yuv(y2out, uout/*will be overwritten later, as will vout*/, vout, r, g, b);
y2out[1] = *y2out;
y2out+=2;
y2inl++;
y2inr++;
uinl++;
vinl++;
uinr++;
vinr++;
}
y1inl = y1inr + 2*in_pitch - visible_pitch;
y1out += 2*out_pitch - visible_pitch;
uinl = uinr + p_inpic->p[U_PLANE].i_pitch - uv_visible_pitch;
vinl = vinr + p_inpic->p[V_PLANE].i_pitch - uv_visible_pitch;
uout += p_outpic->p[U_PLANE].i_pitch - uv_visible_pitch;
vout += p_outpic->p[V_PLANE].i_pitch - uv_visible_pitch;
}
}
inline value_type lab_to_yuv(const value_type& v) {
return rgb_to_yuv(lab_to_rgb(v));
}
void draw_image_info(ARegion *ar, int color_manage, int channels, int x, int y, char *cp, float *fp, int *zp, float *zpf)
{
char str[256];
float dx= 6;
/* text colors */
/* XXX colored text not allowed in Blender UI */
#if 0
unsigned char red[3] = {255, 50, 50};
unsigned char green[3] = {0, 255, 0};
unsigned char blue[3] = {100, 100, 255};
#else
unsigned char red[3] = {255, 255, 255};
unsigned char green[3] = {255, 255, 255};
unsigned char blue[3] = {255, 255, 255};
#endif
float hue=0, sat=0, val=0, lum=0, u=0, v=0;
float col[4], finalcol[4];
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* noisy, high contrast make impossible to read if lower alpha is used. */
glColor4ub(0, 0, 0, 190);
glRecti(0.0, 0.0, ar->winrct.xmax - ar->winrct.xmin + 1, 20);
glDisable(GL_BLEND);
BLF_size(blf_mono_font, 11, 72);
glColor3ub(255, 255, 255);
sprintf(str, "X:%-4d Y:%-4d |", x, y);
// UI_DrawString(6, 6, str); // works ok but fixed width is nicer.
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
if(zp) {
glColor3ub(255, 255, 255);
sprintf(str, " Z:%-.4f |", 0.5f+0.5f*(((float)*zp)/(float)0x7fffffff));
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
if(zpf) {
glColor3ub(255, 255, 255);
sprintf(str, " Z:%-.3f |", *zpf);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
if(channels >= 3) {
glColor3ubv(red);
if (fp)
sprintf(str, " R:%-.4f", fp[0]);
else if (cp)
sprintf(str, " R:%-3d", cp[0]);
else
sprintf(str, " R:-");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
glColor3ubv(green);
if (fp)
sprintf(str, " G:%-.4f", fp[1]);
else if (cp)
sprintf(str, " G:%-3d", cp[1]);
else
sprintf(str, " G:-");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
glColor3ubv(blue);
if (fp)
sprintf(str, " B:%-.4f", fp[2]);
else if (cp)
sprintf(str, " B:%-3d", cp[2]);
else
sprintf(str, " B:-");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
if(channels == 4) {
glColor3ub(255, 255, 255);
if (fp)
sprintf(str, " A:%-.4f", fp[3]);
else if (cp)
sprintf(str, " A:%-3d", cp[3]);
else
sprintf(str, "- ");
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
}
/* color rectangle */
if (channels==1) {
if (fp)
col[0] = col[1] = col[2] = fp[0];
else if (cp)
col[0] = col[1] = col[2] = (float)cp[0]/255.0f;
else
col[0] = col[1] = col[2] = 0.0f;
}
else if (channels==3) {
if (fp)
copy_v3_v3(col, fp);
else if (cp) {
col[0] = (float)cp[0]/255.0f;
col[1] = (float)cp[1]/255.0f;
col[2] = (float)cp[2]/255.0f;
}
else
zero_v3(col);
}
else if (channels==4) {
if (fp)
copy_v4_v4(col, fp);
else if (cp) {
col[0] = (float)cp[0]/255.0f;
col[1] = (float)cp[1]/255.0f;
col[2] = (float)cp[2]/255.0f;
col[3] = (float)cp[3]/255.0f;
}
else
zero_v4(col);
}
if (color_manage) {
linearrgb_to_srgb_v3_v3(finalcol, col);
finalcol[3] = col[3];
}
else {
copy_v4_v4(finalcol, col);
}
glDisable(GL_BLEND);
glColor3fv(finalcol);
dx += 5;
glBegin(GL_QUADS);
glVertex2f(dx, 3);
glVertex2f(dx, 17);
glVertex2f(dx+30, 17);
glVertex2f(dx+30, 3);
glEnd();
dx += 35;
glColor3ub(255, 255, 255);
if(channels == 1) {
if (fp) {
rgb_to_hsv(fp[0], fp[0], fp[0], &hue, &sat, &val);
rgb_to_yuv(fp[0], fp[0], fp[0], &lum, &u, &v);
}
else if (cp) {
rgb_to_hsv((float)cp[0]/255.0f, (float)cp[0]/255.0f, (float)cp[0]/255.0f, &hue, &sat, &val);
rgb_to_yuv((float)cp[0]/255.0f, (float)cp[0]/255.0f, (float)cp[0]/255.0f, &lum, &u, &v);
}
sprintf(str, "V:%-.4f", val);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
sprintf(str, " L:%-.4f", lum);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
else if(channels >= 3) {
if (fp) {
rgb_to_hsv(fp[0], fp[1], fp[2], &hue, &sat, &val);
rgb_to_yuv(fp[0], fp[1], fp[2], &lum, &u, &v);
}
else if (cp) {
rgb_to_hsv((float)cp[0]/255.0f, (float)cp[1]/255.0f, (float)cp[2]/255.0f, &hue, &sat, &val);
rgb_to_yuv((float)cp[0]/255.0f, (float)cp[1]/255.0f, (float)cp[2]/255.0f, &lum, &u, &v);
}
sprintf(str, "H:%-.4f", hue);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
sprintf(str, " S:%-.4f", sat);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
sprintf(str, " V:%-.4f", val);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
sprintf(str, " L:%-.4f", lum);
BLF_position(blf_mono_font, dx, 6, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str);
}
(void)dx;
}
static bool process_server_message ( filter_t *p_filter,
rfbServerToClientMsg *msg )
{
filter_sys_t *p_sys = p_filter->p_sys;
switch (msg->type)
{
case rfbFramebufferUpdate:
{
msg->fu.nRects = htons(msg->fu.nRects);
rfbFramebufferUpdateRectHeader hdr;
for (int i_rect = 0; i_rect < msg->fu.nRects; i_rect++)
{
if (!read_exact(p_filter, p_sys->i_socket, &hdr,
sz_rfbFramebufferUpdateRectHeader ) )
{
msg_Err( p_filter, "Could not read FrameBufferUpdate header" );
return false;
}
hdr.r.x = htons(hdr.r.x);
hdr.r.y = htons(hdr.r.y);
hdr.r.w = htons(hdr.r.w);
hdr.r.h = htons(hdr.r.h);
hdr.encoding = htonl(hdr.encoding);
switch (hdr.encoding)
{
case rfbEncodingRaw:
{
int i_line;
for (i_line = 0; i_line < hdr.r.h; i_line++)
{
if ( !read_exact( p_filter, p_sys->i_socket,
p_sys->read_buffer, hdr.r.w ) )
{
msg_Err( p_filter,
"Could not read FrameBufferUpdate line data" );
return false;
}
vlc_mutex_lock( &p_sys->lock );
if ( !raw_line( p_sys, hdr.r.x,
hdr.r.y + i_line,
hdr.r.w ) )
{
msg_Err( p_filter, "raw_line failed." );
vlc_mutex_unlock( &p_sys->lock );
return false;
}
vlc_mutex_unlock( &p_sys->lock );
}
}
break;
case rfbEncodingCopyRect:
{
rfbCopyRect rect;
if ( !read_exact( p_filter, p_sys->i_socket,
&rect, sz_rfbCopyRect ) )
{
msg_Err( p_filter, "Could not read rfbCopyRect" );
return false;
}
rect.srcX = htons( rect.srcX );
rect.srcY = htons( rect.srcY );
vlc_mutex_lock( &p_sys->lock );
if ( !copy_rect( p_sys,
hdr.r.x, hdr.r.y,
hdr.r.w, hdr.r.h,
rect.srcX, rect.srcY ) )
{
msg_Err( p_filter, "copy_rect failed." );
vlc_mutex_unlock( &p_sys->lock );
return false;
}
vlc_mutex_unlock( &p_sys->lock );
}
break;
case rfbEncodingRRE:
{
rfbRREHeader rrehdr;
if ( !read_exact( p_filter, p_sys->i_socket,
&rrehdr, sz_rfbRREHeader ) )
{
msg_Err( p_filter, "Could not read rfbRREHeader" );
return false;
}
uint8_t i_pixcolor;
if ( !read_exact( p_filter, p_sys->i_socket,
&i_pixcolor, 1 ) )
{
msg_Err( p_filter, "Could not read RRE pixcolor" );
return false;
}
vlc_mutex_lock( &p_sys->lock );
if ( !fill_rect( p_sys,
hdr.r.x, hdr.r.y,
hdr.r.w, hdr.r.h,
i_pixcolor) )
{
msg_Err( p_filter, "main fill_rect failed." );
vlc_mutex_unlock( &p_sys->lock );
return false;
}
vlc_mutex_unlock( &p_sys->lock );
rrehdr.nSubrects = htonl(rrehdr.nSubrects);
int i_datasize = rrehdr.nSubrects *
( sizeof(i_pixcolor) + sz_rfbRectangle ) ;
if ( i_datasize > READ_BUFFER_SIZE )
{
msg_Err( p_filter, "Buffer too small, "
"need %u bytes", i_datasize );
return false;
}
if ( !read_exact( p_filter, p_sys->i_socket,
p_sys->read_buffer, i_datasize ) )
{
msg_Err( p_filter,
"Could not read RRE subrect data" );
return false;
}
uint32_t i_subrect;
rfbRectangle* p_subrect;
int i_offset = 0;
vlc_mutex_lock( &p_sys->lock );
for ( i_subrect = 0;
i_subrect < rrehdr.nSubrects; i_subrect++)
{
i_pixcolor = p_sys->read_buffer[i_offset];
i_offset += sizeof(i_pixcolor);
p_subrect =
(rfbRectangle*)(p_sys->read_buffer + i_offset);
i_offset += sz_rfbRectangle;
if (!fill_rect( p_sys,
htons(p_subrect->x) + hdr.r.x,
htons(p_subrect->y) + hdr.r.y,
htons(p_subrect->w),
htons(p_subrect->h),
i_pixcolor) )
{
msg_Err( p_filter,
"subrect %u fill_rect failed.", i_subrect );
vlc_mutex_unlock( &p_sys->lock );
return false;
}
}
vlc_mutex_unlock( &p_sys->lock );
}
break;
}
}
vlc_mutex_lock( &p_sys->lock );
p_sys->b_need_update = true;
vlc_mutex_unlock( &p_sys->lock );
}
return true;
case rfbSetColourMapEntries:
{
msg->scme.nColours = htons(msg->scme.nColours);
msg->scme.firstColour = htons(msg->scme.firstColour);
int i_datasize;
if ( p_sys->b_alpha_from_vnc )
{
i_datasize = 2 * msg->scme.nColours * 4;
}
else
{
i_datasize = 2 * msg->scme.nColours * 3;
}
if ( i_datasize > READ_BUFFER_SIZE )
{
msg_Err( p_filter, "Buffer too small, need %u bytes",
i_datasize );
return false;
}
if ( !read_exact( p_filter, p_sys->i_socket,
p_sys->read_buffer, i_datasize ) )
{
msg_Err( p_filter, "Could not read color map data" );
return false;
}
uint8_t i_red, i_green, i_blue, i_alpha, i_color_index;
uint16_t i_offset = 0;
i_alpha = 255;
for (int i = 0; i < msg->scme.nColours; i++)
{
i_color_index = i+msg->scme.firstColour;
if ( p_sys->b_alpha_from_vnc )
{
i_alpha = p_sys->read_buffer[i_offset];
i_offset += 2;
}
i_red = p_sys->read_buffer[i_offset];
i_offset += 2;
i_green = p_sys->read_buffer[i_offset];
i_offset += 2;
i_blue = p_sys->read_buffer[i_offset];
i_offset += 2;
rgb_to_yuv( &p_sys->ar_color_table_yuv[i_color_index][0],
&p_sys->ar_color_table_yuv[i_color_index][1],
&p_sys->ar_color_table_yuv[i_color_index][2],
i_red,
i_green,
i_blue );
p_sys->ar_color_table_yuv[i][3] = i_alpha;
}
}
return true;
case rfbBell:
msg_Err( p_filter, "rfbBell received" );
return true;
case rfbServerCutText:
msg->sct.length = htons(msg->sct.length);
if ( msg->sct.length > READ_BUFFER_SIZE )
{
msg_Err( p_filter, "Buffer too small, need %u bytes", msg->sct.length );
return false;
}
if ( !read_exact( p_filter, p_sys->i_socket,
p_sys->read_buffer, msg->sct.length ) )
{
msg_Err( p_filter, "Could not read Reading rfbServerCutText data" );
return false;
}
return true;
case rfbReSizeFrameBuffer:
msg_Err( p_filter, "Reading rfbReSizeFrameBuffer not implemented" );
return false;
default:
msg_Err( p_filter, "Invalid message %u received", msg->type );
return false;
}
return false;
}
/* used by node view too */
void ED_image_draw_info(Scene *scene, ARegion *ar, bool color_manage, bool use_default_view, int channels, int x, int y,
const unsigned char cp[4], const float fp[4], const float linearcol[4], int *zp, float *zpf)
{
rcti color_rect;
char str[256];
int dx = 6;
const int dy = 0.3f * UI_UNIT_Y;
/* text colors */
/* XXX colored text not allowed in Blender UI */
#if 0
unsigned char red[3] = {255, 50, 50};
unsigned char green[3] = {0, 255, 0};
unsigned char blue[3] = {100, 100, 255};
#else
unsigned char red[3] = {255, 255, 255};
unsigned char green[3] = {255, 255, 255};
unsigned char blue[3] = {255, 255, 255};
#endif
float hue = 0, sat = 0, val = 0, lum = 0, u = 0, v = 0;
float col[4], finalcol[4];
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* noisy, high contrast make impossible to read if lower alpha is used. */
glColor4ub(0, 0, 0, 190);
glRecti(0.0, 0.0, BLI_rcti_size_x(&ar->winrct) + 1, UI_UNIT_Y);
glDisable(GL_BLEND);
BLF_size(blf_mono_font, 11 * U.pixelsize, U.dpi);
glColor3ub(255, 255, 255);
BLI_snprintf(str, sizeof(str), "X:%-4d Y:%-4d |", x, y);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
if (zp) {
glColor3ub(255, 255, 255);
BLI_snprintf(str, sizeof(str), " Z:%-.4f |", 0.5f + 0.5f * (((float)*zp) / (float)0x7fffffff));
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
}
if (zpf) {
glColor3ub(255, 255, 255);
BLI_snprintf(str, sizeof(str), " Z:%-.3f |", *zpf);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
}
if (channels >= 3) {
glColor3ubv(red);
if (fp)
BLI_snprintf(str, sizeof(str), " R:%-.5f", fp[0]);
else if (cp)
BLI_snprintf(str, sizeof(str), " R:%-3d", cp[0]);
else
BLI_snprintf(str, sizeof(str), " R:-");
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
glColor3ubv(green);
if (fp)
BLI_snprintf(str, sizeof(str), " G:%-.5f", fp[1]);
else if (cp)
BLI_snprintf(str, sizeof(str), " G:%-3d", cp[1]);
else
BLI_snprintf(str, sizeof(str), " G:-");
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
glColor3ubv(blue);
if (fp)
BLI_snprintf(str, sizeof(str), " B:%-.5f", fp[2]);
else if (cp)
BLI_snprintf(str, sizeof(str), " B:%-3d", cp[2]);
else
BLI_snprintf(str, sizeof(str), " B:-");
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
if (channels == 4) {
glColor3ub(255, 255, 255);
if (fp)
BLI_snprintf(str, sizeof(str), " A:%-.4f", fp[3]);
else if (cp)
BLI_snprintf(str, sizeof(str), " A:%-3d", cp[3]);
else
BLI_snprintf(str, sizeof(str), "- ");
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
}
if (color_manage) {
float rgba[4];
copy_v3_v3(rgba, linearcol);
if (channels == 3)
rgba[3] = 1.0f;
else
rgba[3] = linearcol[3];
if (use_default_view)
IMB_colormanagement_pixel_to_display_space_v4(rgba, rgba, NULL, &scene->display_settings);
else
IMB_colormanagement_pixel_to_display_space_v4(rgba, rgba, &scene->view_settings, &scene->display_settings);
BLI_snprintf(str, sizeof(str), " | CM R:%-.4f G:%-.4f B:%-.4f", rgba[0], rgba[1], rgba[2]);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
}
}
/* color rectangle */
if (channels == 1) {
if (fp) {
col[0] = col[1] = col[2] = fp[0];
}
else if (cp) {
col[0] = col[1] = col[2] = (float)cp[0] / 255.0f;
}
else {
col[0] = col[1] = col[2] = 0.0f;
}
col[3] = 1.0f;
}
else if (channels == 3) {
copy_v3_v3(col, linearcol);
col[3] = 1.0f;
}
else if (channels == 4) {
copy_v4_v4(col, linearcol);
}
else {
BLI_assert(0);
zero_v4(col);
}
if (color_manage) {
if (use_default_view)
IMB_colormanagement_pixel_to_display_space_v4(finalcol, col, NULL, &scene->display_settings);
else
IMB_colormanagement_pixel_to_display_space_v4(finalcol, col, &scene->view_settings, &scene->display_settings);
}
else {
copy_v4_v4(finalcol, col);
}
glDisable(GL_BLEND);
dx += 0.25f * UI_UNIT_X;
BLI_rcti_init(&color_rect, dx, dx + (1.5f * UI_UNIT_X), 0.15f * UI_UNIT_Y, 0.85f * UI_UNIT_Y);
if (channels == 4) {
rcti color_rect_half;
int color_quater_x, color_quater_y;
color_rect_half = color_rect;
color_rect_half.xmax = BLI_rcti_cent_x(&color_rect);
glRecti(color_rect.xmin, color_rect.ymin, color_rect.xmax, color_rect.ymax);
color_rect_half = color_rect;
color_rect_half.xmin = BLI_rcti_cent_x(&color_rect);
color_quater_x = BLI_rcti_cent_x(&color_rect_half);
color_quater_y = BLI_rcti_cent_y(&color_rect_half);
glColor4ub(UI_ALPHA_CHECKER_DARK, UI_ALPHA_CHECKER_DARK, UI_ALPHA_CHECKER_DARK, 255);
glRecti(color_rect_half.xmin, color_rect_half.ymin, color_rect_half.xmax, color_rect_half.ymax);
glColor4ub(UI_ALPHA_CHECKER_LIGHT, UI_ALPHA_CHECKER_LIGHT, UI_ALPHA_CHECKER_LIGHT, 255);
glRecti(color_quater_x, color_quater_y, color_rect_half.xmax, color_rect_half.ymax);
glRecti(color_rect_half.xmin, color_rect_half.ymin, color_quater_x, color_quater_y);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(UNPACK3(finalcol), fp ? fp[3] : (cp[3] / 255.0f));
glRecti(color_rect.xmin, color_rect.ymin, color_rect.xmax, color_rect.ymax);
glDisable(GL_BLEND);
}
else {
glColor3fv(finalcol);
glRecti(color_rect.xmin, color_rect.ymin, color_rect.xmax, color_rect.ymax);
}
/* draw outline */
glColor3ub(128, 128, 128);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glRecti(color_rect.xmin, color_rect.ymin, color_rect.xmax, color_rect.ymax);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
dx += 1.75f * UI_UNIT_X;
glColor3ub(255, 255, 255);
if (channels == 1) {
if (fp) {
rgb_to_hsv(fp[0], fp[0], fp[0], &hue, &sat, &val);
rgb_to_yuv(fp[0], fp[0], fp[0], &lum, &u, &v);
}
else if (cp) {
rgb_to_hsv((float)cp[0] / 255.0f, (float)cp[0] / 255.0f, (float)cp[0] / 255.0f, &hue, &sat, &val);
rgb_to_yuv((float)cp[0] / 255.0f, (float)cp[0] / 255.0f, (float)cp[0] / 255.0f, &lum, &u, &v);
}
BLI_snprintf(str, sizeof(str), "V:%-.4f", val);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
BLI_snprintf(str, sizeof(str), " L:%-.4f", lum);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
}
else if (channels >= 3) {
rgb_to_hsv(finalcol[0], finalcol[1], finalcol[2], &hue, &sat, &val);
rgb_to_yuv(finalcol[0], finalcol[1], finalcol[2], &lum, &u, &v);
BLI_snprintf(str, sizeof(str), "H:%-.4f", hue);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
BLI_snprintf(str, sizeof(str), " S:%-.4f", sat);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
BLI_snprintf(str, sizeof(str), " V:%-.4f", val);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
BLI_snprintf(str, sizeof(str), " L:%-.4f", lum);
BLF_position(blf_mono_font, dx, dy, 0);
BLF_draw_ascii(blf_mono_font, str, sizeof(str));
dx += BLF_width(blf_mono_font, str, sizeof(str));
}
(void)dx;
}
int ColorModel::alloc_color(color& c)
{
#ifdef MAC_OSX_TK
abort();
#else
int r = c.r;
int g = c.g;
int b = c.b;
if (gamma_ != 1.) {
r = int(256. * pow(r / 256., gamma_));
g = int(256. * pow(g / 256., gamma_));
b = int(256. * pow(b / 256., gamma_));
}
#ifndef WIN32
if (r == g && r == b && (r & 7) == 0 && r > 0) {
/*
* This color is one level away from the gray ramp
* used in nv, ghostscript, and the LBL-modified
* tk library. Change it so we'll end up sharing
* the colormap entry. The error won't be perceptible.
*/
r -= 1;
g -= 1;
b -= 1;
}
#endif
XColor xc;
xc.red = r << 8;
xc.green = g << 8;
xc.blue = b << 8;
if (XAllocColor(dpy_, colormap_, &xc) == 0) {
free_colors();
return (-1);
}
#ifdef WIN32
/*
* The current WinTk returns RGB values in the pixel. X returns
* a colormap index. So get the palette index and use that.
*/
TkWinColormap *cmap = (TkWinColormap *) colormap_;
UINT index = GetNearestPaletteIndex(cmap->palette, PALETTERGB(r, g, b));
int pixel = index;
pixel_[index] = xc.pixel;
color& p = colors_[ncolor_];
if (++ncolor_ >= 256) {
fprintf(stderr, "vic: colormap overflow (internal error)\n");
exit(1);
}
#if defined(WIN32) && (TCL_MAJOR_VERSION == 8) && (TCL_MINOR_VERSION == 0)
if (!win32Colors)
win32Colors = pixel_;
win32NColors = ncolor_;
#endif
#else
int pixel = xc.pixel;
pixel_[ncolor_] = pixel;
if (++ncolor_ >= 256) {
fprintf(stderr, "vic: colormap overflow (internal error)\n");
exit(1);
}
color& p = colors_[pixel];
#endif
p.r = xc.red >> 8;
p.g = xc.green >> 8;
p.b = xc.blue >> 8;
/* XXX ed ditherer needs this */
rgb_to_yuv(p);
return (pixel);
#endif // MAC_OSX_TK
}
/* TODO: Write single step conversions where they may actually be useful */
int v4l2_process_image (PyCameraObject* self, const void *image,
unsigned int buffer_size, SDL_Surface* surf)
{
if (!surf)
return 0;
SDL_LockSurface (surf);
switch (self->pixelformat) {
case V4L2_PIX_FMT_RGB24:
if (buffer_size >= self->size * 3) {
switch (self->color_out) {
case RGB_OUT:
rgb24_to_rgb(image, surf->pixels, self->size, surf->format);
break;
case HSV_OUT:
rgb_to_hsv(image, surf->pixels, self->size, V4L2_PIX_FMT_RGB24, surf->format);
break;
case YUV_OUT:
rgb_to_yuv(image, surf->pixels, self->size, V4L2_PIX_FMT_RGB24, surf->format);
break;
}
} else {
SDL_UnlockSurface (surf);
return 0;
}
break;
case V4L2_PIX_FMT_RGB444:
if (buffer_size >= self->size * 2) {
switch (self->color_out) {
case RGB_OUT:
rgb444_to_rgb(image, surf->pixels, self->size, surf->format);
break;
case HSV_OUT:
rgb_to_hsv(image, surf->pixels, self->size, V4L2_PIX_FMT_RGB444, surf->format);
break;
case YUV_OUT:
rgb_to_yuv(image, surf->pixels, self->size, V4L2_PIX_FMT_RGB444, surf->format);
break;
}
} else {
SDL_UnlockSurface (surf);
return 0;
}
break;
case V4L2_PIX_FMT_YUYV:
if (buffer_size >= self->size * 2) {
switch (self->color_out) {
case YUV_OUT:
yuyv_to_yuv(image, surf->pixels, self->size, surf->format);
break;
case RGB_OUT:
yuyv_to_rgb(image, surf->pixels, self->size, surf->format);
break;
case HSV_OUT:
yuyv_to_rgb(image, surf->pixels, self->size, surf->format);
rgb_to_hsv(surf->pixels, surf->pixels, self->size, V4L2_PIX_FMT_YUYV, surf->format);
break;
}
} else {
SDL_UnlockSurface (surf);
return 0;
}
break;
case V4L2_PIX_FMT_SBGGR8:
if (buffer_size >= self->size) {
switch (self->color_out) {
case RGB_OUT:
sbggr8_to_rgb(image, surf->pixels, self->width, self->height, surf->format);
break;
case HSV_OUT:
sbggr8_to_rgb(image, surf->pixels, self->width, self->height, surf->format);
rgb_to_hsv(surf->pixels, surf->pixels, self->size, V4L2_PIX_FMT_SBGGR8, surf->format);
break;
case YUV_OUT:
sbggr8_to_rgb(image, surf->pixels, self->width, self->height, surf->format);
rgb_to_yuv(surf->pixels, surf->pixels, self->size, V4L2_PIX_FMT_SBGGR8, surf->format);
break;
}
} else {
SDL_UnlockSurface (surf);
return 0;
}
break;
case V4L2_PIX_FMT_YUV420:
if (buffer_size >= (self->size * 3) / 2) {
switch (self->color_out) {
case YUV_OUT:
yuv420_to_yuv(image, surf->pixels, self->width, self->height, surf->format);
break;
case RGB_OUT:
yuv420_to_rgb(image, surf->pixels, self->width, self->height, surf->format);
break;
case HSV_OUT:
yuv420_to_rgb(image, surf->pixels, self->width, self->height, surf->format);
rgb_to_hsv(surf->pixels, surf->pixels, self->size, V4L2_PIX_FMT_YUV420, surf->format);
break;
}
} else {
SDL_UnlockSurface (surf);
return 0;
}
break;
}
SDL_UnlockSurface (surf);
return 1;
}
void hq2x_32_rb(WORD *screen, void *pix, uint32_t *palette) {
BYTE k;
SWORD prev_line, next_line;
WORD w[10];
WORD spL = SCR_ROWS;
WORD srb = spL * sizeof(WORD);
WORD dpL = hqnx.dst_rows * 2;
WORD drb = dpL * sizeof(uint32_t);
uint32_t *dp = (uint32_t *) pix;
uint8_t *s_row_p = (uint8_t *) screen;
uint8_t *d_row_p = (uint8_t *) dp;
uint32_t yuv1, yuv2;
uint32_t wrgb[10];
screen += hqnx.startx;
// +----+----+----+
// | | | |
// | w1 | w2 | w3 |
// +----+----+----+
// | | | |
// | w4 | w5 | w6 |
// +----+----+----+
// | | | |
// | w7 | w8 | w9 |
// +----+----+----+
for (; hqnx.sy < hqnx.lines; ++hqnx.sy) {
if (hqnx.sy > 0) {
prev_line = -spL;
} else {
prev_line = 0;
}
if (hqnx.sy < (hqnx.lines - 1)) {
next_line = spL;
} else {
next_line = 0;
}
for (hqnx.sx = hqnx.startx; hqnx.sx < hqnx.rows; ++hqnx.sx) {
int pattern, flag;
w[2] = (*(screen + prev_line));
wrgb[2] = palette[w[2]];
w[5] = (*screen);
wrgb[5] = palette[w[5]];
w[8] = (*(screen + next_line));
wrgb[8] = palette[w[8]];
if (hqnx.sx > 0) {
w[1] = (*(screen + prev_line - 1));
wrgb[1] = palette[w[1]];
w[4] = (*(screen - 1));
wrgb[4] = palette[w[4]];
w[7] = (*(screen + next_line - 1));
wrgb[7] = palette[w[7]];
} else {
w[1] = w[2];
wrgb[1] = wrgb[2];
w[4] = w[5];
wrgb[4] = wrgb[5];
w[7] = w[8];
wrgb[7] = wrgb[8];
}
if (hqnx.sx < (hqnx.rows - 1)) {
w[3] = (*(screen + prev_line + 1));
wrgb[3] = palette[w[3]];
w[6] = (*(screen + 1));
wrgb[6] = palette[w[6]];
w[9] = (*(screen + next_line + 1));
wrgb[9] = palette[w[9]];
} else {
w[3] = w[2];
wrgb[3] = wrgb[2];
w[6] = w[5];
wrgb[6] = wrgb[5];
w[9] = w[8];
wrgb[9] = wrgb[8];
}
pattern = 0;
flag = 1;
yuv1 = rgb_to_yuv(w[5]);
for (k = 1; k <= 9; k++) {
if (k == 5) {
continue;
}
if (w[k] != w[5]) {
yuv2 = rgb_to_yuv(w[k]);
if (yuv_diff(yuv1, yuv2)) {
pattern |= flag;
}
}
flag <<= 1;
}
switch (pattern) {
case 0:
case 1:
case 4:
case 32:
case 128:
case 5:
case 132:
case 160:
case 33:
case 129:
case 36:
case 133:
case 164:
case 161:
case 37:
case 165: {
PIXEL00_20
PIXEL01_20
PIXEL10_20
PIXEL11_20
break;
}
case 2:
case 34:
case 130:
case 162: {
PIXEL00_22
PIXEL01_21
PIXEL10_20
PIXEL11_20
break;
}
case 16:
case 17:
case 48:
case 49: {
PIXEL00_20
PIXEL01_22
PIXEL10_20
PIXEL11_21
break;
}
case 64:
case 65:
case 68:
case 69: {
PIXEL00_20
PIXEL01_20
PIXEL10_21
PIXEL11_22
break;
}
case 8:
case 12:
case 136:
case 140: {
PIXEL00_21
PIXEL01_20
PIXEL10_22
PIXEL11_20
break;
}
case 3:
case 35:
case 131:
case 163: {
PIXEL00_11
PIXEL01_21
PIXEL10_20
PIXEL11_20
break;
}
case 6:
case 38:
case 134:
case 166: {
PIXEL00_22
PIXEL01_12
PIXEL10_20
PIXEL11_20
break;
}
case 20:
case 21:
case 52:
case 53: {
PIXEL00_20
PIXEL01_11
PIXEL10_20
PIXEL11_21
break;
}
case 144:
case 145:
case 176:
case 177: {
PIXEL00_20
PIXEL01_22
PIXEL10_20
PIXEL11_12
break;
}
case 192:
case 193:
case 196:
case 197: {
PIXEL00_20
PIXEL01_20
PIXEL10_21
PIXEL11_11
break;
}
case 96:
case 97:
case 100:
case 101: {
PIXEL00_20
PIXEL01_20
PIXEL10_12
PIXEL11_22
break;
}
case 40:
case 44:
case 168:
case 172: {
PIXEL00_21
PIXEL01_20
PIXEL10_11
PIXEL11_20
break;
}
case 9:
case 13:
case 137:
case 141: {
PIXEL00_12
PIXEL01_20
PIXEL10_22
PIXEL11_20
break;
}
case 18:
case 50: {
PIXEL00_22
if (Diff(w[2], w[6])) {
PIXEL01_10
} else {
PIXEL01_20
}
PIXEL10_20
PIXEL11_21
break;
}
case 80:
case 81: {
PIXEL00_20
PIXEL01_22
PIXEL10_21
if (Diff(w[6], w[8])) {
PIXEL11_10
} else {
PIXEL11_20
}
break;
}
case 72:
case 76: {
PIXEL00_21
PIXEL01_20
if (Diff(w[8], w[4])) {
PIXEL10_10
} else {
PIXEL10_20
}
PIXEL11_22
break;
}
case 10:
case 138: {
if (Diff(w[4], w[2])) {
PIXEL00_10
} else {
PIXEL00_20
}
PIXEL01_21
PIXEL10_22
PIXEL11_20
break;
}
