void ScreenAreaGl::on_realize()
{
Gtk::DrawingArea::on_realize();
Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window();
if (!glwindow->gl_begin(get_gl_context()))
return;
glDisable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
if (glIsTexture(m_uiScreenTexture))
glDeleteTextures(1, &m_uiScreenTexture);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 1.0, 0.0, 0.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glGenTextures(1, &m_uiScreenTexture);
glBindTexture(GL_TEXTURE_2D, m_uiScreenTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
vUpdateTexture();
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glwindow->gl_end();
}
bool RHDrawingArea::on_expose_event(GdkEventExpose* event)
{
Glib::RefPtr<Gdk::GL::Window> gl_window = get_gl_window();
if (!gl_window->gl_begin(get_gl_context()))
{
return false;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glCallList(1);
if (gl_window->is_double_buffered())
{
gl_window->swap_buffers();
}
else
{
glFlush();
}
gl_window->gl_end();
return true;
}
bool ScreenAreaGl::on_expose_event(GdkEventExpose * _pstEvent)
{
if (!m_bEnableRender)
return true;
Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window();
if (!glwindow->gl_begin(get_gl_context()))
return false;
glClear( GL_COLOR_BUFFER_BIT );
glPixelStorei(GL_UNPACK_ROW_LENGTH, m_iScaledWidth + 1);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_iScaledWidth + 1, m_iScaledHeight,
GL_RGBA, GL_UNSIGNED_BYTE, m_puiPixels);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.0f, 0.0f);
glVertex3i(0, 0, 0);
glTexCoord2f(m_iScaledWidth / (GLfloat) m_iTextureSize, 0.0f);
glVertex3i(1, 0, 0);
glTexCoord2f(0.0f, m_iScaledHeight / (GLfloat) m_iTextureSize);
glVertex3i(0, 1, 0);
glTexCoord2f(m_iScaledWidth / (GLfloat) m_iTextureSize,
m_iScaledHeight / (GLfloat) m_iTextureSize);
glVertex3i(1, 1, 0);
glEnd();
glwindow->swap_buffers();
glwindow->gl_end();
return true;
}
void ViewGL::init()
{
_window = get_window();
_glcontext = get_gl_context();
_glwindow = get_gl_window();
if (not _glwindow->gl_begin(_glcontext))
{
UTILS_ERROR("OpenGL begin failed");
}
else
{
UTILS_INFO("OpenGL begin ok");
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
setGlColor(GL_SPECULAR, {{0.8f, 0.8f, 0.8f, 1.f}});
setGlColor(GL_SHININESS, {{10.f, 10.f, 10.f, 1.f}});
_glwindow->gl_end();
}
}
void ScreenAreaGl::vOnWidgetResize()
{
Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window();
int iWidth = get_width();
int iHeight = get_height();
float fScreenAspect = (float) m_iScaledWidth / m_iScaledHeight,
fWindowAspect = (float) iWidth / iHeight;
if (!glwindow->gl_begin(get_gl_context()))
return;
if (fWindowAspect == fScreenAspect)
glViewport(0, 0, iWidth, iHeight);
else if (fWindowAspect < fScreenAspect) {
int iAspectHeight = (int)(iWidth / fScreenAspect);
glViewport(0, (iHeight - iAspectHeight) / 2, iWidth, iAspectHeight);
} else {
int iAspectWidth = (int)(iHeight * fScreenAspect);
glViewport((iWidth - iAspectWidth) / 2, 0, iAspectWidth, iHeight);
}
glwindow->gl_end();
}
void
render_surface::gl_swap_buffers()
{
gl_begin();
get_gl_window()->swap_buffers();
glFinish(); // Ensure rendering completes here (without the GIL) rather than at the next paint (with the GIL)
gl_end();
}
bool ImageDrawingArea::BeginGL()
{
if ( !get_gl_window()->gl_begin( get_gl_context() ) )
{
return false;
}
return true;
}
void ScreenAreaGl::vOnSizeUpdated()
{
if (!is_realized())
return;
Glib::RefPtr<Gdk::GL::Window> glwindow = get_gl_window();
if (!glwindow->gl_begin(get_gl_context()))
return;
vUpdateTexture();
glwindow->gl_end();
}
bool RHDrawingArea::on_configure_event(GdkEventConfigure* event)
{
Glib::RefPtr<Gdk::GL::Window> gl_window = get_gl_window();
if (!gl_window->gl_begin(get_gl_context()))
{
return false;
}
glViewport(0, 0, get_width(), get_height());
gl_window->gl_end();
return true;
}
void RHDrawingArea::on_realize()
{
Gtk::DrawingArea::on_realize();
Glib::RefPtr<Gdk::GL::Window> gl_window = get_gl_window();
if (!gl_window->gl_begin(get_gl_context()))
{
return;
}
GLUquadricObj* qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj, GLU_FILL);
glNewList(1, GL_COMPILE);
gluSphere(qobj, 1.0, 20, 20);
glEndList();
static GLfloat light_diffuse[] = {1.0, 0.0, 0.0, 1.0};
static GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glClearColor(1.0, 1.0, 1.0, 1.0);
glClearDepth(1.0);
glViewport(0, 0, get_width(), get_height());
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(40.0, 1.0, 1.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0, 0.0, 3.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0);
glTranslatef(0.0, 0.0, -3.0);
gl_window->gl_end();
}
bool XvMCTextures::Init(Display *disp, Window XJ_curwin,
int XJ_screen_num,
const QSize &video_dim,
const QSize &window_size)
{
VERBOSE(VB_IMPORTANT, LOC + "Init");
if (!disp)
{
VERBOSE(VB_IMPORTANT, LOC_ERR + "Init() no display!");
return false;
}
XJ_disp = disp;
if (!init_opengl())
{
VERBOSE(VB_PLAYBACK, LOC_ERR + "Failed to initialize OpenGL support.");
return false;
}
uint major = 0, minor = 0;
if (!get_glx_version(XJ_disp, major, minor))
{
VERBOSE(VB_PLAYBACK, LOC_ERR + "GLX extension not present.");
return false;
}
if ((1 == major) && (minor < 3))
{
VERBOSE(VB_PLAYBACK, LOC_ERR + QString(
"Need GLX 1.3 or better, have %1.%2")
.arg(major).arg(minor));
return false;
}
if (!glx_fbconfig)
{
glx_fbconfig = get_fbuffer_cfg(
XJ_disp, XJ_screen_num, get_attr_cfg(kRenderRGBA));
}
if (glx_fbconfig)
glx_pbuffer = get_pbuffer(XJ_disp, glx_fbconfig, video_dim);
if (!glx_context)
X11S(glx_context = glXCreateNewContext(XJ_disp, glx_fbconfig,
GLX_RGBA_TYPE, NULL, 1));
XVisualInfo *vis_info;
vis_info = glXGetVisualFromFBConfig(XJ_disp, glx_fbconfig);
gl_window = get_gl_window(XJ_disp, XJ_curwin, vis_info,
window_size, true);
glx_window = get_glx_window(XJ_disp, glx_fbconfig, gl_window, glx_context,
glx_pbuffer, window_size);
glXMakeContextCurrent(XJ_disp, glx_window, glx_pbuffer, glx_context);
glCheck();
glXMakeContextCurrent(XJ_disp, None, None, NULL);
gl_vid_textures = create_textures(
XJ_disp, glx_window, glx_context, glx_pbuffer, video_dim, 1);
gl_vid_tex_size.resize(gl_vid_textures.size());
gl_osd_textures = create_textures(
XJ_disp, glx_window, glx_context, glx_pbuffer, video_dim, 1);
gl_osd_tex_size.resize(gl_vid_textures.size());
XSync(XJ_disp, 0);
gl_display_size = window_size;
gl_video_size = video_dim;
glXMakeContextCurrent(XJ_disp, glx_window, glx_pbuffer, glx_context);
glCheck();
glXMakeContextCurrent(XJ_disp, None, None, NULL);
VERBOSE(VB_IMPORTANT, LOC +
QString("InitXvMCGL: video_size: %1x%2 vis_size: %3x%4")
.arg(gl_video_size.width()).arg(gl_video_size.height())
.arg(gl_display_size.width()).arg(gl_display_size.height()));
VERBOSE(VB_IMPORTANT, LOC <<endl
<<"glx_fbconfig: "<<glx_fbconfig<<endl
<<"gl_window: "<<gl_window<<endl
<<"glx_window: "<<glx_window<<endl
<<"gl_vid_tex: "<<gl_vid_textures[0]<<endl
<<"gl_osd_tex: "<<gl_osd_textures[0]<<endl);
return true;
}
void
render_surface::gl_end()
{
get_gl_window()->gl_end();
}
void
render_surface::gl_begin()
{
bool ok = get_gl_window()->gl_begin(get_gl_context());
assert(ok);
}
void ImageDrawingArea::EndGL()
{
get_gl_window()->gl_end();
}
bool ImageDrawingArea::on_expose_event( GdkEventExpose* /*event*/ )
{
if ( m_pixBuf == NULL )
{
return true;
}
Glib::Mutex::Lock lock(m_pixBufMutex);
const int width = m_pixBuf->get_width();
const int height = m_pixBuf->get_height();
double validTextureWidth = 1.0;
double validTextureHeight = 1.0;
bool useTiledTextures = false;
GLenum errorno;
BeginGL();
SetImageSize( width, height );
int screenWidth = 0;
int screenHeight = 0;
get_window()->get_size( screenWidth, screenHeight );
// This makes sure that sampling for rendering doesn't occur on the border of pixels.
const double halfPixelAdjustW = 0.25 / (double)screenWidth;
const double halfPixelAdjustH = 0.25 / (double)screenHeight;
glEnable( GL_TEXTURE_2D );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// center the image
glTranslated(
-(m_scaleX - 1.0)/2.0 + halfPixelAdjustW,
-(m_scaleY - 1.0)/2.0 + halfPixelAdjustH, 0.0);
// apply mouse-drag shift
glTranslated(m_shiftX, m_shiftY, 0.0);
// scale the image
glScaled(m_scaleX, m_scaleY, 0.0);
// draw the image
glBindTexture(GL_TEXTURE_2D, m_imageTextures[0]);
#ifdef _WIN32
if (m_PBOSupported)
{
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_PBO);
errorno = glGetError();
if (errorno != GL_NO_ERROR)
{
m_PBOSupported = false;
}
else
{
glBufferDataARB(
GL_PIXEL_UNPACK_BUFFER_ARB,
width * height * 4,
m_pixBuf->get_pixels(),
GL_STREAM_DRAW_ARB);
errorno = glGetError();
if (errorno != GL_NO_ERROR)
{
m_PBOSupported = false;
}
}
}
#endif
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGBA,
width,
height,
0,
GL_BGRA_EXT,
GL_UNSIGNED_BYTE,
m_PBOSupported ? NULL : m_pixBuf->get_pixels() );
errorno = glGetError();
if (errorno != GL_NO_ERROR)
{
// Attempt to fall back and use a power-of-two sized texture.
// This is for older cards that don't support more arbitrary
// texture sizes.
#ifdef _WIN32
if (m_PBOSupported)
{
// unbind PBO to use normal texture transfer
glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, 0);
}
#endif
const int textureWidth = GetMinimumPowerOfTwo(width);
const int textureHeight = GetMinimumPowerOfTwo(height);
validTextureWidth = (double)width / textureWidth;
validTextureHeight = (double)height / textureHeight;
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGBA,
textureWidth,
textureHeight,
0,
GL_BGRA_EXT,
GL_UNSIGNED_BYTE,
NULL );
errorno = glGetError();
if (errorno != GL_NO_ERROR)
{
// The graphics doesn't seem to support this texture size.
// Images must be split and then tiled.
useTiledTextures = true;
}
else
{
glTexSubImage2D(
GL_TEXTURE_2D,
0,
0,
0,
width,
height,
GL_BGRA_EXT,
GL_UNSIGNED_BYTE,
m_pixBuf->get_pixels() );
errorno = glGetError();
if ( errorno != GL_NO_ERROR)
{
// Error
}
}
}
if (useTiledTextures)
{
//
// The image is split into multiple textures.
//
const int bytesPerPixel = 4;
const int tileSize = 1024;
int horizResidual = width % tileSize;
int vertResidual = height % tileSize;
int numHorizTextures = width / tileSize + (horizResidual > 0);
int numVertTextures = height / tileSize + (vertResidual > 0);
unsigned char *tileBuffer = new unsigned char[tileSize * tileSize * bytesPerPixel];
for (int tileY = 0; tileY < numVertTextures ; tileY++)
{
for (int tileX = 0; tileX < numHorizTextures; tileX++)
{
int subTexHeight = tileSize;
if ( tileY == numVertTextures - 1 && vertResidual > 0)
{
subTexHeight = vertResidual;
}
int subTexWidth = tileSize;
if (tileX == numHorizTextures - 1 && horizResidual > 0)
{
subTexWidth = horizResidual;
}
// copy image buffer to the tile
for (int line = 0; line < subTexHeight; line++)
{
memcpy(
tileBuffer + line * tileSize * bytesPerPixel,
m_pixBuf->get_pixels() + ((line + tileSize * tileY) * width + tileSize * tileX) * bytesPerPixel,
subTexWidth * bytesPerPixel);
}
const unsigned int texId = tileY * numHorizTextures + tileX;
if (texId >= sk_maxNumTextures)
{
continue;
}
glBindTexture( GL_TEXTURE_2D, m_imageTextures[ texId] );
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGBA,
tileSize,
tileSize,
0,
GL_BGRA_EXT,
GL_UNSIGNED_BYTE,
tileBuffer );
const double validTileWidth = (double)subTexWidth/tileSize;
const double validTileHeight = (double)subTexHeight/tileSize;
const double x_begin = (double)tileSize / width * tileX;
const double x_end = (double)tileSize / width * ( tileX + validTileWidth);
const double y_begin = 1.0 - (double)tileSize / height * ( tileY + validTileHeight);
const double y_end = 1.0 - (double)tileSize / height * tileY;
glBegin( GL_QUADS );
glTexCoord2d(0.0, validTileHeight);
glVertex2d(x_begin, y_begin);
glTexCoord2d(validTileWidth, validTileHeight);
glVertex2d(x_end, y_begin);
glTexCoord2d(validTileWidth, 0.0);
glVertex2d(x_end, y_end);
glTexCoord2d(0.0, 0.0);
glVertex2d(x_begin, y_end);
glEnd();
}
}
delete [] tileBuffer;
}
else
{
// Just one texture
glBegin( GL_QUADS );
glTexCoord2d(0.0, validTextureHeight);
glVertex2d(0.0, 0.0);
glTexCoord2d(validTextureWidth, validTextureHeight);
glVertex2d(1.0, 0.0);
glTexCoord2d(validTextureWidth, 0.0);
glVertex2d(1.0, 1.0);
glTexCoord2d(0.0, 0.0);
glVertex2d(0.0, 1.0);
glEnd();
}
if ( m_showCrosshair )
{
const double aspectRatio = (double)width/height;
glTranslated(0.5, 0.5, 0.0);
glScaled(1.0, aspectRatio, 0.0);
ShowCrosshair();
}
if (get_gl_window()->is_double_buffered())
{
get_gl_window()->swap_buffers();
}
else
{
glFlush();
}
EndGL();
lock.release();
m_displayedFrameRate.NewFrame();
return true;
}
