bool CFrameBufferObject::Initialize()
{
if (!IsSupported())
return false;
Cleanup();
glGenFramebuffersEXT(1, &m_fbo);
VerifyGLState();
if (!m_fbo)
return false;
m_valid = true;
return true;
}
void CGUITextureGL::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
texture->LoadToGPU();
texture->BindToUnit(0);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE1);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
}
else
glDisable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// diffuse coloring
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
VerifyGLState();
glBegin(GL_QUADS);
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
glTexCoord2f(coords.x1, coords.y1);
glVertex3f(rect.x1, rect.y1, 0);
glTexCoord2f(coords.x2, coords.y1);
glVertex3f(rect.x2, rect.y1, 0);
glTexCoord2f(coords.x2, coords.y2);
glVertex3f(rect.x2, rect.y2, 0);
glTexCoord2f(coords.x1, coords.y2);
glVertex3f(rect.x1, rect.y2, 0);
glEnd();
if (texture)
glDisable(GL_TEXTURE_2D);
}
bool CFrameBufferObject::CreateAndBindToTexture(GLenum target, int width, int height, GLenum format,
GLenum filter, GLenum clampmode)
{
if (!IsValid())
return false;
if (m_texid)
glDeleteTextures(1, &m_texid);
glGenTextures(1, &m_texid);
glBindTexture(target, m_texid);
glTexImage2D(target, 0, format, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(target, GL_TEXTURE_WRAP_S, clampmode);
glTexParameteri(target, GL_TEXTURE_WRAP_T, clampmode);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
VerifyGLState();
return BindToTexture(target, m_texid);
}
bool CFrameBufferObjectGL::Initialize()
{
if (!IsSupported())
return false;
Cleanup();
#if defined(HAS_GL) || defined(HAS_GL2)
glGenFramebuffersEXT(1, &m_fbo);
#else
glGenFramebuffers(1, &m_fbo);
#endif
VerifyGLState();
if (!m_fbo)
return false;
m_valid = true;
return true;
}
void CGUITextureGLES::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
glActiveTexture(GL_TEXTURE0);
texture->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
}
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLubyte col[4][4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
if (texture)
g_Windowing.EnableGUIShader(SM_TEXTURE);
else
g_Windowing.EnableGUIShader(SM_DEFAULT);
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint colLoc = g_Windowing.GUIShaderGetCol();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
if(colLoc >= 0)
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, col);
if (texture)
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
if (texture)
glEnableVertexAttribArray(tex0Loc);
if(colLoc >= 0)
glEnableVertexAttribArray(colLoc);
for (int i=0; i<4; i++)
{
// Setup Colour Values
col[i][0] = (GLubyte)GET_R(color);
col[i][1] = (GLubyte)GET_G(color);
col[i][2] = (GLubyte)GET_B(color);
col[i][3] = (GLubyte)GET_A(color);
}
// Setup vertex position values
#define ROUND_TO_PIXEL(x) (float)(MathUtils::round_int(x))
ver[0][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x1, rect.y1));
ver[0][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x1, rect.y1));
ver[0][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x1, rect.y1));
ver[1][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x2, rect.y1));
ver[1][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x2, rect.y1));
ver[1][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x2, rect.y1));
ver[2][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x2, rect.y2));
ver[2][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x2, rect.y2));
ver[2][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x2, rect.y2));
ver[3][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x1, rect.y2));
ver[3][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x1, rect.y2));
ver[3][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x1, rect.y2));
if (texture)
{
// Setup texture coordinates
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
tex[0][0] = tex[3][0] = coords.x1;
tex[0][1] = tex[1][1] = coords.y1;
tex[1][0] = tex[2][0] = coords.x2;
tex[2][1] = tex[3][1] = coords.y2;
}
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
if(colLoc >= 0)
glDisableVertexAttribArray(colLoc);
if (texture)
glDisableVertexAttribArray(tex0Loc);
g_Windowing.DisableGUIShader();
}
bool CRendererVTB::UploadTexture(int index)
{
CRenderBuffer &buf = m_vtbBuffers[index];
if (!buf.m_videoBuffer)
return false;
CVOpenGLESTextureCacheFlush(m_textureCache, 0);
if (buf.m_textureY)
CFRelease(buf.m_textureY);
buf.m_textureY = nullptr;
if (buf.m_textureUV)
CFRelease(buf.m_textureUV);
buf.m_textureUV = nullptr;
YV12Image &im = m_buffers[index].image;
YUVFIELDS &fields = m_buffers[index].fields;
YUVPLANES &planes = fields[0];
CVReturn ret;
ret = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
m_textureCache,
buf.m_videoBuffer, NULL, GL_TEXTURE_2D, GL_LUMINANCE,
im.width, im.height, GL_LUMINANCE, GL_UNSIGNED_BYTE,
0,
&buf.m_textureY);
if (ret != kCVReturnSuccess)
{
CLog::Log(LOGERROR, "CRendererVTB::UploadTexture - Error uploading texture Y (err: %d)", ret);
return false;
}
ret = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
m_textureCache,
buf.m_videoBuffer, NULL, GL_TEXTURE_2D, GL_LUMINANCE_ALPHA,
im.width/2, im.height/2, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
1,
&buf.m_textureUV);
if (ret != kCVReturnSuccess)
{
CLog::Log(LOGERROR, "CRendererVTB::UploadTexture - Error uploading texture UV (err: %d)", ret);
return false;
}
// set textures
planes[0].id = CVOpenGLESTextureGetName(buf.m_textureY);
planes[1].id = CVOpenGLESTextureGetName(buf.m_textureUV);
planes[2].id = CVOpenGLESTextureGetName(buf.m_textureUV);
glEnable(m_textureTarget);
for (int p=0; p<2; p++)
{
glBindTexture(m_textureTarget, planes[p].id);
glTexParameteri(m_textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(m_textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(m_textureTarget, 0);
VerifyGLState();
}
CalculateTextureSourceRects(index, 3);
return true;
}
void CGLTexture::LoadToGPU()
{
if (!m_pixels)
{
// nothing to load - probably same image (no change)
return;
}
if (m_texture == 0)
{
// Have OpenGL generate a texture object handle for us
// this happens only one time - the first time the texture is loaded
CreateTextureObject();
}
// Bind the texture object
glBindTexture(GL_TEXTURE_2D, m_texture);
GLenum filter = (m_scalingMethod == TEXTURE_SCALING::NEAREST ? GL_NEAREST : GL_LINEAR);
// Set the texture's stretching properties
if (IsMipmapped())
{
GLenum mipmapFilter = (m_scalingMethod == TEXTURE_SCALING::NEAREST ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mipmapFilter);
#ifndef HAS_GLES
// Lower LOD bias equals more sharpness, but less smooth animation
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -0.5f);
if (!m_isOglVersion3orNewer)
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
#endif
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
unsigned int maxSize = CServiceBroker::GetRenderSystem()->GetMaxTextureSize();
if (m_textureHeight > maxSize)
{
CLog::Log(LOGERROR, "GL: Image height %d too big to fit into single texture unit, truncating to %u", m_textureHeight, maxSize);
m_textureHeight = maxSize;
}
if (m_textureWidth > maxSize)
{
CLog::Log(LOGERROR, "GL: Image width %d too big to fit into single texture unit, truncating to %u", m_textureWidth, maxSize);
#ifndef HAS_GLES
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_textureWidth);
#endif
m_textureWidth = maxSize;
}
#ifndef HAS_GLES
GLenum format = GL_BGRA;
GLint numcomponents = GL_RGBA;
switch (m_format)
{
case XB_FMT_DXT1:
format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
break;
case XB_FMT_DXT3:
format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
break;
case XB_FMT_DXT5:
case XB_FMT_DXT5_YCoCg:
format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
break;
case XB_FMT_RGB8:
format = GL_RGB;
numcomponents = GL_RGB;
break;
case XB_FMT_A8R8G8B8:
default:
break;
}
if ((m_format & XB_FMT_DXT_MASK) == 0)
{
glTexImage2D(GL_TEXTURE_2D, 0, numcomponents,
m_textureWidth, m_textureHeight, 0,
format, GL_UNSIGNED_BYTE, m_pixels);
}
else
{
glCompressedTexImage2D(GL_TEXTURE_2D, 0, format,
m_textureWidth, m_textureHeight, 0,
GetPitch() * GetRows(), m_pixels);
}
if (IsMipmapped() && m_isOglVersion3orNewer)
{
glGenerateMipmap(GL_TEXTURE_2D);
}
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
#else // GLES version
// All incoming textures are BGRA, which GLES does not necessarily support.
// Some (most?) hardware supports BGRA textures via an extension.
// If not, we convert to RGBA first to avoid having to swizzle in shaders.
// Explicitly define GL_BGRA_EXT here in the case that it's not defined by
// system headers, and trust the extension list instead.
#ifndef GL_BGRA_EXT
#define GL_BGRA_EXT 0x80E1
#endif
GLint internalformat;
GLenum pixelformat;
switch (m_format)
{
default:
case XB_FMT_RGBA8:
internalformat = pixelformat = GL_RGBA;
break;
case XB_FMT_RGB8:
internalformat = pixelformat = GL_RGB;
break;
case XB_FMT_A8R8G8B8:
if (CServiceBroker::GetRenderSystem()->IsExtSupported("GL_EXT_texture_format_BGRA8888") ||
CServiceBroker::GetRenderSystem()->IsExtSupported("GL_IMG_texture_format_BGRA8888"))
{
internalformat = pixelformat = GL_BGRA_EXT;
}
else if (CServiceBroker::GetRenderSystem()->IsExtSupported("GL_APPLE_texture_format_BGRA8888"))
{
// Apple's implementation does not conform to spec. Instead, they require
// differing format/internalformat, more like GL.
internalformat = GL_RGBA;
pixelformat = GL_BGRA_EXT;
}
else
{
SwapBlueRed(m_pixels, m_textureHeight, GetPitch());
internalformat = pixelformat = GL_RGBA;
}
break;
}
glTexImage2D(GL_TEXTURE_2D, 0, internalformat, m_textureWidth, m_textureHeight, 0,
pixelformat, GL_UNSIGNED_BYTE, m_pixels);
if (IsMipmapped())
{
glGenerateMipmap(GL_TEXTURE_2D);
}
#endif
VerifyGLState();
if (!m_bCacheMemory)
{
_aligned_free(m_pixels);
m_pixels = NULL;
}
m_loadedToGPU = true;
}
void CGUITextureGL::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
texture->LoadToGPU();
texture->BindToUnit(0);
}
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLubyte col[4];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of the vertices
GLuint vertexVBO;
GLuint indexVBO;
struct PackedVertex
{
float x, y, z;
float u1, v1;
}vertex[4];
if (texture)
g_Windowing.EnableShader(SM_TEXTURE);
else
g_Windowing.EnableShader(SM_DEFAULT);
GLint posLoc = g_Windowing.ShaderGetPos();
GLint tex0Loc = g_Windowing.ShaderGetCoord0();
GLint uniColLoc = g_Windowing.ShaderGetUniCol();
// Setup Colors
col[0] = (GLubyte)GET_R(color);
col[1] = (GLubyte)GET_G(color);
col[2] = (GLubyte)GET_B(color);
col[3] = (GLubyte)GET_A(color);
glUniform4f(uniColLoc, col[0] / 255.0f, col[1] / 255.0f, col[2] / 255.0f, col[3] / 255.0f);
// bottom left
vertex[0].x = rect.x1;
vertex[0].y = rect.y1;
vertex[0].z = 0;
// bottom right
vertex[1].x = rect.x2;
vertex[1].y = rect.y1;
vertex[1].z = 0;
// top right
vertex[2].x = rect.x2;
vertex[2].y = rect.y2;
vertex[2].z = 0;
// top left
vertex[3].x = rect.x1;
vertex[3].y = rect.y2;
vertex[3].z = 0;
if (texture)
{
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
vertex[0].u1 = vertex[3].u1 = coords.x1;
vertex[0].v1 = vertex[1].v1 = coords.y1;
vertex[1].u1 = vertex[2].u1 = coords.x2;
vertex[2].v1 = vertex[3].v1 = coords.y2;
}
glGenBuffers(1, &vertexVBO);
glBindBuffer(GL_ARRAY_BUFFER, vertexVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(PackedVertex)*4, &vertex[0], GL_STATIC_DRAW);
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, x)));
glEnableVertexAttribArray(posLoc);
if (texture)
{
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, u1)));
glEnableVertexAttribArray(tex0Loc);
}
glGenBuffers(1, &indexVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLubyte)*4, idx, GL_STATIC_DRAW);
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, 0);
glDisableVertexAttribArray(posLoc);
if (texture)
glDisableVertexAttribArray(tex0Loc);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &vertexVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &indexVBO);
g_Windowing.DisableShader();
}
bool CRendererMediaCodec::RenderHook(int index)
{
YUVPLANE &plane = m_buffers[index].fields[0][0];
YUVPLANE &planef = m_buffers[index].fields[m_currentField][0];
glDisable(GL_DEPTH_TEST);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, plane.id);
if (m_currentField != FIELD_FULL)
{
g_Windowing.EnableGUIShader(SM_TEXTURE_RGBA_BOB_OES);
GLint fieldLoc = g_Windowing.GUIShaderGetField();
GLint stepLoc = g_Windowing.GUIShaderGetStep();
// Y is inverted, so invert fields
if (m_currentField == FIELD_TOP)
glUniform1i(fieldLoc, 0);
else if(m_currentField == FIELD_BOT)
glUniform1i(fieldLoc, 1);
glUniform1f(stepLoc, 1.0f / (float)plane.texheight);
}
else
g_Windowing.EnableGUIShader(SM_TEXTURE_RGBA_OES);
GLint contrastLoc = g_Windowing.GUIShaderGetContrast();
glUniform1f(contrastLoc, CMediaSettings::GetInstance().GetCurrentVideoSettings().m_Contrast * 0.02f);
GLint brightnessLoc = g_Windowing.GUIShaderGetBrightness();
glUniform1f(brightnessLoc, CMediaSettings::GetInstance().GetCurrentVideoSettings().m_Brightness * 0.01f - 0.5f);
glUniformMatrix4fv(g_Windowing.GUIShaderGetCoord0Matrix(), 1, GL_FALSE, m_textureMatrix);
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
GLfloat ver[4][4];
GLfloat tex[4][4];
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint texLoc = g_Windowing.GUIShaderGetCoord0();
glVertexAttribPointer(posLoc, 4, GL_FLOAT, 0, 0, ver);
glVertexAttribPointer(texLoc, 4, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
glEnableVertexAttribArray(texLoc);
// Set vertex coordinates
for(int i = 0; i < 4; i++)
{
ver[i][0] = m_rotatedDestCoords[i].x;
ver[i][1] = m_rotatedDestCoords[i].y;
ver[i][2] = 0.0f; // set z to 0
ver[i][3] = 1.0f;
}
// Set texture coordinates (MediaCodec is flipped in y)
if (m_currentField == FIELD_FULL)
{
tex[0][0] = tex[3][0] = plane.rect.x1;
tex[0][1] = tex[1][1] = plane.rect.y2;
tex[1][0] = tex[2][0] = plane.rect.x2;
tex[2][1] = tex[3][1] = plane.rect.y1;
}
else
{
tex[0][0] = tex[3][0] = planef.rect.x1;
tex[0][1] = tex[1][1] = planef.rect.y2 * 2.0f;
tex[1][0] = tex[2][0] = planef.rect.x2;
tex[2][1] = tex[3][1] = planef.rect.y1 * 2.0f;
}
for(int i = 0; i < 4; i++)
{
tex[i][2] = 0.0f;
tex[i][3] = 1.0f;
}
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
glDisableVertexAttribArray(texLoc);
const float identity[16] = {
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
glUniformMatrix4fv(g_Windowing.GUIShaderGetCoord0Matrix(), 1, GL_FALSE, identity);
g_Windowing.DisableGUIShader();
VerifyGLState();
glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
VerifyGLState();
return true;
}
bool CRendererVDPAU::UploadVDPAUTexture420(int index)
{
VDPAU::CVdpauRenderPicture *vdpau = (VDPAU::CVdpauRenderPicture*)m_buffers[index].hwDec;
YV12Image &im = m_buffers[index].image;
YUVFIELDS &fields = m_buffers[index].fields;
if (!vdpau || !vdpau->valid)
{
return false;
}
im.height = vdpau->texHeight;
im.width = vdpau->texWidth;
// YUV
for (int f = FIELD_TOP; f<=FIELD_BOT ; f++)
{
YUVPLANES &planes = fields[f];
planes[0].texwidth = im.width;
planes[0].texheight = im.height >> 1;
planes[1].texwidth = planes[0].texwidth >> im.cshift_x;
planes[1].texheight = planes[0].texheight >> im.cshift_y;
planes[2].texwidth = planes[1].texwidth;
planes[2].texheight = planes[1].texheight;
for (int p = 0; p < 3; p++)
{
planes[p].pixpertex_x = 1;
planes[p].pixpertex_y = 1;
}
}
// crop
// m_sourceRect.x1 += vdpau->crop.x1;
// m_sourceRect.x2 -= vdpau->crop.x2;
// m_sourceRect.y1 += vdpau->crop.y1;
// m_sourceRect.y2 -= vdpau->crop.y2;
// set textures
fields[1][0].id = vdpau->texture[0];
fields[1][1].id = vdpau->texture[2];
fields[1][2].id = vdpau->texture[2];
fields[2][0].id = vdpau->texture[1];
fields[2][1].id = vdpau->texture[3];
fields[2][2].id = vdpau->texture[3];
glEnable(m_textureTarget);
for (int f = FIELD_TOP; f <= FIELD_BOT; f++)
{
for (int p=0; p<2; p++)
{
glBindTexture(m_textureTarget,fields[f][p].id);
glTexParameteri(m_textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(m_textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(m_textureTarget,0);
VerifyGLState();
}
}
CalculateTextureSourceRects(index, 3);
glDisable(m_textureTarget);
return true;
}
bool CRendererVTB::UploadTexture(int index)
{
CRenderBuffer &renderBuf = m_vtbBuffers[index];
YUVBUFFER &buf = m_buffers[index];
YUVPLANE (&planes)[YuvImage::MAX_PLANES] = m_buffers[index].fields[0];
YuvImage &im = m_buffers[index].image;
VTB::CVideoBufferVTB *vb = dynamic_cast<VTB::CVideoBufferVTB*>(buf.videoBuffer);
if (!vb)
{
return false;
}
CVOpenGLESTextureCacheFlush(m_textureCache, 0);
if (renderBuf.m_textureY)
CFRelease(renderBuf.m_textureY);
renderBuf.m_textureY = nullptr;
if (renderBuf.m_textureUV)
CFRelease(renderBuf.m_textureUV);
renderBuf.m_textureUV = nullptr;
CVReturn ret;
ret = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
m_textureCache,
vb->GetPB(), nullptr, GL_TEXTURE_2D, GL_LUMINANCE,
im.width, im.height, GL_LUMINANCE, GL_UNSIGNED_BYTE,
0,
&renderBuf.m_textureY);
if (ret != kCVReturnSuccess)
{
CLog::Log(LOGERROR, "CRendererVTB::UploadTexture - Error uploading texture Y (err: %d)", ret);
return false;
}
ret = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
m_textureCache,
vb->GetPB(), nullptr, GL_TEXTURE_2D, GL_LUMINANCE_ALPHA,
im.width/2, im.height/2, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
1,
&renderBuf.m_textureUV);
if (ret != kCVReturnSuccess)
{
CLog::Log(LOGERROR, "CRendererVTB::UploadTexture - Error uploading texture UV (err: %d)", ret);
return false;
}
// set textures
planes[0].id = CVOpenGLESTextureGetName(renderBuf.m_textureY);
planes[1].id = CVOpenGLESTextureGetName(renderBuf.m_textureUV);
planes[2].id = CVOpenGLESTextureGetName(renderBuf.m_textureUV);
for (int p=0; p<2; p++)
{
glBindTexture(m_textureTarget, planes[p].id);
glTexParameteri(m_textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(m_textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(m_textureTarget, 0);
VerifyGLState();
}
CalculateTextureSourceRects(index, 3);
return true;
}
bool CGUIFontTTFGL::FirstBegin()
{
if (m_textureStatus == TEXTURE_REALLOCATED)
{
if (glIsTexture(m_nTexture))
g_TextureManager.ReleaseHwTexture(m_nTexture);
m_textureStatus = TEXTURE_VOID;
}
if (m_textureStatus == TEXTURE_VOID)
{
// Have OpenGL generate a texture object handle for us
glGenTextures(1, (GLuint*) &m_nTexture);
// Bind the texture object
glBindTexture(GL_TEXTURE_2D, m_nTexture);
#ifdef HAS_GL
glEnable(GL_TEXTURE_2D);
#endif
// Set the texture's stretching properties
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Set the texture image -- THIS WORKS, so the pixels must be wrong.
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, m_texture->GetWidth(), m_texture->GetHeight(), 0,
GL_ALPHA, GL_UNSIGNED_BYTE, 0);
VerifyGLState();
m_textureStatus = TEXTURE_UPDATED;
}
if (m_textureStatus == TEXTURE_UPDATED)
{
glBindTexture(GL_TEXTURE_2D, m_nTexture);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, m_updateY1, m_texture->GetWidth(), m_updateY2 - m_updateY1, GL_ALPHA, GL_UNSIGNED_BYTE,
m_texture->GetPixels() + m_updateY1 * m_texture->GetPitch());
glDisable(GL_TEXTURE_2D);
m_updateY1 = m_updateY2 = 0;
m_textureStatus = TEXTURE_READY;
}
// Turn Blending On
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_ONE);
glEnable(GL_BLEND);
#ifdef HAS_GL
glEnable(GL_TEXTURE_2D);
#endif
glBindTexture(GL_TEXTURE_2D, m_nTexture);
#ifdef HAS_GL
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
VerifyGLState();
if(g_Windowing.UseLimitedColor())
{
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, m_nTexture); // dummy bind
glEnable(GL_TEXTURE_2D);
const GLfloat rgba[4] = {16.0f / 255.0f, 16.0f / 255.0f, 16.0f / 255.0f, 0.0f};
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE , GL_COMBINE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, rgba);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB , GL_ADD);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB , GL_PREVIOUS);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB , GL_CONSTANT);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA , GL_REPLACE);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA , GL_PREVIOUS);
VerifyGLState();
}
#endif
return true;
}
void CGUITextureGLES::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
CRenderSystemGLES *renderSystem = dynamic_cast<CRenderSystemGLES*>(&CServiceBroker::GetRenderSystem());
if (texture)
{
texture->LoadToGPU();
texture->BindToUnit(0);
}
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLubyte col[4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
if (texture)
renderSystem->EnableGUIShader(SM_TEXTURE);
else
renderSystem->EnableGUIShader(SM_DEFAULT);
GLint posLoc = renderSystem->GUIShaderGetPos();
GLint tex0Loc = renderSystem->GUIShaderGetCoord0();
GLint uniColLoc= renderSystem->GUIShaderGetUniCol();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
if (texture)
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
if (texture)
glEnableVertexAttribArray(tex0Loc);
// Setup Colors
col[0] = (GLubyte)GET_R(color);
col[1] = (GLubyte)GET_G(color);
col[2] = (GLubyte)GET_B(color);
col[3] = (GLubyte)GET_A(color);
glUniform4f(uniColLoc, col[0] / 255.0f, col[1] / 255.0f, col[2] / 255.0f, col[3] / 255.0f);
ver[0][0] = ver[3][0] = rect.x1;
ver[0][1] = ver[1][1] = rect.y1;
ver[1][0] = ver[2][0] = rect.x2;
ver[2][1] = ver[3][1] = rect.y2;
ver[0][2] = ver[1][2] = ver[2][2] = ver[3][2]= 0;
if (texture)
{
// Setup texture coordinates
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
tex[0][0] = tex[3][0] = coords.x1;
tex[0][1] = tex[1][1] = coords.y1;
tex[1][0] = tex[2][0] = coords.x2;
tex[2][1] = tex[3][1] = coords.y2;
}
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
if (texture)
glDisableVertexAttribArray(tex0Loc);
renderSystem->DisableGUIShader();
}
void CGUITextureGLES::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
glActiveTexture(GL_TEXTURE0);
texture->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
glEnable(GL_TEXTURE_2D);
}
else
glDisable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLfloat col[4][4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
g_Windowing.EnableGUIShader(SM_TEXTURE);
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint colLoc = g_Windowing.GUIShaderGetCol();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, col);
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
glEnableVertexAttribArray(tex0Loc);
glEnableVertexAttribArray(colLoc);
for (int i=0; i<4; i++)
{
// Setup Colour Values
col[i][0] = (GLubyte)GET_R(color);
col[i][1] = (GLubyte)GET_G(color);
col[i][2] = (GLubyte)GET_B(color);
col[i][3] = (GLubyte)GET_A(color);
}
// Setup vertex position values
// ver[0][3] = ver[1][3] = ver[2][3] = ver[3][3] = 0.0f; // FIXME, ver has only 3 elements - this is not correct
ver[0][0] = ver[3][0] = rect.x1;
ver[0][1] = ver[1][1] = rect.y1;
ver[1][0] = ver[2][0] = rect.x2;
ver[2][1] = ver[3][1] = rect.y2;
// Setup texture coordinates
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
tex[0][0] = tex[3][0] = coords.x1;
tex[0][1] = tex[1][1] = coords.y1;
tex[1][0] = tex[2][0] = coords.x2;
tex[2][1] = tex[3][1] = coords.y2;
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
glDisableVertexAttribArray(colLoc);
glDisableVertexAttribArray(tex0Loc);
g_Windowing.DisableGUIShader();
if (texture)
glDisable(GL_TEXTURE_2D);
}