XBMC4Xbox

<onfocus>XBMC.System.PWMControl(#FF0000)</onfocus>

<onfocus>XBMC.System.PWMControl(#00FF00)</onfocus>

<onfocus>XBMC.System.PWMControl(#FFFFFF,#000000,#000000,#000000,firework,500)</onfocus>

<onfocus>XBMC.System.PWMControl(#FF00FF)</onfocus>

<onfocus>XBMC.System.PWMControl(#FFFF00)</onfocus>

<onfocus>XBMC.System.PWMControl(#00FFFF)</onfocus>

<onfocus>XBMC.System.PWMControl(#FFFFFF)</onfocus>

<advancedsettings>

<ambilight>

<enabled>true</enabled>

<spaceBetweenPixels>30</spaceBetweenPixels>

<FloatingAverageFrames>1</FloatingAverageFrames>

<GammaR>1.2</GammaR>

<GammaG>1.0</GammaG>

<GammaB>0.8</GammaB>

<MinRGB>2</MinRGB>

<FilterThreshold>50</FilterThreshold>

<DarknessLimit>20</DarknessLimit>

</ambilight>

</advancedsettings>

m_ambiLight = false;

m_ambiLightSpaceBetweenPixels = 30;

m_ambiLightFloatingAverageFrames = 1;

m_ambiLightMinRGB = 2;

m_ambiLightMaxRGB = 255;

m_ambiLightMode = "linear";

m_ambiLightPosition = "all";

m_ambiLightGammaR = 1.2f;

m_ambiLightGammaG = 1.0f;

m_ambiLightGammaB = 0.8f;

m_ambiLightIntensityR = 1.0f;

m_ambiLightIntensityG = 1.0f;

m_ambiLightIntensityB = 1.0f;

m_ambiLightFilterThreshold = 50;

m_ambiLightDarknessLimit = 20;

pElement = pRootElement->FirstChildElement("ambilight");

if (pElement)

{

XMLUtils::GetBoolean(pElement, "enabled", m_ambiLight);

XMLUtils::GetInt(pElement, "spaceBetweenPixels", m_ambiLightSpaceBetweenPixels);

XMLUtils::GetInt(pElement, "floatingAverageFrames", m_ambiLightFloatingAverageFrames);

XMLUtils::GetInt(pElement, "minRGB", m_ambiLightMinRGB);

XMLUtils::GetInt(pElement, "maxRGB", m_ambiLightMaxRGB);

XMLUtils::GetString(pElement, "mode", m_ambiLightMode);

XMLUtils::GetString(pElement, "position", m_ambiLightPosition);

XMLUtils::GetFloat(pElement, "gammaR", m_ambiLightGammaR);

XMLUtils::GetFloat(pElement, "gammaG", m_ambiLightGammaG);

XMLUtils::GetFloat(pElement, "gammaB", m_ambiLightGammaB);

XMLUtils::GetFloat(pElement, "intensityR", m_ambiLightIntensityR);

XMLUtils::GetFloat(pElement, "intensityG", m_ambiLightIntensityG);

XMLUtils::GetFloat(pElement, "intensityB", m_ambiLightIntensityB);

XMLUtils::GetInt(pElement, "filterThreshold", m_ambiLightFilterThreshold);

XMLUtils::GetInt(pElement, "darknessLimit", m_ambiLightDarknessLimit);

}

bool m_ambiLight;

int m_ambiLightSpaceBetweenPixels;

int m_ambiLightFloatingAverageFrames;

int m_ambiLightMinRGB;

int m_ambiLightMaxRGB;

CStdString m_ambiLightMode;

CStdString m_ambiLightPosition;

float m_ambiLightGammaR;

float m_ambiLightGammaG;

float m_ambiLightGammaB;

float m_ambiLightIntensityR;

float m_ambiLightIntensityG;

float m_ambiLightIntensityB;

int m_ambiLightFilterThreshold;

int m_ambiLightDarknessLimit;

g_iledSmartxxrgb.AmbiLightUpdateFrameNumber();

#include "utils/LED.h"

// AMBI-LIGHT STUFF

if(g_advancedSettings.m_ambiLight)

{

g_iledSmartxxrgb.AmbiLightUpdate();

g_iledSmartxxrgb.AmbiLightParamsUpdate(0,picture.iWidth,2);

for(unsigned int i=0;i<picture.iHeight;i++)

{

BYTE *s0=&picture.data[0][i*picture.iWidth];

BYTE *s1=&picture.data[1][i/2*picture.iWidth/2];

BYTE *s2=&picture.data[2][i/2*picture.iWidth/2];

g_iledSmartxxrgb.AmbiLightRGBCalculate(s0,s1,s2);

}

}

// END AMBI-LIGHT STUFF

#include "utils/LED.h"

// init Params for AmbiLight

g_iledSmartxxrgb.AmbiLightParamsInit(width,height,m_yuvcoef,m_yuvrange);

BYTE *s0,*s1,*s2;

BYTE *d0,*d1,*d2;

int w2,h2,x2,y2;

// check if we've finished the recent Frame and push it to the SmartXX...

if(g_advancedSettings.m_ambiLight)

g_iledSmartxxrgb.AmbiLightUpdate();

d0 = (BYTE*)im.plane[0] + im.stride[0] * y + x;

s0 = src[0];

w2 = w >> im.cshift_x; h2 = h >> im.cshift_y;

x2 = x >> im.cshift_x; y2 = y >> im.cshift_y;

d1 = (BYTE*)im.plane[1] + im.stride[1] * y2 + x2;

s1 = src[1];

d2 = (BYTE*)im.plane[2] + im.stride[2] * y2 + x2;

s2 = src[2];

int widthRatio = (int)(w/w2);

int heightRatio = (int)(h/h2);

//Update AmbiLights params...

if(g_advancedSettings.m_ambiLight)

g_iledSmartxxrgb.AmbiLightParamsUpdate(x,w,widthRatio);

for (int i = 0;i < h;i++)

memcpy(d0, s0, w);

s0 += stride[0];

d0 += im.stride[0];

if(i % heightRatio == 0)

{

memcpy(d1, s1, w2);

s1 += stride[1];

d1 += im.stride[1];

memcpy(d2, s2, w2);

s2 += stride[2];

d2 += im.stride[2];

}

// calculate RGB-values for the recent row of the frame...

if(g_advancedSettings.m_ambiLight)

g_iledSmartxxrgb.AmbiLightRGBCalculate(s0,s1,s2);

g_iledSmartxxrgb.AmbiLightStop();

CUtil::PWMControl(strRgbA,strRgbB,strWhiteA,strWhiteB,strTran, iTrTime);

else if(parameter.size() == 7)

strTran = "fade2";

tRGBColor rgb;

sscanf(parameter,"#%2X%2X%2X",&rgb.r,&rgb.g,&rgb.b);

//CUtil::PWMControl(strRgbA,strRgbB,strWhiteA,strWhiteB,strTran, iTrTime);

g_iledSmartxxrgb.SetRGBState(rgb);

else

CLog::Log(LOGDEBUG,"System.PWMControl(): Invalid parameters - use: System.PWMControl(#rgb1,#rgb2,#white1,#white2,mode,time)");

#include "AdvancedSettings.h"

isPaused = false;

AmbiLightParams.AmbiLightIsPlaying=false;

//SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_LOWEST);

SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_HIGHEST);

if(!isPaused)

{

dwFrameTime = timeGetTime() - dwLastTime;

if( (s_RGBs.strTransition.IsEmpty() || s_RGBs.strTransition.Equals("none")) && !strLastTransition.Equals("none") )

{

SetRGBLed(s_CurRGB.red,s_CurRGB.green,s_CurRGB.blue, s_CurRGB.white);

}

else if(s_RGBs.strTransition.Equals("switch") && !strLastTransition.Equals("switch"))

{

if(dwFrameTime >= s_RGBs.iTime )

{

s_CurRGB.red = s_RGBs.red2;

s_CurRGB.green = s_RGBs.green2;

s_CurRGB.blue = s_RGBs.blue2;

s_CurRGB.white = s_RGBs.white2;

SetRGBLed(s_CurRGB.red,s_CurRGB.green,s_CurRGB.blue,s_CurRGB.white);

}

else

{

s_CurRGB.red = s_RGBs.red1;

s_CurRGB.green = s_RGBs.green1;

s_CurRGB.blue = s_RGBs.blue1;

s_CurRGB.white = s_RGBs.white1;

SetRGBLed(s_CurRGB.red,s_CurRGB.green,s_CurRGB.blue,s_CurRGB.white);

}

}

else if(s_RGBs.strTransition.Equals("blink"))

{

strLastTransition = "blink";

if(dwFrameTime >= s_RGBs.iTime )

{

s_CurRGB.red = (s_CurRGB.red != s_RGBs.red1) ? s_RGBs.red1 : s_RGBs.red2;

s_CurRGB.green = (s_CurRGB.green != s_RGBs.green1) ? s_RGBs.green1 : s_RGBs.green2;

s_CurRGB.blue = (s_CurRGB.blue != s_RGBs.blue1) ? s_RGBs.blue1 : s_RGBs.blue2;

s_CurRGB.white= (s_CurRGB.white != s_RGBs.white1) ? s_RGBs.white1 : s_RGBs.white2;

dwLastTime = timeGetTime();

SetRGBLed(s_CurRGB.red,s_CurRGB.green,s_CurRGB.blue,s_CurRGB.white);

}

}

else if(s_RGBs.strTransition.Equals("fade") || s_RGBs.strTransition.Equals("fadeloop") || s_RGBs.strTransition.Equals("faderepeat"))

{

static double distanceR,distanceG,distanceB,distanceW;

if(!strLastTransition.Equals("fade"))

{

distanceR = bRepeat ? s_RGBs.red1-s_RGBs.red2 : s_RGBs.red2-s_RGBs.red1;

distanceG = bRepeat ? s_RGBs.green1-s_RGBs.green2 : s_RGBs.green2-s_RGBs.green1;

distanceB = bRepeat ? s_RGBs.blue1-s_RGBs.blue2 : s_RGBs.blue2-s_RGBs.blue1;

distanceW = bRepeat ? s_RGBs.white1-s_RGBs.white2 : s_RGBs.white2-s_RGBs.white1;

strLastTransition = "fade";

if(s_RGBs.strTransition.Equals("faderepeat"))bRepeat=!bRepeat;

}

if(dwFrameTime <= s_RGBs.iTime )

{

double stepR=distanceR/s_RGBs.iTime*dwFrameTime;

double stepG=distanceG/s_RGBs.iTime*dwFrameTime;

double stepB=distanceB/s_RGBs.iTime*dwFrameTime;

double stepW=distanceW/s_RGBs.iTime*dwFrameTime;

s_CurRGB.red=(bRepeat ? s_RGBs.red1 : s_RGBs.red2) +(int)stepR;

s_CurRGB.green=(bRepeat ? s_RGBs.green1 : s_RGBs.green2)+(int)stepG;

s_CurRGB.blue=(bRepeat ? s_RGBs.blue1 : s_RGBs.blue2)+(int)stepB;

s_CurRGB.white=(bRepeat ? s_RGBs.white1 : s_RGBs.white2)+(int)stepW;

SetRGBLed(s_CurRGB.red,s_CurRGB.green,s_CurRGB.blue,s_CurRGB.white);

}

else if(s_RGBs.strTransition.Equals("fadeloop") || s_RGBs.strTransition.Equals("faderepeat"))

{

strLastTransition="none";

dwLastTime = timeGetTime();

}

}

else if(s_RGBs.strTransition.Equals("fade2"))

static int distanceR,distanceG,distanceB,distanceW;

static int maxDiffR,maxDiffG,maxDiffB;

if(!strLastTransition.Equals("fade2"))

{

strLastTransition = "fade2";

dwFrameTime = 0;

dwLastTime = timeGetTime();

s_RGBs.red1 =s_CurRGB.red;

s_RGBs.green1 =s_CurRGB.green;

s_RGBs.blue1 =s_CurRGB.blue ;

distanceR = s_RGBs.red2-s_RGBs.red1;

distanceG = s_RGBs.green2-s_RGBs.green1;

distanceB = s_RGBs.blue2-s_RGBs.blue1;

distanceW = s_RGBs.white2-s_RGBs.white1;

int max=abs(MAX(distanceR,distanceG,distanceB));

//max one second transition time

s_RGBs.iTime = int((max/255.0f)*FADE2_MAX_TIME);

}

if(dwFrameTime <= s_RGBs.iTime && (s_CurRGB.red!=s_RGBs.red2 || s_CurRGB.blue!=s_RGBs.blue2 || s_CurRGB.green!=s_RGBs.green2))

{

// how far do we need to be according to current time...

int stepR=(int)((double)distanceR/s_RGBs.iTime*dwFrameTime);

int stepG=(int)((double)distanceG/s_RGBs.iTime*dwFrameTime);

int stepB=(int)((double)distanceB/s_RGBs.iTime*dwFrameTime);

int stepW=(int)((double)distanceW/s_RGBs.iTime*dwFrameTime);

s_CurRGB.red=s_RGBs.red1+stepR;

s_CurRGB.green=s_RGBs.green1+stepG;

s_CurRGB.blue=s_RGBs.blue1+stepB;

s_CurRGB.white=s_RGBs.white1+stepW;

SetRGBLed(s_CurRGB.red,s_CurRGB.green,s_CurRGB.blue,s_CurRGB.white);

}

else

{

strLastTransition = "reset";

}

}

for(int i=0;i<10;i++)

Sleep(1);

}

// this can also be called when navigationg in the XBMC while a movie runs in background.

// when in menu it can happen that parallel to AmbiLight PWMControl will be started. In that

// case we want AmbiLight to stay on and so the ambilight will stop the rgb-thread. To avoid

// flashing of LEDs in this case we don't turn them off.

if(!AmbiLightParams.AmbiLightIsPlaying)

{

SetRGBLed(0,0,0,0xb); //r=0,g=0,b=0 w=0xb (Status LED ON)

}

if (g_sysinfo.SmartXXModCHIP().Equals("SmartXX V3") || g_sysinfo.SmartXXModCHIP().Equals("SmartXX OPX")) // && !AmbiLightParams.AmbiLightIsPlaying && !isPaused)

void ILEDSmartxxRGB::Pause()

{

//isPaused=true;

}

void ILEDSmartxxRGB::Continue()

{

if(isPaused)

dwLastTime=timeGetTime();

isPaused=false;

}

bool ILEDSmartxxRGB::IsPaused()

{

return isPaused;

}

static oldR=0,oldG=0,oldB=0;

/*if(abs(oldR-red)>1)

CLog::DebugLog("RSkipAmbilight");

if(abs(oldG-green)>1)

CLog::DebugLog("GSkipAmbilight");

if(abs(oldB-blue)>1)

CLog::DebugLog("BSkipAmbilight");*/

oldR=red;

oldG=green;

oldB=blue;

red=CLAMP(red/2,0,127);

green=CLAMP(green/2,0,127);

blue=CLAMP(blue/2,0,127);

bool ILEDSmartxxRGB::SetRGBState(tRGBColor rgb)

{

// we have a new request: start reset

strCurrentStatus = "NULL";

strLastStatus = "NULL";

strLastTransition = "NULL";

s_RGBs.strTransition = "NULL";

// is used to identify first frame in blink-mode, 0 is not usable to do this check as zero is

// a valid value for a color

s_RGBs.strTransition = "fade2";

s_RGBs.red2 =rgb.r;

s_RGBs.green2 =rgb.g;

s_RGBs.blue2 =rgb.b;

/*s_RGBs.red1 =s_CurRGB.red;

s_RGBs.green1 =s_CurRGB.green;

s_RGBs.blue1 =s_CurRGB.blue ;*/

//dwFrameTime = 0;

//dwLastTime = timeGetTime();

bRepeat = false;

// end reset

SetRGBStatus(s_RGBs.strTransition);

if(!IsRunning())

Start();

return true;

}

void ILEDSmartxxRGB::AmbiLightUpdateFrameNumber()

{

// only do this, if ambilight is enabled...

if(g_advancedSettings.m_ambiLight && AmbiLightParams.AmbiLightIsPlaying)

{

AmbiLightParams.recentFrame=(AmbiLightParams.recentFrame+1) % g_advancedSettings.m_ambiLightFloatingAverageFrames;

AmbiLightParams.frameHasChanged=true;

}

}

void ILEDSmartxxRGB::AmbiLightSetAverageColor(unsigned int H,unsigned int S,unsigned int V)

{

// this function is called after we've gotten the average color of the recent frame. It then shifts

// the array containing the values of our FloatingAverageArray (if enabled) to push out the oldest value and

// insert these new values at the beginning (FIFO).

// first copy AmbiLightParams to local var for better handling...

AMBILIGHT &params=AmbiLightParams;

// also copy our FloatingAverageFrames-var to local var...

unsigned int FloatingAverageFrames=g_advancedSettings.m_ambiLightFloatingAverageFrames;

// when mode is linear, then the oldest frame in our floating average counts once, the frame after that counts twice,

// the frame after that thrice and so on...

/*if(g_advancedSettings.m_ambiLightMode=="linear")

{

// in this case the sums have to be recalculated from zero...

params.sumR=0;

params.sumG=0;

params.sumB=0;

// recalculate RGB arrays, starting with the now oldest frame...

// if we have a framenumber of 5 at the moment and FloatingAverageFrames of 10

// then the first index is 5 which is the 6th field in the array, which takes now

// the oldest value...

for(unsigned int i=1;i<FloatingAverageFrames;i++)

{

unsigned int index=(i+params.recentFrame) % (FloatingAverageFrames);

// divide by its old weight, then multiply with its new weight which just became decreased by one...

params.arrR[index]=(params.arrR[index]/(i+1))*i;

params.arrG[index]=(params.arrG[index]/(i+1))*i;

params.arrB[index]=(params.arrB[index]/(i+1))*i;

// also update the sums...

params.sumR+=params.arrR[index];

params.sumG+=params.arrG[index];

params.sumB+=params.arrB[index];

}

// at last we update the array-field that takes the values of the recent frame times the FloatingAverageFrames

// (because the recent frame has the heighest weight which is FloatingAverageFrames)...

params.arrR[params.recentFrame]=R*(FloatingAverageFrames);

params.arrG[params.recentFrame]=G*(FloatingAverageFrames);

params.arrB[params.recentFrame]=B*(FloatingAverageFrames);

// a last update to our sums...

params.sumR+=params.arrR[params.recentFrame];

params.sumG+=params.arrG[params.recentFrame];

params.sumB+=params.arrB[params.recentFrame];

}

else*/

{

// if we donot calc linear, each frame of our floatingAverageFrames has the same weight, so calculation is easy...

// the sum gets substracted the old value and added the new value...

//params.sumH+=H-params.arrH[params.recentFrame];

//params.sumS+=S-params.arrS[params.recentFrame];

//params.sumV+=V-params.arrV[params.recentFrame];

//// the corresponding array-value gets overwritten...

//params.arrH[params.recentFrame]=H;

//params.arrS[params.recentFrame]=S;

//params.arrV[params.recentFrame]=V;

}

}

void ILEDSmartxxRGB::AmbiLightStop()

{

if(g_advancedSettings.m_ambiLight)

{

CLog::Log(LOGDEBUG,"AmbiLight is stopping...");

AmbiLightParams.AmbiLightIsPlaying=false;

OnExit();

Continue();

}

}

void ILEDSmartxxRGB::AmbiLightRGBSet()

{

AMBILIGHT &params=AmbiLightParams;

//necessary vars...

tHSVColor hsv;

tRGBColor rgb;

tHSVHistogramm hsvHisto;

// Initialize hsv-Color...

hsv.h=0;

hsv.s=0;

hsv.v=0;

// emptying the temporary histogram...

for(int i=0;i<=360;i++)

hsvHisto.h[i]=0;

for(int i=0;i<=100;i++) {

hsvHisto.s[i]=0;

hsvHisto.v[i]=0; }

//create the histogramm of the hue-channel...

for(int i=0;i<(int)params.PixelCount;i++)

hsvHisto.h[params.hsvMatrix[i].h]++;

int sumH=0,oldSumH=0;

//now find the window, with the most hue...

for(int i=0;i<HUE_WINDOW;i++)

sumH+=hsvHisto.h[i];

for(int i=0;i<=360-HUE_WINDOW;i++)

{

sumH=sumH-hsvHisto.h[i]+hsvHisto.h[i+HUE_WINDOW];

if(sumH>oldSumH)

{

oldSumH=sumH;

hsv.h=i+1;

}

}

//now find the max inside our window...

int maxH=hsv.h;

for(int i=hsv.h+1;i<hsv.h+HUE_WINDOW;i++)

maxH = hsvHisto.h[i]>hsvHisto.h[maxH]?i:maxH;

hsv.h=maxH;

//window limits for saturation histogram...

int iMin=CLAMP(hsv.h-WINDOW_SIZE,0,360);

int iMax=CLAMP(hsv.h+WINDOW_SIZE,0,360);

//now we count all pixels around the

int relevantPixelCount=0;

for(int i=iMin;i<=iMax;i++)

relevantPixelCount+=hsvHisto.h[i];

// nur wenn die Anzahl der f?r das Maximum relevanten Pixel eine Fl?che einnimmt die gr??er als die Vorgegebene

// Minimalgr??e ist wird die Saturation und der Value berechnet (ohne die bleibt die Farbe schwarz)...

if(relevantPixelCount*(g_advancedSettings.m_ambiLightSpaceBetweenPixels+1)>=params.SourceWidth*params.SourceHeight*MIN_PERCENTAGE)

{

//Saturation Histogramm

for(int i=0;i<(int)params.PixelCount;i++)

{

if(params.hsvMatrix[i].h>=iMin && params.hsvMatrix[i].h<=iMax)

hsvHisto.s[params.hsvMatrix[i].s]++;

}

//Max Saturation

for(int i=0;i<=100;i++)

hsv.s=hsvHisto.s[i]>hsvHisto.s[hsv.s] ? i : hsv.s;

//Value Average

int sumV=0;

for(int i=0;i<(int)params.PixelCount;i++)

sumV+=params.hsvMatrix[i].v;

if(params.PixelCount>0)

hsv.v=sumV/params.PixelCount;

}

rgb=HSV2RGB(hsv);

// now we take the power of gamma for each RGB-value and use our scale-factor to form an valid RGB-value...

// this gamma factor is an simple way to control how fast a LED turns bright especially in lower values. if in dark

// passages you always have blue light try an gamme value below 1 so blue will have a lower gamma curve. On the other

// hand you could pass Red and green a gamma above 1, common value would be e.g. gammaR=2.2, gammeG=2.0, gammaB=0.8

// (as blue often seems to be the brightest LED).

rgb.r=(int)(pow((float)rgb.r,params.gammaR)*params.gammaScaleR);

rgb.g=(int)(pow((float)rgb.g,params.gammaG)*params.gammaScaleG);

rgb.b=(int)(pow((float)rgb.b,params.gammaB)*params.gammaScaleB);

rgb.r=CLAMP(rgb.r,g_advancedSettings.m_ambiLightMinRGB,g_advancedSettings.m_ambiLightMaxRGB);

rgb.g=CLAMP(rgb.g,g_advancedSettings.m_ambiLightMinRGB,g_advancedSettings.m_ambiLightMaxRGB);

rgb.b=CLAMP(rgb.b,g_advancedSettings.m_ambiLightMinRGB,g_advancedSettings.m_ambiLightMaxRGB);

// our values get passed to the SmartXX...

SetRGBState(rgb);

//SetRGBLed(rgb.r,rgb.g,rgb.b,0);

}

void ILEDSmartxxRGB::AmbiLightParamsInit(unsigned int SourceWidth,unsigned int SourceHeight,YUVCOEF yuvcoef,YUVRANGE yuvrange)

{

AMBILIGHT &params=AmbiLightParams;

if(g_advancedSettings.m_ambiLight==true)

{

CLog::DebugLog ("Params x %i w %i",params.x,params.w);

CLog::Log(LOGDEBUG,"AmbiLight is initializing...");

s_CurRGB.red=2;

s_CurRGB.green=2;

s_CurRGB.blue=2;

params.AmbiLightIsPlaying=true;

// here we initialize our Params, it's always called, when a new movie starts...

params.frameHasChanged = false;

params.recentFrame = 0;

params.SourceWidth=SourceWidth;

params.SourceHeight=SourceHeight;

params.yuvcoef=yuvcoef;

params.yuvrange=yuvrange;

params.PixelCount=0;

params.RowCount=0;

params.PixelOverflow=0;

params.R=0;

params.G=0;

params.B=0;

params.hsvMatrix=new tHSVColor[92161];

//memset(&params.hsvMatrix,0,sizeof(params.hsvMatrix)*92161);

if(params.arrH==NULL)

{

params.hsvh=new tHSVHistogramm[g_advancedSettings.m_ambiLightFloatingAverageFrames];

params.arrH=new unsigned int[g_advancedSettings.m_ambiLightFloatingAverageFrames];

params.arrS=new unsigned int[g_advancedSettings.m_ambiLightFloatingAverageFrames];

params.arrV=new unsigned int[g_advancedSettings.m_ambiLightFloatingAverageFrames];

}

//initialize Array...

for(int i=0;i<g_advancedSettings.m_ambiLightFloatingAverageFrames;i++)

{

for(int j=0;j<=360;j++)

params.hsvh[i].h[j]=0;

for(int j=0;j<=100;j++)

{

params.hsvh[i].s[j]=0;

params.hsvh[i].v[j]=0;

}

params.arrH[i]=0; //g_advancedSettings.m_ambiLightMinRGB;

params.arrS[i]=0; //g_advancedSettings.m_ambiLightMinRGB;

params.arrV[i]=0; //g_advancedSettings.m_ambiLightMinRGB;

}

/*params.sumH=0;

params.sumS=0;

params.sumV=0;*/

params.gammaR=1/g_advancedSettings.m_ambiLightGammaR;

params.gammaG=1/g_advancedSettings.m_ambiLightGammaG;

params.gammaB=1/g_advancedSettings.m_ambiLightGammaB;

params.gammaScaleR=255/pow(255.0f,params.gammaR);

params.gammaScaleG=255/pow(255.0f,params.gammaG);

params.gammaScaleB=255/pow(255.0f,params.gammaB);

}

}

void ILEDSmartxxRGB::AmbiLightUpdate()

{

AMBILIGHT &params=AmbiLightParams;

// when the frame has changed...

if(params.frameHasChanged)

{

// and we have checked more than 0 pixels...

//if(params.PixelCount>0)

{

//static unsigned int oldR=0,oldG=0,oldB=0;

// then we calculate the average of the last frame...

//unsigned int R=(unsigned int)(params.R/params.PixelCount);

//unsigned int G=(unsigned int)(params.G/params.PixelCount);

//unsigned int B=(unsigned int)(params.B/params.PixelCount);

// check, whether we have a skip (e.g. a new scene or st.)

//AmbiLightCheckSkip(oldR,oldG,oldB,R,G,B);

//oldR=R;oldG=G;oldB=B;

// pass it to SetAverageColor...

//AmbiLightSetAverageColor(R,G,B);

// and push it onto the SmartXX...

AmbiLightRGBSet();

}

// then the RGB-values get zeroed for a fresh start in this new frame...

params.R=0;

params.G=0;

params.B=0;

//memset(&params.hsvMatrix,0,sizeof(params.hsvMatrix)*92161);

// the counter is reset...

params.PixelCount=0;

// a new startposition for Pixeloverflow is calculated...

//params.PixelOverflow=g_advancedSettings.m_ambiLightSpaceBetweenPixels*params.recentFrame;

// and FrameChange Property...

params.frameHasChanged = false;

// and RowCount is reset...

params.RowCount=0;

}

}

void ILEDSmartxxRGB::AmbiLightCheckSkip(unsigned int oldR,unsigned int oldG,unsigned int oldB,unsigned int newR,unsigned int newG,unsigned int newB)

{

/*AMBILIGHT &params=AmbiLightParams;

int skipR=oldR-newR;

int skipG=oldG-newG;

int skipB=oldB-newB;

if(skipR<0) skipR*=-1;

if(skipG<0) skipG*=-1;

if(skipB<0) skipB*=-1;

if((skipR+skipG+skipB)>g_advancedSettings.m_ambiLightFilterThreshold*3)

{

for(int i=0;i<g_advancedSettings.m_ambiLightFloatingAverageFrames;i++)

{

params.arrR[i]=newR;

params.arrG[i]=newG;

params.arrB[i]=newB;

}

params.sumR=newR*g_advancedSettings.m_ambiLightFloatingAverageFrames;

params.sumG=newG*g_advancedSettings.m_ambiLightFloatingAverageFrames;

params.sumB=newB*g_advancedSettings.m_ambiLightFloatingAverageFrames;

}*/

}

void ILEDSmartxxRGB::AmbiLightParamsUpdate(int x,int w,int widthRatio)

{

// set values

AmbiLightParams.x = x;

AmbiLightParams.w = w;

AmbiLightParams.WidthRatio = widthRatio;

//CLog::DebugLog("sWidth %i sHeight %i",AmbiLightParams.SourceWidth,AmbiLightParams.SourceHeight);

}

void ILEDSmartxxRGB::AmbiLightRGBCalculate(BYTE *s0,BYTE *s1,BYTE *s2)

{

// copy our ambilight params for easier handling...

AMBILIGHT &params=AmbiLightParams;

CStdString position=g_advancedSettings.m_ambiLightPosition.ToLower();

// here we make sure, we're in the right row of pixels. If we only want to interpret the bottom half,

// but are in the first pixel row, do nothing...

if((position=="top" && params.RowCount<params.SourceHeight/2) || (position=="bottom" && params.RowCount>=params.SourceHeight/2) || position=="left" || position=="right" || position=="all")

{

// these vars take the x-value from where to start getting pixels and the width. e.g. if you only want to interpret

// the left area of the screen, then StartX equals zero and EndX equals StartX+resolutionwidth/2

// these are always recalulated as x and w might change during different YUV-chunks...

unsigned int StartX;

unsigned int EndX;

// here we set StartX and EndW for different modes...

if(position=="left")

{

StartX=params.x;

EndX=StartX+params.w/2;

}

else if(position=="right")

{

StartX=params.x+params.SourceWidth/2;

EndX=StartX+params.w/2;

}

else

{

StartX=params.x;

EndX=StartX+params.w;

}

// now we go on the first pixel in a line is always Startx+PixelOverflow. PixelOverflow is calculated like this:

// when you have a resolution width of 1280px and SpaceBetweenPixels is 499 (means each 500th pixel in a row is

// interpreted) then the first Pixel taken is StartX+PixelCount which euals normally 0, then we add SpaceBetweenPixels+1

// so our next Pixel in this row is number 500 (between 0 and 500 there's 499px). the next one is, as you guessed

// 1000 and the next one should be 1500 but, as our resolution width is only 1280, here's the overflow

// (also you have to take notice of FloatingAverageFrames which decreases SpaceBetweenPixels, so if we have

// FloatingAverageFrames of 10 then in each Frame we would interpret only each 500*10=5000th pixel)

for(unsigned int i=10;i<EndX;i+=g_advancedSettings.m_ambiLightSpaceBetweenPixels*g_advancedSettings.m_ambiLightFloatingAverageFrames)

//StartX+params.PixelOverflow

{

// i2 is the index for the YUV U+V planes. these are usually half the size of the Y-plane, so usually WidthRatio

// should be 2.

unsigned int i2=(unsigned int)(i/params.WidthRatio);

// now we convert the YUV pixel to RGB...

tRGBColor rgb=AmbiLightYUV2RGB(s0[i],s1[i2],s2[i2]);

// and rgb to hsv...

tHSVColor hsv=RGB2HSV(rgb);

// and add the found RGB-vals to the according params-field...

if(hsv.v>=g_advancedSettings.m_ambiLightDarknessLimit)

{

params.hsvMatrix[params.PixelCount]=hsv;

// this counter is necessary, so we know, how many pixels we've counted in this frame...

params.PixelCount++;

}

}

// now our OverFlow-Parameter gets set as described above...

params.PixelOverflow=params.PixelOverflow % g_advancedSettings.m_ambiLightSpaceBetweenPixels*g_advancedSettings.m_ambiLightFloatingAverageFrames;

}

// and the RowCounter gets increased, it's necessary for us to know where we are when mode is top or bottom...

params.RowCount++;

}

tRGBColor ILEDSmartxxRGB::AmbiLightYUV2RGB(BYTE y, BYTE u, BYTE v)

{

YUVCOEF &coef = AmbiLightParams.yuvcoef;

YUVRANGE &range = AmbiLightParams.yuvrange;

// normalize

float Yp = (y - range.y_min) * 255.0f / (range.y_max - range.y_min);

float Up = (u - range.u_min) * 255.0f / (range.u_max - range.u_min) - 127.5f;

float Vp = (v - range.v_min) * 255.0f / (range.v_max - range.v_min) - 127.5f;

// recalculate

tRGBColor rgb;

rgb.r = (int)(Yp + coef.r_up * Up + coef.r_vp * Vp);

rgb.g = (int)(Yp + coef.g_up * Up + coef.g_vp * Vp);

rgb.b = (int)(Yp + coef.b_up * Up + coef.b_vp * Vp);

// clamp

rgb.r = CLAMP(rgb.r, 0, 255);

rgb.g = CLAMP(rgb.g, 0, 255);

rgb.b = CLAMP(rgb.b, 0, 255);

return rgb;

}

tHSVColor ILEDSmartxxRGB::RGB2HSV(tRGBColor rgb)

{

float min,max,delta;

float h,s,v;

float r,g,b;

//skalieren der RGB-Werte auf das Intervall [0;1]

r=(float)rgb.r/255.0f;

g=(float)rgb.g/255.0f;

b=(float)rgb.b/255.0f;

min=MIN(r,g,b);

max=MAX(r,g,b);

v=max; // v

delta=max-min;

if(max!=0)

{

s=delta/max; // s

if(r==g && g==b)

h=0;

else if(r==max) // h

h=(g-b)/delta;

else if(g==max)

h=2+(b-r)/delta;

else

h=4+(r-g)/delta;

h*=60.0f;

if(h<0.0f)

h+=360.0f;

}

else

{

// r = g = b = 0 // s = 0, v is undefined

s=0.0f;

h=0.0f;

}

//skalieren: h=[0;360]; s,v=[0;100]

tHSVColor hsv;

hsv.h=(int)h;

hsv.s=(int)(s*100);

hsv.v=(int)(v*100);

return hsv;

}

tRGBColor ILEDSmartxxRGB::HSV2RGB(tHSVColor hsv)

{

int i;

float f,p,q,t;

float h,s,v;

float r,g,b;

h=(float)hsv.h;

s=(float)hsv.s/100.0f;

v=(float)hsv.v/100.0f;

if(s==0)

{

r=g=b=v;

}

else

{

h/=60;

i=(int)h;

f=h-i;

p=v*(1-s);

q=v*(1-s*f);

t=v*(1-s*(1-f));

switch(i)

{

case 0:

case 6:

r=v;

g=t;

b=p;

break;

case 1:

r=q;

g=v;

b=p;

break;

case 2:

r=p;

g=v;

b=t;

break;

case 3:

r=p;

g=q;

b=v;

break;

case 4:

r=t;

g=p;

b=v;

break;

default:

r=v;

g=p;

b=q;

break;

}

}

tRGBColor rgb;

rgb.r=(int)(r*255);

rgb.g=(int)(g*255);

rgb.b=(int)(b*255);

return rgb;

}

#include "cores/VideoRenderers/XBoxRenderer.h"

#define MAX(a, b, c) (((a) > (b) && (a) > (c)) ? (a) : ((b) > (c) ? (b) : (c)))

#define MIN(a, b, c) (((a) < (b) && (a) < (c)) ? (a) : ((b) < (c) ? (b) : (c)))

#define FRAMES 10

// Ambilight consts

#define WINDOW_SIZE 5

#define HUE_WINDOW 5

#define MIN_PERCENTAGE 0.01

#define FADE2_MAX_TIME 1000

// --- tRGBColor --------------------------------------------------------------

typedef struct {

int r, g, b;

} tRGBColor;

// --- tHSVColor --------------------------------------------------------------

typedef struct {

int h, s, v;

} tHSVColor;

// --- tHSVHistogram ----------------------------------------------------------

typedef struct {

int h[361];

int s[101];

int v[101];

} tHSVHistogramm;

struct AMBILIGHT {

bool frameHasChanged;

bool AmbiLightIsPlaying;

unsigned int SourceWidth;

unsigned int SourceHeight;

unsigned int RowCount;

unsigned int PixelCount;

unsigned int PixelOverflow;

int WidthRatio;

int x;

int w;

unsigned int R;

unsigned int G;

unsigned int B;

unsigned int *arrH;

unsigned int *arrS;

unsigned int *arrV;

// new calculation

tHSVHistogramm *hsvh;

tHSVColor *hsvMatrix;

// end new calculation

YUVCOEF yuvcoef;

YUVRANGE yuvrange;

unsigned int recentFrame;

float gammaR;

float gammaG;

float gammaB;

float gammaScaleR;

float gammaScaleG;

float gammaScaleB; };

bool isPaused;

AMBILIGHT AmbiLightParams;

void AmbiLightSetAverageColor(unsigned int R,unsigned int B,unsigned int G);

void AmbiLightRGBSet();

tRGBColor AmbiLightYUV2RGB(BYTE y, BYTE u, BYTE v);

void AmbiLightCheckSkip(unsigned int oldR,unsigned int oldG,unsigned int oldB,unsigned int newR,unsigned int newG,unsigned int newB);

tHSVColor RGB2HSV(tRGBColor rgb);

tRGBColor HSV2RGB(tHSVColor color);

virtual void Pause();

virtual void Continue();

virtual bool IsPaused();

bool SetRGBState(tRGBColor rgb);

void AmbiLightUpdateFrameNumber();

void AmbiLightRGBCalculate(BYTE *s0,BYTE *s1,BYTE *s2);

void AmbiLightParamsInit(unsigned int SourceWidth,unsigned int SourceHeight,YUVCOEF yuvcoef,YUVRANGE yuvrange);

void AmbiLightParamsUpdate(int x,int w,int widthRatio);

void AmbiLightUpdate();

void AmbiLightStop();