void ColorSpace::ConvertImageYUV422ToRGB24(const void * yuvData,
size_t yuvSize, int width, int height, void* rgbData)
{
unsigned int *yuyv = (unsigned int*)yuvData;
unsigned char * rgb = (unsigned char*)rgbData;
for (int i=0,px=0; i< height*width/2;i++)
{
char r, g, b;
// read VYUY
int y2 = ((*yuyv & 0x000000ff));
int u = ((*yuyv & 0x0000ff00)>>8);
int y = ((*yuyv & 0x00ff0000)>>16);
int v = ((*yuyv & 0xff000000)>>24);
YUVToRGB(y2, u, v, &r, &g, &b);
rgb[px++] = r;
rgb[px++] = g;
rgb[px++] = b;
YUVToRGB(y, u, v, &r, &g, &b);
rgb[px++] = r;
rgb[px++] = g;
rgb[px++] = b;
yuyv++;
}
}
QVector <double> RgbF16ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
{
QVector <double> channelValues(4);
YUVToRGB(*y, *u, *v, &channelValues[0],&channelValues[1],&channelValues[2], lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
channelValues[3]=1.0;
return channelValues;
}
/******************将两个帧合并成一个帧返回**********************/
AVFrame* frame_combine(AVFrame* pFrame1,const AVFrame* pFrame2)
{
YUVToRGB(pFrame1),YUVToRGB(pFrame2);
AVFrame* r=pFrame1;
AVFrame *f1=pFrame1,*f2=pFrame2;
int i,j;
for(i=0;i<f1->height;i++)
{
for(j=0;j<3*f1->width;j++)
{
int index=i*r->width*3+j;
int a=f1->data[0][index],b=f2->data[0][index];
r->data[0][index]=cal(a,b);
}
}
RGBToYUV(r);
return r;
}
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 transform(const quint8 *srcU8, quint8 *dstU8, qint32 nPixels) const
{
//if (m_model="RGBA" || m_colorize) {
/*It'd be nice to have LCH automatically selector for LAB in the future, but I don't know how to select LAB
* */
const RGBPixel* src = reinterpret_cast<const RGBPixel*>(srcU8);
RGBPixel* dst = reinterpret_cast<RGBPixel*>(dstU8);
float h, s, v, r, g, b;
qreal lumaR, lumaG, lumaB;
//Default to rec 709 when there's no coefficients given//
if (m_lumaRed<=0 || m_lumaGreen<=0 || m_lumaBlue<=0) {
lumaR = 0.2126;
lumaG = 0.7152;
lumaB = 0.0722;
} else {
lumaR = m_lumaRed;
lumaG = m_lumaGreen;
lumaB = m_lumaBlue;
}
while (nPixels > 0) {
if (m_colorize) {
h = m_adj_h * 360;
if (h >= 360.0) h = 0;
s = m_adj_s;
r = SCALE_TO_FLOAT(src->red);
g = SCALE_TO_FLOAT(src->green);
b = SCALE_TO_FLOAT(src->blue);
float luminance = r * lumaR + g * lumaG + b * lumaB;
if (m_adj_v > 0) {
luminance *= (1.0 - m_adj_v);
luminance += 1.0 - (1.0 - m_adj_v);
}
else if (m_adj_v < 0 ){
luminance *= (m_adj_v + 1.0);
}
v = luminance;
HSLToRGB(h, s, v, &r, &g, &b);
}
else {
if (m_type == 0) {
RGBToHSV(SCALE_TO_FLOAT(src->red), SCALE_TO_FLOAT(src->green), SCALE_TO_FLOAT(src->blue), &h, &s, &v);
h += m_adj_h * 180;
if (h > 360) h -= 360;
if (h < 0) h += 360;
s += m_adj_s;
v += m_adj_v;
HSVToRGB(h, s, v, &r, &g, &b);
} else if (m_type == 1) {
RGBToHSL(SCALE_TO_FLOAT(src->red), SCALE_TO_FLOAT(src->green), SCALE_TO_FLOAT(src->blue), &h, &s, &v);
h += m_adj_h * 180;
if (h > 360) h -= 360;
if (h < 0) h += 360;
s *= (m_adj_s + 1.0);
if (s < 0.0) s = 0.0;
if (s > 1.0) s = 1.0;
if (m_adj_v < 0)
v *= (m_adj_v + 1.0);
else
v += (m_adj_v * (1.0 - v));
HSLToRGB(h, s, v, &r, &g, &b);
} else if (m_type == 2){
qreal red = SCALE_TO_FLOAT(src->red);
qreal green = SCALE_TO_FLOAT(src->green);
qreal blue = SCALE_TO_FLOAT(src->blue);
qreal hue, sat, intensity;
RGBToHCI(red, green, blue, &hue, &sat, &intensity);
hue *=360.0;
hue += m_adj_h * 180;
//if (intensity+m_adj_v>1.0){hue+=180.0;}
if (hue < 0) hue += 360;
hue = fmod(hue, 360.0);
sat *= (m_adj_s + 1.0);
//sat = qBound(0.0, sat, 1.0);
intensity += (m_adj_v);
HCIToRGB(hue/360.0, sat, intensity, &red, &green, &blue);
r = red;
g = green;
b = blue;
} else if (m_type == 3){
qreal red = SCALE_TO_FLOAT(src->red);
qreal green = SCALE_TO_FLOAT(src->green);
qreal blue = SCALE_TO_FLOAT(src->blue);
qreal hue, sat, luma;
RGBToHCY(red, green, blue, &hue, &sat, &luma, lumaR, lumaG, lumaB);
hue *=360.0;
hue += m_adj_h * 180;
//if (luma+m_adj_v>1.0){hue+=180.0;}
if (hue < 0) hue += 360;
hue = fmod(hue, 360.0);
sat *= (m_adj_s + 1.0);
//sat = qBound(0.0, sat, 1.0);
luma += m_adj_v;
HCYToRGB(hue/360.0, sat, luma, &red, &green, &blue, lumaR, lumaG, lumaB);
r = red;
g = green;
b = blue;
} else if (m_type == 4){
qreal red = SCALE_TO_FLOAT(src->red);
qreal green = SCALE_TO_FLOAT(src->green);
qreal blue = SCALE_TO_FLOAT(src->blue);
qreal y, cb, cr;
RGBToYUV(red, green, blue, &y, &cb, &cr, lumaR, lumaG, lumaB);
cb *= (m_adj_h + 1.0);
//cb = qBound(0.0, cb, 1.0);
cr *= (m_adj_s + 1.0);
//cr = qBound(0.0, cr, 1.0);
y += (m_adj_v);
YUVToRGB(y, cb, cr, &red, &green, &blue, lumaR, lumaG, lumaB);
r = red;
g = green;
b = blue;
}
}
clamp< _channel_type_ >(&r, &g, &b);
dst->red = SCALE_FROM_FLOAT(r);
dst->green = SCALE_FROM_FLOAT(g);
dst->blue = SCALE_FROM_FLOAT(b);
dst->alpha = src->alpha;
--nPixels;
++src;
++dst;
}
/*} else if (m_model="LABA"){
const LABPixel* src = reinterpret_cast<const LABPixel*>(srcU8);
LABPixel* dst = reinterpret_cast<LABPixel*>(dstU8);
qreal lightness = SCALE_TO_FLOAT(src->L);
qreal a = SCALE_TO_FLOAT(src->a);
qreal b = SCALE_TO_FLOAT(src->b);
qreal L, C, H;
while (nPixels > 0) {
if (m_type = 4) {
a *= (m_adj_h + 1.0);
a = qBound(0.0, a, 1.0);
b *= (m_adj_s + 1.0);
b = qBound(0.0, b, 1.0);
if (m_adj_v < 0)
lightness *= (m_adj_v + 1.0);
else
lightness += (m_adj_v * (1.0 - lightness));
} else {//lch
LABToLCH(lightness, a, b, &L, &C, &H);
H *=360;
H += m_adj_h * 180;
if (H > 360) h -= 360;
if (H < 0) h += 360;
C += m_adj_s;
C = qBound(0.0,C,1.0);
L += m_adj_v;
L = qBound(0.0,L,1.0);
LCHToLAB(L, C, H/360.0, &lightness, &a, &b);
}
clamp< _channel_type_ >(&lightness, &a, &b);
dst->L = SCALE_FROM_FLOAT(lightness);
dst->a = SCALE_FROM_FLOAT(a);
dst->b = SCALE_FROM_FLOAT(b);
dst->alpha = src->alpha;
--nPixels;
++src;
++dst;
}
}*/
}
//int *width = NULL;
//int *height = NULL;
void CALLBACK DecCBFun(long nPort,char * pBuf,long nSize, FRAME_INFO * pFrameInfo,long nReserved1,long)
{
if(pFrameInfo->nType == T_YV12) YUVToRGB((unsigned char *)pBuf,pOutRGB,pFrameInfo->nWidth,pFrameInfo->nHeight);
//YUVToRGB((unsigned char *)pBuf,pOutRGB,*width,*height);
* haveNewFrame = XTrue;
}
