XBMC4Xbox

<onright>96</onright>

<onup>9</onup>

<ondown>5</ondown>

<texturefocus>home-focus.gif</texturefocus>

<texturenofocus>-</texturenofocus>

<textoffsetx>30</textoffsetx>

<onright>96</onright>

<onup>2</onup>

<ondown>3</ondown>

<texturefocus>home-focus.gif</texturefocus>

<texturenofocus>-</texturenofocus>

<textoffsetx>30</textoffsetx>

<onright>96</onright>

<onup>5</onup>

<ondown>4</ondown>

<texturefocus>home-focus.gif</texturefocus>

<texturenofocus>-</texturenofocus>

<textoffsetx>30</textoffsetx>

<onright>96</onright>

<onup>3</onup>

<ondown>7</ondown>

<texturefocus>home-focus.gif</texturefocus>

<texturenofocus>-</texturenofocus>

<textoffsetx>30</textoffsetx>

<onright>96</onright>

<onup>4</onup>

<ondown>9</ondown>

<texturefocus>home-focus.gif</texturefocus>

<texturenofocus>-</texturenofocus>

<textoffsetx>30</textoffsetx>

<onright>6</onright>

<onup>10</onup>

<ondown>5</ondown>

<texturefocus>home-focus.gif</texturefocus>

<texturenofocus>-</texturenofocus>

<textoffsetx>20</textoffsetx>

<onright>96</onright>

<onup>10</onup>

<ondown>5</ondown>

<texturefocus>home-focus.gif</texturefocus>

<texturenofocus>-</texturenofocus>

<textoffsetx>20</textoffsetx>

m_bAutoFatxLimit = true;

m_bgInfoLoaderMaxThreads = 1;

}

bool CAdvancedSettings::Load()

XMLUtils::GetBoolean(pElement, "verbose", m_bPythonVerbose);

}

XMLUtils::GetBoolean(pRootElement, "autofatxlimit", m_bAutoFatxLimit);

XMLUtils::GetString(pRootElement, "cddbaddress", m_cddbAddress);

class CAdvancedSettings

{

};

extern CAdvancedSettings g_advancedSettings;

}

UpdateLCD();

// read raw input from controller, remote control, mouse and keyboard

ReadInput();

* http://www.gnu.org/copyleft/gpl.html

*

*/

#include "stdafx.h"

#include "AdvancedSettings.h"

#include "GUISettings.h"

#include "DVDCodecs/Overlay/DVDOverlaySSA.h"

#include <sstream>

#include <iomanip>

using namespace std;

