CBaseTexture* CGUIFontTTFGL::ReallocTexture(unsigned int& newHeight)
{
newHeight = CBaseTexture::PadPow2(newHeight);
CBaseTexture* newTexture = new CTexture(m_textureWidth, newHeight, XB_FMT_A8);
if (!newTexture || newTexture->GetPixels() == NULL)
{
CLog::Log(LOGERROR, "GUIFontTTFGL::CacheCharacter: Error creating new cache texture for size %f", m_height);
return NULL;
}
m_textureHeight = newTexture->GetHeight();
m_textureWidth = newTexture->GetWidth();
memset(newTexture->GetPixels(), 0, m_textureHeight * newTexture->GetPitch());
if (m_texture)
{
unsigned char* src = (unsigned char*) m_texture->GetPixels();
unsigned char* dst = (unsigned char*) newTexture->GetPixels();
for (unsigned int y = 0; y < m_texture->GetHeight(); y++)
{
memcpy(dst, src, m_texture->GetPitch());
src += m_texture->GetPitch();
dst += newTexture->GetPitch();
}
delete m_texture;
}
return newTexture;
}
bool CPicture::CreateTiledThumb(const std::vector<std::string> &files, const std::string &thumb)
{
if (!files.size())
return false;
unsigned int num_across = (unsigned int)ceil(sqrt((float)files.size()));
unsigned int num_down = (files.size() + num_across - 1) / num_across;
unsigned int tile_width = g_advancedSettings.m_imageRes / num_across;
unsigned int tile_height = g_advancedSettings.m_imageRes / num_down;
unsigned int tile_gap = 1;
bool success = false;
// create a buffer for the resulting thumb
uint32_t *buffer = (uint32_t *)calloc(g_advancedSettings.m_imageRes * g_advancedSettings.m_imageRes, 4);
for (unsigned int i = 0; i < files.size(); ++i)
{
int x = i % num_across;
int y = i / num_across;
// load in the image
unsigned int width = tile_width - 2*tile_gap, height = tile_height - 2*tile_gap;
CBaseTexture *texture = CTexture::LoadFromFile(files[i], width, height, true);
if (texture && texture->GetWidth() && texture->GetHeight())
{
GetScale(texture->GetWidth(), texture->GetHeight(), width, height);
// scale appropriately
uint32_t *scaled = new uint32_t[width * height];
if (ScaleImage(texture->GetPixels(), texture->GetWidth(), texture->GetHeight(), texture->GetPitch(),
(uint8_t *)scaled, width, height, width * 4))
{
if (!texture->GetOrientation() || OrientateImage(scaled, width, height, texture->GetOrientation()))
{
success = true; // Flag that we at least had one successful image processed
// drop into the texture
unsigned int posX = x*tile_width + (tile_width - width)/2;
unsigned int posY = y*tile_height + (tile_height - height)/2;
uint32_t *dest = buffer + posX + posY*g_advancedSettings.m_imageRes;
uint32_t *src = scaled;
for (unsigned int y = 0; y < height; ++y)
{
memcpy(dest, src, width*4);
dest += g_advancedSettings.m_imageRes;
src += width;
}
}
}
delete[] scaled;
}
delete texture;
}
// now save to a file
if (success)
success = CreateThumbnailFromSurface((uint8_t *)buffer, g_advancedSettings.m_imageRes, g_advancedSettings.m_imageRes,
g_advancedSettings.m_imageRes * 4, thumb);
free(buffer);
return success;
}
CBaseTexture* CGUIFontTTFGL::ReallocTexture(unsigned int& newHeight)
{
newHeight = CBaseTexture::PadPow2(newHeight);
CBaseTexture* newTexture = new CTexture(m_textureWidth, newHeight, XB_FMT_A8);
if (!newTexture || newTexture->GetPixels() == NULL)
{
CLog::Log(LOGERROR, "GUIFontTTFGL::CacheCharacter: Error creating new cache texture for size %f", m_height);
delete newTexture;
return NULL;
}
m_textureHeight = newTexture->GetHeight();
m_textureScaleY = 1.0f / m_textureHeight;
m_textureWidth = newTexture->GetWidth();
m_textureScaleX = 1.0f / m_textureWidth;
if (m_textureHeight < newHeight)
CLog::Log(LOGWARNING, "%s: allocated new texture with height of %d, requested %d", __FUNCTION__, m_textureHeight, newHeight);
m_staticCache.Flush();
m_dynamicCache.Flush();
memset(newTexture->GetPixels(), 0, m_textureHeight * newTexture->GetPitch());
if (m_texture)
{
m_updateY1 = 0;
m_updateY2 = m_texture->GetHeight();
unsigned char* src = (unsigned char*) m_texture->GetPixels();
unsigned char* dst = (unsigned char*) newTexture->GetPixels();
for (unsigned int y = 0; y < m_texture->GetHeight(); y++)
{
memcpy(dst, src, m_texture->GetPitch());
src += m_texture->GetPitch();
dst += newTexture->GetPitch();
}
delete m_texture;
}
m_textureStatus = TEXTURE_REALLOCATED;
return newTexture;
}
bool CWinSystemX11::CreateNewWindow(const CStdString& name, bool fullScreen, RESOLUTION_INFO& res, PHANDLE_EVENT_FUNC userFunction)
{
RESOLUTION_INFO& desktop = g_settings.m_ResInfo[RES_DESKTOP];
if (fullScreen &&
(res.iWidth != desktop.iWidth || res.iHeight != desktop.iHeight ||
res.fRefreshRate != desktop.fRefreshRate || res.iScreen != desktop.iScreen))
{
//on the first call to SDL_SetVideoMode, SDL stores the current displaymode
//SDL restores the displaymode on SDL_QUIT(), if we change the displaymode
//before the first call to SDL_SetVideoMode, SDL changes the displaymode back
//to the wrong mode on exit
CLog::Log(LOGINFO, "CWinSystemX11::CreateNewWindow initializing to desktop resolution first");
if (!SetFullScreen(true, desktop, false))
return false;
}
if(!SetFullScreen(fullScreen, res, false))
return false;
CBaseTexture* iconTexture = CTexture::LoadFromFile("special://xbmc/media/icon.png");
if (iconTexture)
SDL_WM_SetIcon(SDL_CreateRGBSurfaceFrom(iconTexture->GetPixels(), iconTexture->GetWidth(), iconTexture->GetHeight(), 32, iconTexture->GetPitch(), 0xff0000, 0x00ff00, 0x0000ff, 0xff000000L), NULL);
SDL_WM_SetCaption("XBMC Media Center", NULL);
delete iconTexture;
// register XRandR Events
#if defined(HAS_XRANDR)
int iReturn;
XRRQueryExtension(m_dpy, &m_RREventBase, &iReturn);
XRRSelectInput(m_dpy, m_wmWindow, RRScreenChangeNotifyMask);
#endif
m_bWindowCreated = true;
return true;
}
bool CTextureDDSJob::DoWork()
{
if (URIUtils::GetExtension(m_original).Equals(".dds"))
return false;
CBaseTexture *texture = CBaseTexture::LoadFromFile(m_original);
if (texture)
{ // convert to DDS
CDDSImage dds;
CLog::Log(LOGDEBUG, "Creating DDS version of: %s", m_original.c_str());
bool ret = dds.Create(URIUtils::ReplaceExtension(m_original, ".dds"), texture->GetWidth(), texture->GetHeight(), texture->GetPitch(), texture->GetPixels(), 40);
delete texture;
return ret;
}
return false;
}
bool CWinSystemX11::CreateIconPixmap()
{
int depth;
XImage *img = NULL;
Visual *vis;
XWindowAttributes wndattribs;
XVisualInfo visInfo;
double rRatio;
double gRatio;
double bRatio;
int outIndex = 0;
unsigned int i,j;
unsigned char *buf;
uint32_t *newBuf = 0;
size_t numNewBufBytes;
// Get visual Info
XGetWindowAttributes(m_dpy, m_glWindow, &wndattribs);
visInfo.visualid = wndattribs.visual->visualid;
int nvisuals = 0;
XVisualInfo* visuals = XGetVisualInfo(m_dpy, VisualIDMask, &visInfo, &nvisuals);
if (nvisuals != 1)
{
CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - could not find visual");
return false;
}
visInfo = visuals[0];
XFree(visuals);
depth = visInfo.depth;
vis = visInfo.visual;
if (depth < 15)
{
CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - no suitable depth");
return false;
}
rRatio = vis->red_mask / 255.0;
gRatio = vis->green_mask / 255.0;
bRatio = vis->blue_mask / 255.0;
CBaseTexture *iconTexture = CBaseTexture::LoadFromFile("special://xbmc/media/icon256x256.png");
if (!iconTexture)
return false;
buf = iconTexture->GetPixels();
if (depth>=24)
numNewBufBytes = (4 * (iconTexture->GetWidth() * iconTexture->GetHeight()));
else
numNewBufBytes = (2 * (iconTexture->GetWidth() * iconTexture->GetHeight()));
newBuf = (uint32_t*)malloc(numNewBufBytes);
if (!newBuf)
{
CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - malloc failed");
return false;
}
for (i=0; i<iconTexture->GetHeight();++i)
{
for (j=0; j<iconTexture->GetWidth();++j)
{
unsigned int pos = i*iconTexture->GetPitch()+j*4;
unsigned int r, g, b;
r = (buf[pos+2] * rRatio);
g = (buf[pos+1] * gRatio);
b = (buf[pos+0] * bRatio);
r &= vis->red_mask;
g &= vis->green_mask;
b &= vis->blue_mask;
newBuf[outIndex] = r | g | b;
++outIndex;
}
}
img = XCreateImage(m_dpy, vis, depth,ZPixmap, 0, (char *)newBuf,
iconTexture->GetWidth(), iconTexture->GetHeight(),
(depth>=24)?32:16, 0);
if (!img)
{
CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - could not create image");
free(newBuf);
return false;
}
if (!XInitImage(img))
{
CLog::Log(LOGERROR, "CWinSystemX11::CreateIconPixmap - init image failed");
XDestroyImage(img);
return false;
}
// set byte order
union
{
char c[sizeof(short)];
short s;
} order;
order.s = 1;
if ((1 == order.c[0]))
{
img->byte_order = LSBFirst;
}
else
{
img->byte_order = MSBFirst;
}
// create icon pixmap from image
m_icon = XCreatePixmap(m_dpy, m_glWindow, img->width, img->height, depth);
GC gc = XCreateGC(m_dpy, m_glWindow, 0, NULL);
XPutImage(m_dpy, m_icon, gc, img, 0, 0, 0, 0, img->width, img->height);
XFreeGC(m_dpy, gc);
XDestroyImage(img); // this also frees newBuf
delete iconTexture;
return true;
}