CDVDPlayerVideo::CDVDPlayerVideo( CDVDClock* pClock

{

m_pClock = pClock;

m_pOverlayContainer = pOverlayContainer;

{

StopThread();

g_dvdPerformanceCounter.DisableVideoQueue();

#ifdef HAS_VIDEO_PLAYBACK

if(m_output.inited)

{

double CDVDPlayerVideo::GetOutputDelay()

{

}

bool CDVDPlayerVideo::OpenStream( CDVDStreamInfo &hint )

{

CThread::SetName("CDVDPlayerVideo");

m_iDroppedFrames = 0;

m_iCurrentPts = DVD_NOPTS_VALUE;

m_FlipTimeStamp = m_pClock->GetAbsoluteClock();

bRequestDrop = false;

#else

if (m_messageQueue.GetDataSize() == 0

{

bRequestDrop = false;

m_iDroppedRequest = 0;

memset(&picture, 0, sizeof(DVDVideoPicture));

if (m_pVideoCodec->GetPicture(&picture))

{

sPostProcessType.clear();

picture.iGroupId = pPacket->iGroupId;

m_pOverlayCodecCC = NULL;

}

CLog::Log(LOGNOTICE, "thread end: video_thread");

}

bool bHasSpecialOverlay = m_pOverlayContainer->ContainsOverlayType(DVDOVERLAY_TYPE_SPU)

|| m_pOverlayContainer->ContainsOverlayType(DVDOVERLAY_TYPE_IMAGE)

|| m_pOverlayContainer->ContainsOverlayType(DVDOVERLAY_TYPE_SSA);

if (bHasSpecialOverlay)

{

if (m_pTempOverlayPicture && (m_pTempOverlayPicture->iWidth != pSource->iWidth || m_pTempOverlayPicture->iHeight != pSource->iHeight))

CDVDCodecUtils::FreePicture(m_pTempOverlayPicture);

m_pTempOverlayPicture = NULL;

}

if (!m_pTempOverlayPicture) m_pTempOverlayPicture = CDVDCodecUtils::AllocatePicture(pSource->iWidth, pSource->iHeight);

}

CDVDCodecUtils::CopyPicture(m_pTempOverlayPicture, pSource);

else

CDVDCodecUtils::CopyPicture(pDest, pSource);

m_pOverlayContainer->Lock();

VecOverlays* pVecOverlays = m_pOverlayContainer->GetOverlays();

}

m_pOverlayContainer->Unlock();

if (bHasSpecialOverlay && m_pTempOverlayPicture)

CDVDCodecUtils::CopyPicture(pDest, m_pTempOverlayPicture);

}

#ifdef HAS_VIDEO_PLAYBACK

/* check so that our format or aspect has changed. if it has, reconfigure renderer */

if (!g_renderManager.IsConfigured()

{

CLog::Log(LOGNOTICE, " fps: %f, pwidth: %i, pheight: %i, dwidth: %i, dheight: %i",

m_fFrameRate, pPicture->iWidth, pPicture->iHeight, pPicture->iDisplayWidth, pPicture->iDisplayHeight);

switch(pPicture->color_matrix)

{

}

if(m_bAllowFullscreen)

// calculate the time we need to delay this picture before displaying

double iSleepTime, iClockSleep, iFrameSleep, iCurrentClock, iFrameDuration;

iCurrentClock = m_pClock->GetAbsoluteClock(); // snapshot current clock

iClockSleep = pts - m_pClock->GetClock(); //sleep calculated by pts to clock comparison

iFrameSleep = m_FlipTimeStamp - iCurrentClock; // sleep calculated by duration of frame

if( m_speed < 0 )

{

if( iClockSleep < -DVD_MSEC_TO_TIME(200)

return result | EOS_DROPPED;

}

// video device might not be done yet

while (index < 0 && !CThread::m_bStop &&

{

Sleep(1);

index = g_renderManager.GetImage(&image);

#include "Application.h"

#include "XBVideoConfig.h"

#include "Settings.h"

// http://www.martinreddy.net/gfx/faqs/colorconv.faq

xscale = 1.0f;

yscale = 1.0f;

}

// horizontal centering, and align to bottom of subtitles line

osdRect.left = (float)rv.left + (float)(rv.right - rv.left - (float)w * xscale) / 2.0f;

osdRect.right = osdRect.left + (float)w * xscale;

if (

D3D_OK != m_pD3DDevice->CreateTexture(m_iOSDTextureWidth, m_iOSDTextureHeight[iOSDBuffer], 1, 0, D3DFMT_LIN_L8, 0, &m_pOSDYTexture[iOSDBuffer]) ||

D3D_OK != m_pD3DDevice->CreateTexture(m_iOSDTextureWidth, m_iOSDTextureHeight[iOSDBuffer], 1, 0, D3DFMT_LIN_A8, 0, &m_pOSDATexture[iOSDBuffer])

{

CLog::Log(LOGERROR, "Could not create OSD/Sub textures");

DeleteOSDTextures(iOSDBuffer);

if (

(D3D_OK == m_pOSDYTexture[iOSDBuffer]->LockRect(0, &lr, &rc, 0)) &&

(D3D_OK == m_pOSDATexture[iOSDBuffer]->LockRect(0, &lra, &rc, 0))

{

//clear the textures

memset(lr.pBits, 0, lr.Pitch*m_iOSDTextureHeight[iOSDBuffer]);

//m_pD3DDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_INVSRCALPHA );

//m_pD3DDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCALPHA );

//m_pD3DDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE );

//m_pD3DDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCALPHA );

}

DeleteYV12Texture(i);

}

if(m_iYV12RenderBuffer > i)

m_NumYV12Buffers = i+1;

}

}

// If the TV has no HD support widescreen mode is chossen according to video AR

if (g_videoConfig.Has1080i()) // Widescreen TV with 1080i res

else if (g_videoConfig.Has720p()) // Widescreen TV with 720p res

else if (g_videoConfig.Has480p()) // Widescreen TV with 480p

{

if (bWideScreenMode) // Choose widescreen mode according to video AR

m_iResolution = HDTV_480p_16x9;

else

m_iResolution = HDTV_480p_4x3;

else if (bWideScreenMode) // Standard 16:9 TV set with no HD

m_iResolution = NTSC_16x9;

else

// We choose 16:9 resolution only for 16:9 video sources

if (m_fSourceFrameRatio >= 16.0f / 9.0f)

// The video fits best into widescreen modes so they are

// the first choices

if (g_videoConfig.Has1080i())

m_fps = fps;

m_iFlags = flags;

m_bConfigured = true;

// setup what colorspace we live in

if(flags & CONF_FLAGS_YUV_FULLRANGE)

m_yuvrange = yuv_range_full;

switch(CONF_FLAGS_YUVCOEF_MASK(flags))

{

}

// calculate the input frame aspect ratio

CalculateFrameAspectRatio(d_width, d_height);

ChooseBestResolution(m_fps);

source = NextYV12Texture();

#ifdef MP_DIRECTRENDERING

}

#endif

if( source >= 0 && m_image[source].plane[0] )

{

if( m_image[source].flags & IMAGE_FLAG_WRITING )

SetEvent(m_eventTexturesDone[source]);

m_image[source].flags &= ~IMAGE_FLAG_INUSE;

/* if image should be preserved reserve it so it's not auto seleceted */

unsigned int CXBoxRenderer::DrawSlice(unsigned char *src[], int stride[], int w, int h, int x, int y)

{

int index = NextYV12Texture();

if( index < 0 )

return -1;

CLog::Log(LOGWARNING, CStdString(__FUNCTION__) + " - Timeout waiting for texture %d", index);

YV12Image &im = m_image[index];

{

}

SetEvent(m_eventTexturesDone[index]);

DeleteYV12Texture(i);

DeleteOSDTextures(i);

}

if (m_hLowMemShader)

{

m_pD3DDevice->DeletePixelShader(m_hLowMemShader);

m_hLowMemShader = 0;

}

m_bConfigured = false;

}

void CXBoxRenderer::DeleteYV12Texture(int index)

{

CSingleLock lock(g_graphicsContext);

YV12Image &im = m_image[index];

YUVFIELDS &fields = m_YUVTexture[index];

im.plane[p] = NULL;

m_NumYV12Buffers = 0;

CLog::Log(LOGDEBUG, "Deleted YV12 texture %i", index);

}

p = 0;

stride = im.stride[p];

im.plane[p] = (BYTE*)dwTextureSize;

dwTextureSize += XGSetTextureHeader(im.width , im.height , 1, 0, D3DFMT_LIN_L8, 0, fields[0][p], dwTextureSize, stride);

/* U */

p = 1;

stride = im.stride[p];

im.plane[p] = (BYTE*)dwTextureSize;

dwTextureSize += XGSetTextureHeader(im.width>>im.cshift_x, im.height>>im.cshift_y, 1, 0, D3DFMT_LIN_L8, 0, fields[0][p], dwTextureSize, stride);

/* V */

p = 2;

stride = im.stride[p];

im.plane[p] = (BYTE*)dwTextureSize;

dwTextureSize += XGSetTextureHeader(im.width>>im.cshift_x, im.height>>im.cshift_y, 1, 0, D3DFMT_LIN_L8, 0, fields[0][p], dwTextureSize, stride);

BYTE* data = (BYTE*)XPhysicalAlloc(dwTextureSize, MAXULONG_PTR, D3DTEXTURE_ALIGNMENT, memflags);

strWhiteB= arSplit[3].c_str();

strTran = arSplit[4].c_str();

iTrTime = atoi(arSplit[5].c_str());

}

{

strRgbA = strRgbB = parameter;

strWhiteA = strWhiteB = "#000000";

}

}

else if (execute.Equals("backupsysteminfo"))

{

#include "xbox/XKUtils.h"

#include "LCD.h"

#include "GUISettings.h"

#include <conio.h>

ILEDSmartxxRGB g_iledSmartxxrgb;

void ILED::CLEDControl(int ixLED)

ILEDSmartxxRGB::ILEDSmartxxRGB()

{

s_RGBs.strTransition = "NULL";

s_CurRGB.white = 0;

dwLastTime = 0;

bRepeat = false;

}

ILEDSmartxxRGB::~ILEDSmartxxRGB()

{

if (g_sysinfo.SmartXXModCHIP().Equals("SmartXX V3") || g_sysinfo.SmartXXModCHIP().Equals("SmartXX OPX"))

{

SetRGBStatus("general");

}

}

void ILEDSmartxxRGB::Process()

{

{

s_CurRGB.red = s_RGBs.red1;

s_CurRGB.blue = s_RGBs.blue1;

s_CurRGB.white = s_RGBs.white1;

}

static double distanceR,distanceG,distanceB,distanceW;

{

}