def update_texture_rgb24(self, img_data, x, y, width, height, rowstride):
drawable = self.glarea.get_gl_drawable()
context = self.glarea.get_gl_context()
if not drawable.gl_begin(context):
raise Exception("** Cannot create OpenGL rendering context!")
assert self.textures is not None
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride / 3)
if self.current_mode == GLClientWindow.MODE_YUV:
raise Exception("** YUV -> RGB mode change unimplemented!")
elif self.current_mode == GLClientWindow.MODE_UNINITIALIZED:
log("Creating new RGB texture")
w, h = self.get_size()
# First time we draw must be full image
assert w == width and h == height
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0, GL_RGB,
GL_UNSIGNED_BYTE, 0)
self.current_mode = GLClientWindow.MODE_RGB
log("Updating RGB texture")
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width, height,
GL_RGB, GL_UNSIGNED_BYTE, img_data)
drawable.gl_end()
self.render_image()
def _loadTexture(self):
"""
Load texture data from current image object
"""
ix, iy, image = self.image_obj.getTextureData()
# allocate texture object if never yet done [bruce 060207 revised all related code, to fix bug 1059]
if self.tex_name is None:
self.tex_name = glGenTextures(1)
# note: by experiment (iMac G5 Panther), this returns a single number (1L, 2L, ...), not a list or tuple,
# but for an argument >1 it returns a list of longs. We depend on this behavior here. [bruce 060207]
# initialize texture data
glBindTexture(GL_TEXTURE_2D,
self.tex_name) # 2d texture (x and y size)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
self.have_mipmaps = False
if debug_pref("smoother tiny textures",
Choice_boolean_False,
prefs_key=True):
#bruce 060212 new feature; only takes effect when image is reloaded for some reason (like "load image" button)
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, ix, iy, GL_RGBA,
GL_UNSIGNED_BYTE, image)
self.have_mipmaps = True
else:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA,
GL_UNSIGNED_BYTE, image)
# 0 is mipmap level, GL_RGBA is internal format, ix, iy is size, 0 is borderwidth,
# and (GL_RGBA, GL_UNSIGNED_BYTE, image) describe the external image data. [bruce 060212 comment]
## self._initTextureEnv() #bruce 060207 do this in draw method, not here
self.assy.o.gl_update()
return
def update_texture_rgb24(self, img_data, x, y, width, height, rowstride):
drawable = self.glarea.get_gl_drawable()
context = self.glarea.get_gl_context()
if not drawable.gl_begin(context):
raise Exception("** Cannot create OpenGL rendering context!")
assert self.textures is not None
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride/3)
if self.current_mode == GLClientWindow.MODE_YUV:
raise Exception("** YUV -> RGB mode change unimplemented!")
elif self.current_mode == GLClientWindow.MODE_UNINITIALIZED:
log("Creating new RGB texture")
w, h = self.get_size()
# First time we draw must be full image
assert w == width and h == height
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0)
self.current_mode = GLClientWindow.MODE_RGB
log("Updating RGB texture")
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, img_data)
drawable.gl_end()
self.render_image()
def _do_paint_rgb24(self, img_data, x, y, w, h, rowstride, options, callbacks):
log("do_paint_rgb24(%s bytes, %s, %s, %s, %s, %s, %s, %s)", len(img_data), x, y, w, h, rowstride, options, callbacks)
ww, wh = self.size
if x+w>ww or y+h>wh:
log("do_paint_rgb24: ignoring paint which would overflow the backing area")
return
drawable = self.gl_init()
if not drawable:
log("do_paint_rgb24: cannot paint yet..")
return
try:
#cleanup if we were doing yuv previously:
if self.pixel_format!=GLPixmapBacking.RGB24:
self.remove_shader()
self.pixel_format = GLPixmapBacking.RGB24
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride/3)
for texture in (GL_TEXTURE1, GL_TEXTURE2):
glActiveTexture(texture)
glDisable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, w, h, GL_RGB, GL_UNSIGNED_BYTE, img_data)
glBegin(GL_QUADS)
for rx,ry in ((x, y), (x, y+h), (x+w, y+h), (x+w, y)):
glTexCoord2i(rx, ry)
glVertex2i(rx, ry)
glEnd()
finally:
self.gl_end(drawable)
def _loadTexture(self):
"""
Load texture data from current image object
"""
ix, iy, image = self.image_obj.getTextureData()
# allocate texture object if never yet done [bruce 060207 revised all related code, to fix bug 1059]
if self.tex_name is None:
self.tex_name = glGenTextures(1)
# note: by experiment (iMac G5 Panther), this returns a single number (1L, 2L, ...), not a list or tuple,
# but for an argument >1 it returns a list of longs. We depend on this behavior here. [bruce 060207]
# initialize texture data
glBindTexture(GL_TEXTURE_2D, self.tex_name) # 2d texture (x and y size)
glPixelStorei(GL_UNPACK_ALIGNMENT,1)
self.have_mipmaps = False
if debug_pref("smoother tiny textures", Choice_boolean_False, prefs_key = True):
#bruce 060212 new feature; only takes effect when image is reloaded for some reason (like "load image" button)
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, ix, iy, GL_RGBA, GL_UNSIGNED_BYTE, image)
self.have_mipmaps = True
else:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA, GL_UNSIGNED_BYTE, image)
# 0 is mipmap level, GL_RGBA is internal format, ix, iy is size, 0 is borderwidth,
# and (GL_RGBA, GL_UNSIGNED_BYTE, image) describe the external image data. [bruce 060212 comment]
## self._initTextureEnv() #bruce 060207 do this in draw method, not here
self.assy.o.gl_update()
return
def create_float_texture(self, data, size, dimensions=2, components=3):
"""Bind texture with floating point vectors within.
dimensions: dimensionality of the texture
vector, matrix, 3D matrix.
components: dimensionality of texture element
number or 2D, 3D, 4D vector.
"""
texture_type = get_texture_type(dimensions)
texture_constructor = get_texture_constructor(dimensions)
internal_format = get_color_internal_format(components)
texture_format = get_color_format(components)
glBindTexture(texture_type, self.__textures_ids[len(self.__textures)])
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
# HACK: Python <3.5 doesn't allow to use *size
# within enumerable arguments
params = ([texture_type, 0, internal_format]
+ list(size) + [0, texture_format, GL_FLOAT, data.flatten()])
texture_constructor(*params)
glTexParameterf(texture_type, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(texture_type, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
self.__textures.append(dimensions)
def load_stack(self, stack):
print('stack shape', stack.shape)
s = np.array(stack, dtype=np.uint8, order='F')
print(s.shape)
w, h, d = s.shape
print('shape', s.shape)
stack_texture = glGenTextures(1)
print(stack_texture)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, stack_texture)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
# glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
# glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
# glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)
glTexImage3D(GL_TEXTURE_3D, 0, GL_R8, d, h, w, 0, GL_RED,
GL_UNSIGNED_BYTE, s)
print("made 3D texture")
return stack_texture, s.shape
def load_texture(self, img: Image) -> None:
img_data = np.fromstring(img.tobytes(), np.uint8)
width, height = img.size
self._texture = glGenTextures(1)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glBindTexture(GL_TEXTURE_2D, self._texture)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
mode = GL_RGBA
if img.mode == "RGB":
mode = GL_RGB
glTexImage2D(
GL_TEXTURE_2D,
0,
mode,
width,
height,
0,
mode,
GL_UNSIGNED_BYTE,
img_data,
)
glGenerateMipmap(GL_TEXTURE_2D)
def _do_paint_rgb24(self, img_data, x, y, width, height, rowstride,
options, callbacks):
debug(
"%s._do_paint_rgb24(x=%d, y=%d, width=%d, height=%d, rowstride=%d)",
self, x, y, width, height, rowstride)
drawable = self.gl_init()
if not drawable:
debug("%s._do_paint_rgb24(..) drawable is not set!", self)
return False
try:
self.set_rgb24_paint_state()
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a - 1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * 3) > a:
row_length = width + (rowstride - width * 3) / 3
self.gl_marker(
"RGB24 update at %d,%d, size %d,%d, stride is %d, row length %d, alignment %d"
% (x, y, width, height, rowstride, row_length, alignment))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 4, width, height, 0,
GL_RGB, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y + height)
glTexCoord2i(width, height)
glVertex2i(x + width, y + height)
glTexCoord2i(width, 0)
glVertex2i(x + width, y)
glEnd()
# Present update to screen
self.present_fbo(drawable)
# present_fbo has reset state already
finally:
drawable.gl_end()
return True
def update_planar_textures(self,
x,
y,
width,
height,
img,
pixel_format,
scaling=False):
assert self.textures is not None, "no OpenGL textures!"
log("%s.update_planar_textures%s", self,
(x, y, width, height, img, pixel_format))
divs = get_subsampling_divs(pixel_format)
if self.pixel_format is None or self.pixel_format != pixel_format or self.texture_size != (
width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
self.gl_marker("Creating new planar textures, pixel format %s" %
pixel_format)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if scaling or (div_w > 1 or div_h > 1):
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
width / div_w, height / div_h, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, None)
self.gl_marker("updating planar textures: %sx%s %s" %
(width, height, pixel_format))
rowstrides = img.get_rowstride()
img_data = img.get_pixels()
assert len(rowstrides) == 3 and len(img_data) == 3
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
pixel_data = img_data[index]
log("texture %s: div=%s, rowstride=%s, %sx%s, data=%s bytes",
index, divs[index], rowstrides[index], width / div_w,
height / div_h, len(pixel_data))
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width / div_w,
height / div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE,
pixel_data)
def __init__(self, wid, w, h, old_backing, mmap_enabled, mmap):
Backing.__init__(self, wid, mmap_enabled, mmap)
display_mode = (gtk.gdkgl.MODE_RGB | gtk.gdkgl.MODE_SINGLE)
# We use single buffer because double doesn't work, figure out why
try:
self.glconfig = gtk.gdkgl.Config(mode=display_mode)
except gtk.gdkgl.NoMatches:
raise SystemExit
self._backing = gtk.gdkgl.ext(
gdk.Pixmap(gdk.get_default_root_window(), w, h))
log.info("Creating GL pixmap size %d %d " % (w, h))
self.gldrawable = self._backing.set_gl_capability(self.glconfig)
log.info("drawable ok")
# Then create an indirect OpenGL rendering context.
self.glcontext = gtk.gdkgl.Context(self.gldrawable, direct=True)
log.info("context ok")
if not self.glcontext:
raise SystemExit, "** Cannot create OpenGL rendering context!"
print "OpenGL rendering context is created."
self.texture = None
self.textures = [0]
self.use_openGL_CSC = True
self.yuv420_shader = None
# OpenGL begin
if not self.gldrawable.gl_begin(self.glcontext):
return False
glViewport(0, 0, w, h)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0.0, w, h, 0.0, -1.0, 1.0)
glMatrixMode(GL_MODELVIEW)
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
self.gldrawable.gl_end()
cr = self._backing.cairo_create()
if old_backing is not None and old_backing._backing is not None:
# Really we should respect bit-gravity here but... meh.
cr.set_operator(cairo.OPERATOR_SOURCE)
cr.set_source_pixmap(old_backing._backing, 0, 0)
cr.paint()
old_w, old_h = old_backing._backing.get_size()
cr.move_to(old_w, 0)
cr.line_to(w, 0)
cr.line_to(w, h)
cr.line_to(0, h)
cr.line_to(0, old_h)
cr.line_to(old_w, old_h)
cr.close_path()
else:
cr.rectangle(0, 0, w, h)
cr.set_source_rgb(1, 1, 1)
cr.fill()
def update_texture_yuv(self, img_data, x, y, width, height, rowstrides, pixel_format):
assert x==0 and y==0
assert self.textures is not None, "no OpenGL textures!"
if self.pixel_format is None or self.pixel_format!=pixel_format or self.texture_size!=(width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
divs = get_subsampling_divs(pixel_format)
debug("GL creating new YUV textures for pixel format %s using divs=%s", pixel_format, divs)
self.gl_marker("Creating new YUV textures")
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if div_w > 1 or div_h > 1:
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/div_w, height/div_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0)
debug("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv_shader:
self.yuv_shader = [ 1 ]
glGenProgramsARB(1, self.yuv_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
err = glGetString(GL_PROGRAM_ERROR_STRING_ARB)
if err:
#FIXME: maybe we should do something else here?
log.error(err)
self.gl_marker("Updating YUV textures")
divs = get_subsampling_divs(pixel_format)
U_width = 0
U_height = 0
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div_w, height/div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[index])
if index == 1:
U_width = width/div_w
U_height = height/div_h
elif index == 2:
if width/div_w != U_width:
log.error("Width of V plane is %d, differs from width of corresponding U plane (%d), pixel_format is %d", width/div_w, U_width, pixel_format)
if height/div_h != U_height:
log.error("Height of V plane is %d, differs from height of corresponding U plane (%d)", height/div_h, U_height)
def _update_texture(self, w, h, pixels):
print("update_texture id=%s" % self.drawing_area.texture_id)
if self.drawing_area.texture_id is not None:
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.drawing_area.texture_id)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0,
GL_RGB, GL_UNSIGNED_BYTE, pixels)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
def main(path=None):
glutInit(sys.argv)
if sys.platform == 'darwin':
if not path:
path = dialog()
if not path:
sys.exit(0)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE)
glutInitWindowPosition(0, 0)
glutInitWindowSize(730, 650)
win = glutCreateWindow(b'MIDI Player')
(width, height, img) = read_image(join(dirname(__file__), 'mixer.ppm'))
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB,
GL_UNSIGNED_BYTE, img)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glMatrixMode(GL_TEXTURE)
glLoadIdentity()
glScale(1 / width, 1 / height, 1)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0, 730, 0, 650, 0, 1)
player = Player(win, path, width, height)
glutDisplayFunc(player.display_func)
glutKeyboardFunc(player.keyboard_func)
glutMouseFunc(player.mouse_func)
glutMotionFunc(player.motion_func)
glutIdleFunc(player.process_events)
submenus = []
for instrument in range(128):
if instrument % 8 == 0:
submenus.append([
families[instrument // 8],
glutCreateMenu(player.change_instrument)
])
glutAddMenuEntry(instruments[instrument].encode('ascii'), instrument)
glutCreateMenu(player.change_instrument)
for family, submenu in submenus:
glutAddSubMenu(family.encode('ascii'), submenu)
glutAttachMenu(GLUT_RIGHT_BUTTON)
glutMainLoop()
def main(path=None):
glutInit(sys.argv)
if sys.platform == 'darwin':
if not path:
path = dialog()
if not path:
sys.exit(0)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE)
glutInitWindowPosition(0, 0)
glutInitWindowSize(730, 650)
win = glutCreateWindow(b'MIDI Player')
(width, height, img) = read_image('mixer.ppm')
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
rbo = c_uint(int(glGenRenderbuffersEXT(1)))
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo)
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, width, height)
fbo = c_uint(int(glGenFramebuffersEXT(1)))
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo)
glFramebufferRenderbufferEXT(GL_READ_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, rbo)
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo)
glClear(GL_COLOR_BUFFER_BIT)
glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, img)
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0)
player = Player(win, path, width, height)
glutDisplayFunc(player.display_func)
glutKeyboardFunc(player.keyboard_func)
glutMouseFunc(player.mouse_func)
glutMotionFunc(player.motion_func)
glutIdleFunc(player.process_events)
submenus = []
for instrument in range(128):
if instrument % 8 == 0:
submenus.append([families[instrument // 8],
glutCreateMenu(player.change_instrument)])
glutAddMenuEntry(instruments[instrument].encode('ascii'), instrument)
glutCreateMenu(player.change_instrument)
for family, submenu in submenus:
glutAddSubMenu(family.encode('ascii'), submenu)
glutAttachMenu(GLUT_RIGHT_BUTTON)
glutMainLoop()
def set_texture(m):
texture_data = np.array(m.texture_image, dtype='int8')
m.textureID = glGenTextures(1)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glBindTexture(GL_TEXTURE_2D, m.textureID)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texture_data.shape[1],
texture_data.shape[0], 0, GL_BGR, GL_UNSIGNED_BYTE,
texture_data.flatten())
glHint(GL_GENERATE_MIPMAP_HINT,
GL_NICEST) # must be GL_FASTEST, GL_NICEST or GL_DONT_CARE
glGenerateMipmap(GL_TEXTURE_2D)
def main(path=None):
glutInit(sys.argv)
if sys.platform == 'darwin':
if not path:
path = dialog()
if not path:
sys.exit(0)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE)
glutInitWindowPosition(0, 0)
glutInitWindowSize(730, 650)
win = glutCreateWindow(b'MIDI Player')
(width, height, img) = read_image(join(dirname(__file__), 'mixer.ppm'))
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0,
GL_RGB, GL_UNSIGNED_BYTE, img)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glMatrixMode(GL_TEXTURE)
glLoadIdentity()
glScale(1/width, 1/height, 1)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0, 730, 0, 650, 0, 1)
player = Player(win, path, width, height)
glutDisplayFunc(player.display_func)
glutKeyboardFunc(player.keyboard_func)
glutMouseFunc(player.mouse_func)
glutMotionFunc(player.motion_func)
glutIdleFunc(player.process_events)
submenus = []
for instrument in range(128):
if instrument % 8 == 0:
submenus.append([families[instrument // 8],
glutCreateMenu(player.change_instrument)])
glutAddMenuEntry(instruments[instrument].encode('ascii'), instrument)
glutCreateMenu(player.change_instrument)
for family, submenu in submenus:
glutAddSubMenu(family.encode('ascii'), submenu)
glutAttachMenu(GLUT_RIGHT_BUTTON)
glutMainLoop()
def _do_paint_rgb24(self, img_data, x, y, width, height, rowstride, options, callbacks):
debug("%s._do_paint_rgb24(x=%d, y=%d, width=%d, height=%d, rowstride=%d)", self, x, y, width, height, rowstride)
drawable = self.gl_init()
if not drawable:
debug("%s._do_paint_rgb24(..) drawable is not set!", self)
return False
try:
self.set_rgb24_paint_state()
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a-1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * 3) > a:
row_length = width + (rowstride - width * 3) / 3
self.gl_marker("RGB24 update at %d,%d, size %d,%d, stride is %d, row length %d, alignment %d" % (x, y, width, height, rowstride, row_length, alignment))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 4, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y+height)
glTexCoord2i(width, height)
glVertex2i(x+width, y+height)
glTexCoord2i(width, 0)
glVertex2i(x+width, y)
glEnd()
# Present update to screen
self.present_fbo(drawable)
# present_fbo has reset state already
finally:
drawable.gl_end()
return True
def _update_texture(self, w, h, pixels):
print("update_texture id=%s" % self.drawing_area.texture_id)
if self.drawing_area.texture_id is not None:
glBindTexture(GL_TEXTURE_RECTANGLE_ARB,
self.drawing_area.texture_id)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0, GL_RGB,
GL_UNSIGNED_BYTE, pixels)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
def update_texture_yuv(self, img_data, x, y, width, height, rowstrides, pixel_format):
window_width, window_height = self.size
assert self.textures is not None, "no OpenGL textures!"
if self.pixel_format is None or self.pixel_format!=pixel_format:
self.pixel_format = pixel_format
divs = self.get_subsampling_divs(pixel_format)
log("GL creating new YUV textures for pixel format %s using divs=%s", pixel_format, divs)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if div>1:
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width/div, window_height/div, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0)
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv_shader:
self.yuv_shader = [ 1 ]
glGenProgramsARB(1, self.yuv_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
err = glGetString(GL_PROGRAM_ERROR_STRING_ARB)
if err:
#FIXME: maybe we should do something else here?
log.error(err)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
divs = self.get_subsampling_divs(pixel_format)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div, height/div, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[index])
glFlush()
def update_planar_textures(self, x, y, width, height, img, pixel_format, scaling=False):
assert x==0 and y==0
assert self.textures is not None, "no OpenGL textures!"
debug("%s.update_planar_textures%s", self, (x, y, width, height, img, pixel_format))
divs = get_subsampling_divs(pixel_format)
if self.pixel_format is None or self.pixel_format!=pixel_format or self.texture_size!=(width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
self.gl_marker("Creating new planar textures, pixel format %s" % pixel_format)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if scaling or (div_w > 1 or div_h > 1):
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/div_w, height/div_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, None)
self.gl_marker("updating planar textures: %sx%s %s" % (width, height, pixel_format))
U_width = 0
U_height = 0
rowstrides = img.get_rowstride()
img_data = img.get_pixels()
assert len(rowstrides)==3
assert len(img_data)==3
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
pixel_data = img_data[index][:]
debug("texture %s: div=%s, rowstride=%s, %sx%s, data=%s bytes", index, divs[index], rowstrides[index], width/div_w, height/div_h, len(pixel_data))
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/div_w, height/div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixel_data)
if index == 1:
U_width = width/div_w
U_height = height/div_h
elif index == 2:
if width/div_w != U_width:
log.error("Width of V plane is %d, differs from width of corresponding U plane (%d), pixel_format is %d", width/div_w, U_width, pixel_format)
if height/div_h != U_height:
log.error("Height of V plane is %d, differs from height of corresponding U plane (%d), pixel_format is %d", height/div_h, U_height, pixel_format)
def paint_rgb24(self, img_data, x, y, width, height, rowstride):
# OpenGL begin
if not self.gldrawable.gl_begin(self.glcontext):
log.error("OUCH")
return False
# Upload texture
if not self.texture:
self.texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.texture)
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride / 3)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, width, height, 0,
GL_RGB, GL_UNSIGNED_BYTE, img_data)
vtxarrays = 1
if vtxarrays == 1:
texcoords = [[0, 0], [0, height], [width, height], [width, 0]]
vtxcoords = texcoords
glVertexPointeri(vtxcoords)
glTexCoordPointeri(texcoords)
glDrawArrays(GL_QUADS, 0, 4)
else:
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(0, 0)
glTexCoord2i(0, height)
glVertex2i(0, height)
glTexCoord2i(width, height)
glVertex2i(width, height)
glTexCoord2i(width, 0)
glVertex2i(width, 0)
glEnd()
# OpenGL end
#self.gldrawable.swap_buffers()
# self.gldrawable.swap_buffers()
glFinish()
self.gldrawable.gl_end()
def paint_rgb24(self, img_data, x, y, width, height, rowstride):
# OpenGL begin
if not self.gldrawable.gl_begin(self.glcontext):
log.error("OUCH")
return False
# Upload texture
if not self.texture:
self.texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.texture)
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride/3)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, img_data);
vtxarrays=1
if vtxarrays == 1:
texcoords = [ [ 0, 0 ],
[ 0, height],
[ width, height],
[ width, 0] ]
vtxcoords = texcoords
glVertexPointeri(vtxcoords)
glTexCoordPointeri(texcoords)
glDrawArrays(GL_QUADS, 0, 4);
else:
glBegin(GL_QUADS);
glTexCoord2i(0, 0);
glVertex2i(0, 0);
glTexCoord2i(0, height);
glVertex2i(0, height);
glTexCoord2i(width, height);
glVertex2i(width, height);
glTexCoord2i(width, 0);
glVertex2i(width, 0);
glEnd()
# OpenGL end
#self.gldrawable.swap_buffers()
# self.gldrawable.swap_buffers()
glFinish()
self.gldrawable.gl_end()
def config_texture(self):
w, h = self.size
pixels = "\0" * w * h * 4
# Create Texture
print("glBindTexture(GL_TEXTURE_RECTANGLE_ARB) size=%s" % str(self.size))
self.texture_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.texture_id)
print("done")
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0,
GL_RGB, GL_UNSIGNED_BYTE, pixels)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
def read_texture(filename):
image_data = 0
is_hdr = False
size = ()
if OpenEXR.isOpenExrFile(filename):
is_hdr = True
img = OpenEXR.InputFile(filename)
FLOAT = Imath.PixelType(Imath.PixelType.FLOAT)
(r, g, b) = ( img.channel(chan, FLOAT) for chan in ('R', 'G', 'B'))
dw = img.header()['dataWindow']
size = (dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1)
r_data = np.fromstring(r, dtype=np.float32)
g_data = np.fromstring(g, dtype=np.float32)
b_data = np.fromstring(b, dtype=np.float32)
image_data = np.dstack((r_data, g_data, b_data))
img.close()
else:
try:
image = Image.open(filename)
except IOError as ex:
print('IOError: failed to open texture file %s' % filename)
return -1
print('opened file: size=', image.size, 'format=', image.format)
image_data = np.array(list(image.getdata()), np.uint8)
size = image.size
image.close()
texture_id= glGenTextures(1)
glPixelStorei(GL_UNPACK_ALIGNMENT, 4)
glBindTexture(GL_TEXTURE_2D, texture_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
if is_hdr:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, size[0], size[1], 0, GL_RGB, GL_FLOAT, image_data)
else:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size[0], size[1], 0, GL_RGB, GL_UNSIGNED_BYTE, image_data)
return texture_id
def set_alignment(self, width, rowstride, pixel_format):
bytes_per_pixel = len(pixel_format) #ie: BGRX -> 4
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a-1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (rowstride - width * bytes_per_pixel) // bytes_per_pixel
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
self.gl_marker("set_alignment%s GL_UNPACK_ROW_LENGTH=%i, GL_UNPACK_ALIGNMENT=%i", (width, rowstride, pixel_format), row_length, alignment)
def get_textureid_with_text(text, fgcolor, bgcolor):
if not hasattr(get_textureid_with_text, 'cache'):
get_textureid_with_text.cache = {}
import zlib
uid = str(zlib.crc32(text)) + str(zlib.crc32(np.array(fgcolor))) + str(
zlib.crc32(np.array(bgcolor)))
if uid not in get_textureid_with_text.cache:
from PIL import ImageFont
from PIL import Image
from PIL import ImageDraw
font = ImageFont.truetype(
os.path.join(os.path.dirname(__file__), "ressources", "Arial.ttf"),
100)
imsize = (128, 128)
bgarray = np.asarray(np.zeros((imsize[0], imsize[1], 3)), np.uint8)
bgarray[:, :, 0] += bgcolor[0]
bgarray[:, :, 1] += bgcolor[1]
bgarray[:, :, 2] += bgcolor[2]
img = Image.fromarray(bgarray)
draw = ImageDraw.Draw(img)
w, h = draw.textsize(text, font=font)
text_pos = ((imsize[0] - w) / 2, (imsize[1] - h) / 2)
draw.text(text_pos,
text,
fill=tuple(np.asarray(fgcolor, np.uint8)),
font=font)
texture_data = np.asarray(
np.array(img.getdata()).reshape(img.size[0], img.size[1], 3) * 255,
np.uint8)
textureID = glGenTextures(1)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glBindTexture(GL_TEXTURE_2D, textureID)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texture_data.shape[1],
texture_data.shape[0], 0, GL_BGR, GL_UNSIGNED_BYTE,
texture_data.flatten())
glHint(GL_GENERATE_MIPMAP_HINT,
GL_NICEST) # must be GL_FASTEST, GL_NICEST or GL_DONT_CARE
glGenerateMipmap(GL_TEXTURE_2D)
get_textureid_with_text.cache[uid] = textureID
return get_textureid_with_text.cache[uid]
def _create_texture(self):
pixels = "\0" * 320 * 240 * 4
w = 320
h = 240
# Create Texture
tex_id = glGenTextures(1)
print("glBindTexture(GL_TEXTURE_RECTANGLE_ARB)")
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex_id)
print("done")
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0,
GL_RGB, GL_UNSIGNED_BYTE, pixels)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
self.texture_id = tex_id
def create_float_texture(self, data, size, dimensions=2, components=3):
"""Bind texture with floating point vectors within.
dimensions: dimensionality of the texture
vector, matrix, 3D matrix.
components: dimensionality of texture element
number or 2D, 3D, 4D vector.
"""
if dimensions == 1:
texture_type = GL_TEXTURE_1D
texture_store = glTexImage1D
elif dimensions == 2:
texture_type = GL_TEXTURE_2D
texture_store = glTexImage2D
elif dimensions == 3:
texture_type = GL_TEXTURE_3D
texture_store = glTexImage3D
if components == 1:
internal_format = GL_R32F
texture_format = GL_RED
if components == 2:
internal_format = GL_RG32F
texture_format = GL_RG
if components == 3:
internal_format = GL_RGB32F
texture_format = GL_RGB
if components == 4:
internal_format = GL_RGBA32F
texture_format = GL_RGBA
glBindTexture(texture_type, self.__textures_ids[len(self.__textures)])
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
# HACK: Python <3.5 doesn't allow to use *size
# within enumerable arguments
params = ([texture_type, 0, internal_format] + list(size) +
[0, texture_format, GL_FLOAT,
data.flatten()])
texture_store(*params)
glTexParameterf(texture_type, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(texture_type, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
self.__textures.append(dimensions)
def config_texture(self):
w, h = self.size
pixels = "\0" * w * h * 4
# Create Texture
print("glBindTexture(GL_TEXTURE_RECTANGLE_ARB) size=%s" %
str(self.size))
self.texture_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.texture_id)
print("done")
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0, GL_RGB,
GL_UNSIGNED_BYTE, pixels)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
def from_matrix(cls, matrix):
"""Creates a texture from given matrix file.
:param matrix: The matrix.
:type matrix: list
:returns: The texture instance.
:rtype: :class:`renderer.Texture`
"""
w, h = len(matrix[0]), len(matrix)
grid = bytes(chain.from_iterable(reversed(matrix)))
tex = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, tex)
# This code is necessary to handle non-power-of-two textures with small
# sizes.
# TODO: refactor this
param_ids = [
GL_UNPACK_ALIGNMENT,
GL_UNPACK_ROW_LENGTH,
GL_UNPACK_SKIP_ROWS,
GL_UNPACK_SKIP_PIXELS,
]
old_params = {
p: glGetInteger(p)
for p in param_ids
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0)
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0)
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0)
glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, w, h)
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RED, GL_UNSIGNED_BYTE, grid)
for p, v in old_params.items():
glPixelStorei(p, v)
glBindTexture(GL_TEXTURE_2D, 0)
return Texture(tex, w, h, GL_TEXTURE_2D)
def blit_buffer(self,
buffer,
size=None,
mode='RGB',
format=None,
pos=(0, 0),
buffertype=GL_UNSIGNED_BYTE):
'''Blit a buffer into a texture.
:Parameters:
`buffer` : str
Image data
`size` : tuple, default to texture size
Size of the image (width, height)
`mode` : str, default to 'RGB'
Image mode, can be one of RGB, RGBA, BGR, BGRA
`format` : glconst, default to None
if format is passed, it will be used instead of mode
`pos` : tuple, default to (0, 0)
Position to blit in the texture
`buffertype` : glglconst, default to GL_UNSIGNED_BYTE
Type of the data buffer
'''
if size is None:
size = self.size
if format is None:
format = self.mode_to_gl_format(mode)
target = self.target
glBindTexture(target, self.id)
glEnable(target)
# activate 1 alignement, of window failed on updating weird size
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
# need conversion ?
pdata, format = self._convert_buffer(buffer, format)
# transfer the new part of texture
glTexSubImage2D(target, 0, pos[0], pos[1], size[0], size[1], format,
buffertype, pdata)
glFlush()
glDisable(target)
def _create_texture(self):
pixels = "\0" * 320 * 240 * 4
w = 320
h = 240
# Create Texture
tex_id = glGenTextures(1)
print("glBindTexture(GL_TEXTURE_RECTANGLE_ARB)")
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex_id)
print("done")
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB, w, h, 0, GL_RGB,
GL_UNSIGNED_BYTE, pixels)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
self.texture_id = tex_id
def update_planar_textures(self, x, y, width, height, img, pixel_format, scaling=False):
assert self.textures is not None, "no OpenGL textures!"
log("%s.update_planar_textures%s", self, (x, y, width, height, img, pixel_format))
divs = get_subsampling_divs(pixel_format)
if self.pixel_format is None or self.pixel_format!=pixel_format or self.texture_size!=(width, height):
self.pixel_format = pixel_format
self.texture_size = (width, height)
self.gl_marker("Creating new planar textures, pixel format %s", pixel_format)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if scaling or (div_w > 1 or div_h > 1):
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
set_texture_level()
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width//div_w, height//div_h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, None)
self.gl_marker("updating planar textures: %sx%s %s", width, height, pixel_format)
rowstrides = img.get_rowstride()
img_data = img.get_pixels()
assert len(rowstrides)==3 and len(img_data)==3
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1), (GL_TEXTURE2, 2)):
(div_w, div_h) = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
upload, pixel_data = self.pixels_for_upload(img_data[index])
log("texture %s: div=%s, rowstride=%s, %sx%s, data=%s bytes, upload=%s", index, divs[index], rowstrides[index], width//div_w, height//div_h, len(pixel_data), upload)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 0)
try:
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAX_LEVEL, 0)
except:
pass
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width//div_w, height//div_h, GL_LUMINANCE, GL_UNSIGNED_BYTE, pixel_data)
def __init__(self, imagefile, points=[], alpha=1.0):
super(ImageActor, self).__init__()
im = Image.open(imagefile)
# Try to open the image file
try:
ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBA", 0, -1)
except SystemError:
ix, iy, image = im.size[0], im.size[1], im.tostring("raw", "RGBX", 0, -1)
# get a texture buffer
glActiveTexture(GL_TEXTURE0)
self.texid = glGenTextures(1)
# Bind the texture
glBindTexture(GL_TEXTURE_2D, self.texid)
glPixelStorei(GL_UNPACK_ALIGNMENT,1)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
# Upload the image
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ix, iy, 0, GL_RGBA, GL_UNSIGNED_BYTE, image)
# Generate the points for the billboard
if points == []:
points = [Point(0,0), Point(ix,0), Point(ix,-iy), Point(0,-iy)]
if len(points) != 4:
raise Exception("Image needs 4 points, %d provided" % len(points))
# Generate the UV map
uv = [Point(0,1), Point(1,1), Point(1,0), Point(0,0)]
a = []
for i in [0,1,2,0,2,3]:
point = points[i]
tex = uv[i]
a.extend([point.x, point.y, tex.x, tex.y])
# Assign the VBO
super(ImageActor, self)._assignVBO(a)
self.alpha = float(alpha)
def loadTexture(image_obj, tex_name=0): #e arg want_mipmaps
"""
Load texture data from current image object;
return have_mipmaps, tex_name
(also leave that texture bound, BTW)
"""
# note: some of this code has been copied into exprs/images.py, class
# texture_holder [bruce 061125]
ix, iy, image = image_obj.getTextureData()
# allocate texture object if necessary
if not tex_name:
tex_name = glGenTextures(1)
# It's deprecated to let this happen much. [070308]
print "debug fyi: texture_helpers.loadTexture allocated tex_name %r" %\
(tex_name,)
# note: by experiment (iMac G5 Panther), this returns a single number
# (1L, 2L, ...), not a list or tuple, but for an argument >1 it returns
# a list of longs. We depend on this behavior here. [bruce 060207]
tex_name = int(tex_name) # make sure it worked as expected
assert tex_name != 0
# initialize texture data
glBindTexture(GL_TEXTURE_2D, tex_name) # 2d texture (x and y size)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1) ###k what's this?
have_mipmaps = False
##want_mipmaps = debug_pref("smoother tiny textures",
## Choice_boolean_False, prefs_key = True)
want_mipmaps = True
if want_mipmaps:
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, ix, iy, GL_RGBA,
GL_UNSIGNED_BYTE, image)
have_mipmaps = True
else:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA,
GL_UNSIGNED_BYTE, image)
# 0 is mipmap level, GL_RGBA is internal format, ix, iy is size, 0
# is borderwidth, and (GL_RGBA, GL_UNSIGNED_BYTE, image) describe
# the external image data. [bruce 060212 comment]
return have_mipmaps, tex_name
def loadTexture(image_obj, tex_name = 0): #e arg want_mipmaps
"""
Load texture data from current image object;
return have_mipmaps, tex_name
(also leave that texture bound, BTW)
"""
# note: some of this code has been copied into exprs/images.py, class
# texture_holder [bruce 061125]
ix, iy, image = image_obj.getTextureData()
# allocate texture object if necessary
if not tex_name:
tex_name = glGenTextures(1)
# It's deprecated to let this happen much. [070308]
print "debug fyi: texture_helpers.loadTexture allocated tex_name %r" %\
(tex_name,)
# note: by experiment (iMac G5 Panther), this returns a single number
# (1L, 2L, ...), not a list or tuple, but for an argument >1 it returns
# a list of longs. We depend on this behavior here. [bruce 060207]
tex_name = int(tex_name) # make sure it worked as expected
assert tex_name != 0
# initialize texture data
glBindTexture(GL_TEXTURE_2D, tex_name) # 2d texture (x and y size)
glPixelStorei(GL_UNPACK_ALIGNMENT,1) ###k what's this?
have_mipmaps = False
##want_mipmaps = debug_pref("smoother tiny textures",
## Choice_boolean_False, prefs_key = True)
want_mipmaps = True
if want_mipmaps:
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, ix, iy, GL_RGBA,
GL_UNSIGNED_BYTE, image)
have_mipmaps = True
else:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA,
GL_UNSIGNED_BYTE, image)
# 0 is mipmap level, GL_RGBA is internal format, ix, iy is size, 0
# is borderwidth, and (GL_RGBA, GL_UNSIGNED_BYTE, image) describe
# the external image data. [bruce 060212 comment]
return have_mipmaps, tex_name
def load_texture(image):
image = limit_pixels_count(image, args.pixels_limit)
width, height = image.size
image = image.tostring("raw", "RGBX", 0, -1)
# Create Texture
_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, _id)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, image)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
return _id
def _do_paint_rgb24(self, img_data, x, y, w, h, rowstride, options,
callbacks):
log("do_paint_rgb24(%s bytes, %s, %s, %s, %s, %s, %s, %s)",
len(img_data), x, y, w, h, rowstride, options, callbacks)
ww, wh = self.size
if x + w > ww or y + h > wh:
log("do_paint_rgb24: ignoring paint which would overflow the backing area"
)
return
drawable = self.gl_init()
if not drawable:
log("do_paint_rgb24: cannot paint yet..")
return
try:
#cleanup if we were doing yuv previously:
if self.pixel_format != GLPixmapBacking.RGB24:
self.remove_shader()
self.pixel_format = GLPixmapBacking.RGB24
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstride / 3)
for texture in (GL_TEXTURE1, GL_TEXTURE2):
glActiveTexture(texture)
glDisable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, w, h, GL_RGB,
GL_UNSIGNED_BYTE, img_data)
glBegin(GL_QUADS)
for rx, ry in ((x, y), (x, y + h), (x + w, y + h), (x + w, y)):
glTexCoord2i(rx, ry)
glVertex2i(rx, ry)
glEnd()
finally:
self.gl_end(drawable)
def __init__(self, face: freetype.Face, char: str) -> None:
if face.load_char(char, freetype.FT_LOAD_RENDER):
raise RuntimeError('failed to load char \'%s\'' % char)
glyph = face.glyph
bitmap = glyph.bitmap
assert bitmap.pixel_mode == freetype.FT_PIXEL_MODE_GRAY, \
"We haven't implemented support for other pixel modes"
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT)
glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE)
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
self._texture_id = glGenTextures(1)
self._width = bitmap.width
self._height = bitmap.rows
self._descender = glyph.bitmap_top - self._height
self._bearing_x = glyph.bitmap_left
self._advance = numpy.array(
[face.glyph.advance.x / 64.0, face.glyph.advance.y / 64.0])
glBindTexture(GL_TEXTURE_2D, self._texture_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
data = numpy.array(bitmap.buffer,
numpy.ubyte).reshape(self._height, self._width)
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, self._width, self._height, 0,
GL_ALPHA, GL_UNSIGNED_BYTE, numpy.flipud(data))
glPopClientAttrib()
def load_texture(image):
image = limit_pixels_count(image, args.pixels_limit)
width, height = image.size
image = image.tostring("raw", "RGBX", 0, -1)
# Create Texture
_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, _id)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(
GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image
)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)
return _id
def blit_buffer(self, buffer, size=None, mode='RGB', format=None,
pos=(0, 0), buffertype=GL_UNSIGNED_BYTE):
'''Blit a buffer into a texture.
:Parameters:
`buffer` : str
Image data
`size` : tuple, default to texture size
Size of the image (width, height)
`mode` : str, default to 'RGB'
Image mode, can be one of RGB, RGBA, BGR, BGRA
`format` : glconst, default to None
if format is passed, it will be used instead of mode
`pos` : tuple, default to (0, 0)
Position to blit in the texture
`buffertype` : glglconst, default to GL_UNSIGNED_BYTE
Type of the data buffer
'''
if size is None:
size = self.size
if format is None:
format = self.mode_to_gl_format(mode)
target = self.target
glBindTexture(target, self.id)
glEnable(target)
# activate 1 alignement, of window failed on updating weird size
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
# need conversion ?
pdata, format = self._convert_buffer(buffer, format)
# transfer the new part of texture
glTexSubImage2D(target, 0, pos[0], pos[1],
size[0], size[1], format,
buffertype, pdata)
glFlush()
glDisable(target)
def __init__(self, stack, spacing):
s = np.array(stack, dtype=np.uint8, order='F')
w, h, d = s.shape
stack_texture = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_3D, stack_texture)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glTexParameter(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)
glTexImage3D(GL_TEXTURE_3D, 0, GL_R8, d, h, w, 0, GL_RED,
GL_UNSIGNED_BYTE, s)
self.stack_texture = stack_texture
self.shape = s.shape
def refresh(self):
img = self.textureData
mi, ma = self.histogramScale
pic_ny, pic_nx = img.shape
if img.dtype.type in (numpy.float64, numpy.int32, numpy.uint32):
data = img.astype(numpy.float32)
imgString = data.tostring()
imgType = numpy.float32
else:
imgString = img.tostring()
imgType = img.dtype.type
# maxUShort: value that represents "maximum color" - i.e. white
if img.dtype.type == numpy.uint16:
maxUShort = (1 << 16) - 1
elif img.dtype.type == numpy.int16:
maxUShort = (1 << 15) - 1
elif img.dtype.type == numpy.uint8:
maxUShort = (1 << 8) - 1
else:
maxUShort = 1
mmrange = float(ma) - float(mi)
fBias = -float(mi) / mmrange
f = maxUShort / mmrange
glBindTexture(GL_TEXTURE_2D, self.texture)
glPixelTransferf(GL_RED_SCALE, f)
glPixelTransferf(GL_GREEN_SCALE, f)
glPixelTransferf(GL_BLUE_SCALE, f)
glPixelTransferf(GL_RED_BIAS, fBias)
glPixelTransferf(GL_GREEN_BIAS, fBias)
glPixelTransferf(GL_BLUE_BIAS, fBias)
glPixelTransferi(GL_MAP_COLOR, False)
if img.dtype.type in (numpy.float64, numpy.int32, numpy.uint32,
numpy.complex64, numpy.complex128):
itSize = 4
glPixelStorei(GL_UNPACK_SWAP_BYTES,
False) # create native float32 copy - see below
else:
itSize = img.itemsize
glPixelStorei(GL_UNPACK_SWAP_BYTES, not img.dtype.isnative)
glPixelStorei(GL_UNPACK_ALIGNMENT, itSize)
if imgType not in dtypeToGlTypeMap:
raise ValueError("Unsupported data mode %s" % str(imgType))
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, pic_nx, pic_ny, GL_LUMINANCE,
dtypeToGlTypeMap[imgType], imgString)
def _do_paint_rgb(self, bpp, img_data, x, y, width, height, rowstride, options):
log("%s._do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d, options=%s)", self, bpp, len(img_data), x, y, width, height, rowstride, options)
context = self.gl_context()
if not context:
log("%s._do_paint_rgb(..) no context!", self)
return False
#TODO: move this code up to the decode thread section
upload, img_data = self.pixels_for_upload(img_data)
with context:
self.gl_init()
self.set_rgb_paint_state()
rgb_format = options.get(b"rgb_format")
if not rgb_format:
#Older servers may not tell us the pixel format, so we must infer it:
if bpp==24:
rgb_format = "RGB"
else:
assert bpp==32
rgb_format = "RGBA"
else:
rgb_format = rgb_format.decode()
#convert it to a GL constant:
pformat = PIXEL_FORMAT_TO_CONSTANT.get(rgb_format)
assert pformat is not None, "could not find pixel format for %s (bpp=%s)" % (rgb_format, bpp)
bytes_per_pixel = len(rgb_format) #ie: BGRX -> 4
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a-1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (rowstride - width * bytes_per_pixel) // bytes_per_pixel
self.gl_marker("%s %sbpp update at (%d,%d) size %dx%d (%s bytes), stride=%d, row length %d, alignment %d, using GL %s format=%s",
rgb_format, bpp, x, y, width, height, len(img_data), rowstride, row_length, alignment, upload, CONSTANT_TO_PIXEL_FORMAT.get(pformat))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 0)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAX_LEVEL, 0)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, self.texture_pixel_format, width, height, 0, pformat, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y+height)
glTexCoord2i(width, height)
glVertex2i(x+width, y+height)
glTexCoord2i(width, 0)
glVertex2i(x+width, y)
glEnd()
self.paint_box(options.get("encoding"), options.get("delta", -1)>=0, x, y, width, height)
# Present update to screen
self.present_fbo(x, y, width, height, options.get("flush", 0))
# present_fbo has reset state already
return True
def paint_yuv420(self, img_data, x, y, width, height, rowstrides):
#import time
#before=time.time()
# OpenGL begin
if not self.gldrawable.gl_begin(self.glcontext):
log.error("OUCH")
return False
# Upload texture
if self.textures[0] == 0:
self.textures = glGenTextures(3)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [ 1 ]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
# The following fragprog is:
# * MIT X11 license, Copyright (c) 2007 by:
# * Michael Dominic K. <*****@*****.**>
#http://www.mdk.org.pl/2007/11/17/gl-colorspace-conversions
prog = """!!ARBfp1.0
# cgc version 3.1.0010, build date Feb 10 2012
# command line args: -profile arbfp1
# source file: yuv.cg
#vendor NVIDIA Corporation
#version 3.1.0.10
#profile arbfp1
#program main
#semantic main.IN
#var float2 IN.texcoord1 : $vin.TEXCOORD0 : TEX0 : 0 : 1
#var float2 IN.texcoord2 : $vin.TEXCOORD1 : TEX1 : 0 : 1
#var float2 IN.texcoord3 : $vin.TEXCOORD2 : TEX2 : 0 : 1
#var samplerRECT IN.texture1 : TEXUNIT0 : texunit 0 : 0 : 1
#var samplerRECT IN.texture2 : TEXUNIT1 : texunit 1 : 0 : 1
#var samplerRECT IN.texture3 : TEXUNIT2 : texunit 2 : 0 : 1
#var float4 IN.color : $vin.COLOR0 : COL0 : 0 : 1
#var float4 main.color : $vout.COLOR0 : COL : -1 : 1
#const c[0] = 1.1643835 2.017231 0 0.5
#const c[1] = 0.0625 1.1643835 -0.3917616 -0.81296802
#const c[2] = 1.1643835 0 1.5960271
PARAM c[3] = { { 1.1643835, 2.017231, 0, 0.5 },
{ 0.0625, 1.1643835, -0.3917616, -0.81296802 },
{ 1.1643835, 0, 1.5960271 } };
TEMP R0;
TEMP R1;
TEX R0.x, fragment.texcoord[2], texture[2], RECT;
ADD R1.z, R0.x, -c[0].w;
TEX R1.x, fragment.texcoord[0], texture[0], RECT;
TEX R0.x, fragment.texcoord[1], texture[1], RECT;
ADD R1.x, R1, -c[1];
ADD R1.y, R0.x, -c[0].w;
DP3 result.color.z, R1, c[0];
DP3 result.color.y, R1, c[1].yzww;
DP3 result.color.x, R1, c[2];
MOV result.color.w, fragment.color.primary;
END
# 10 instructions, 2 R-regs
"""
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glEnable(GL_FRAGMENT_PROGRAM_ARB)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/2, height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width/2, height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[2]);
vtxarrays=0
if vtxarrays == 1:
texcoords = [ [ 0, 0 ],
[ 0, height],
[ width, height],
[ width, 0] ]
vtxcoords = texcoords
texcoords_half = [ [ 0, 0 ],
[ 0, height/2],
[ width/2, height/2],
[ width/2, 0] ]
glVertexPointeri(vtxcoords)
glActiveTexture(GL_TEXTURE0);
glClientActiveTexture(GL_TEXTURE0)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointeri(texcoords)
glActiveTexture(GL_TEXTURE1);
glClientActiveTexture(GL_TEXTURE1)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointeri(texcoords_half)
glActiveTexture(GL_TEXTURE2);
glClientActiveTexture(GL_TEXTURE2)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointeri(texcoords_half)
glDrawArrays(GL_QUADS, 0, 4);
else:
glBegin(GL_QUADS);
glMultiTexCoord2i(GL_TEXTURE0, 0, 0);
glMultiTexCoord2i(GL_TEXTURE1, 0, 0);
glMultiTexCoord2i(GL_TEXTURE2, 0, 0);
glVertex2i(0, 0);
glMultiTexCoord2i(GL_TEXTURE0, 0, height);
glMultiTexCoord2i(GL_TEXTURE1, 0, height/2);
glMultiTexCoord2i(GL_TEXTURE2, 0, height/2);
glVertex2i(0, height);
glMultiTexCoord2i(GL_TEXTURE0, width, height);
glMultiTexCoord2i(GL_TEXTURE1, width/2, height/2);
glMultiTexCoord2i(GL_TEXTURE2, width/2, height/2);
glVertex2i(width, height);
glMultiTexCoord2i(GL_TEXTURE0, width, 0);
glMultiTexCoord2i(GL_TEXTURE1, width/2, 0);
glMultiTexCoord2i(GL_TEXTURE2, width/2, 0);
glVertex2i(width, 0);
glEnd()
# OpenGL end
#self.gldrawable.swap_buffers()
# self.gldrawable.swap_buffers()
glFinish()
self.gldrawable.gl_end()
def paint_yuv420(self, img_data, x, y, width, height, rowstrides):
#import time
#before=time.time()
# OpenGL begin
if not self.gldrawable.gl_begin(self.glcontext):
log.error("OUCH")
return False
# Upload texture
if self.textures[0] == 0:
self.textures = glGenTextures(3)
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [1]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
# The following fragprog is:
# * MIT X11 license, Copyright (c) 2007 by:
# * Michael Dominic K. <*****@*****.**>
#http://www.mdk.org.pl/2007/11/17/gl-colorspace-conversions
prog = """!!ARBfp1.0
# cgc version 3.1.0010, build date Feb 10 2012
# command line args: -profile arbfp1
# source file: yuv.cg
#vendor NVIDIA Corporation
#version 3.1.0.10
#profile arbfp1
#program main
#semantic main.IN
#var float2 IN.texcoord1 : $vin.TEXCOORD0 : TEX0 : 0 : 1
#var float2 IN.texcoord2 : $vin.TEXCOORD1 : TEX1 : 0 : 1
#var float2 IN.texcoord3 : $vin.TEXCOORD2 : TEX2 : 0 : 1
#var samplerRECT IN.texture1 : TEXUNIT0 : texunit 0 : 0 : 1
#var samplerRECT IN.texture2 : TEXUNIT1 : texunit 1 : 0 : 1
#var samplerRECT IN.texture3 : TEXUNIT2 : texunit 2 : 0 : 1
#var float4 IN.color : $vin.COLOR0 : COL0 : 0 : 1
#var float4 main.color : $vout.COLOR0 : COL : -1 : 1
#const c[0] = 1.1643835 2.017231 0 0.5
#const c[1] = 0.0625 1.1643835 -0.3917616 -0.81296802
#const c[2] = 1.1643835 0 1.5960271
PARAM c[3] = { { 1.1643835, 2.017231, 0, 0.5 },
{ 0.0625, 1.1643835, -0.3917616, -0.81296802 },
{ 1.1643835, 0, 1.5960271 } };
TEMP R0;
TEMP R1;
TEX R0.x, fragment.texcoord[2], texture[2], RECT;
ADD R1.z, R0.x, -c[0].w;
TEX R1.x, fragment.texcoord[0], texture[0], RECT;
TEX R0.x, fragment.texcoord[1], texture[1], RECT;
ADD R1.x, R1, -c[1];
ADD R1.y, R0.x, -c[0].w;
DP3 result.color.z, R1, c[0];
DP3 result.color.y, R1, c[1].yzww;
DP3 result.color.x, R1, c[2];
MOV result.color.w, fragment.color.primary;
END
# 10 instructions, 2 R-regs
"""
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glEnable(GL_FRAGMENT_PROGRAM_ARB)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width, height,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0])
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width / 2,
height / 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[1])
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, width / 2,
height / 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[2])
vtxarrays = 0
if vtxarrays == 1:
texcoords = [[0, 0], [0, height], [width, height], [width, 0]]
vtxcoords = texcoords
texcoords_half = [[0, 0], [0, height / 2], [width / 2, height / 2],
[width / 2, 0]]
glVertexPointeri(vtxcoords)
glActiveTexture(GL_TEXTURE0)
glClientActiveTexture(GL_TEXTURE0)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glTexCoordPointeri(texcoords)
glActiveTexture(GL_TEXTURE1)
glClientActiveTexture(GL_TEXTURE1)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glTexCoordPointeri(texcoords_half)
glActiveTexture(GL_TEXTURE2)
glClientActiveTexture(GL_TEXTURE2)
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
glTexCoordPointeri(texcoords_half)
glDrawArrays(GL_QUADS, 0, 4)
else:
glBegin(GL_QUADS)
glMultiTexCoord2i(GL_TEXTURE0, 0, 0)
glMultiTexCoord2i(GL_TEXTURE1, 0, 0)
glMultiTexCoord2i(GL_TEXTURE2, 0, 0)
glVertex2i(0, 0)
glMultiTexCoord2i(GL_TEXTURE0, 0, height)
glMultiTexCoord2i(GL_TEXTURE1, 0, height / 2)
glMultiTexCoord2i(GL_TEXTURE2, 0, height / 2)
glVertex2i(0, height)
glMultiTexCoord2i(GL_TEXTURE0, width, height)
glMultiTexCoord2i(GL_TEXTURE1, width / 2, height / 2)
glMultiTexCoord2i(GL_TEXTURE2, width / 2, height / 2)
glVertex2i(width, height)
glMultiTexCoord2i(GL_TEXTURE0, width, 0)
glMultiTexCoord2i(GL_TEXTURE1, width / 2, 0)
glMultiTexCoord2i(GL_TEXTURE2, width / 2, 0)
glVertex2i(width, 0)
glEnd()
# OpenGL end
#self.gldrawable.swap_buffers()
# self.gldrawable.swap_buffers()
glFinish()
self.gldrawable.gl_end()
def _do_paint_rgb(self, bpp, img_data, x, y, width, height, rowstride,
options, callbacks):
debug(
"%s._do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d)",
self, bpp, len(img_data), x, y, width, height, rowstride)
drawable = self.gl_init()
if not drawable:
debug("%s._do_paint_rgb(..) drawable is not set!", self)
return False
try:
self.set_rgb_paint_state()
bytes_per_pixel = bpp / 8
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a - 1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (
rowstride - width * bytes_per_pixel) / bytes_per_pixel
rgb_format = options.get("rgb_format", None)
self.gl_marker(
"%s %sbpp update at %d,%d, size %d,%d, stride is %d, row length %d, alignment %d"
% (rgb_format, bpp, x, y, width, height, rowstride, row_length,
alignment))
#Older clients may not tell us the pixel format, so we must infer it:
if bpp == 24:
default_format = "RGB"
else:
assert bpp == 32
default_format = "RGBA"
#convert it to a GL constant:
pformat = PIXEL_FORMAT_TO_CONSTANT.get(rgb_format
or default_format)
assert pformat is not None, "could not find pixel format for %s or %s (bpp=%s)" % (
rgb_format, default_format, bpp)
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,
self.texture_pixel_format, width, height, 0, pformat,
GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y + height)
glTexCoord2i(width, height)
glVertex2i(x + width, y + height)
glTexCoord2i(width, 0)
glVertex2i(x + width, y)
glEnd()
# Present update to screen
self.present_fbo(drawable)
# present_fbo has reset state already
finally:
drawable.gl_end()
return True
def _do_paint_rgb(self, bpp, img_data, x, y, width, height, rowstride, options, callbacks):
debug(
"%s._do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d)",
self,
bpp,
len(img_data),
x,
y,
width,
height,
rowstride,
)
drawable = self.gl_init()
if not drawable:
debug("%s._do_paint_rgb(..) drawable is not set!", self)
return False
try:
self.set_rgb_paint_state()
bytes_per_pixel = bpp / 8
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a - 1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) > a:
row_length = width + (rowstride - width * bytes_per_pixel) / bytes_per_pixel
rgb_format = options.get("rgb_format", None)
self.gl_marker(
"%s %sbpp update at %d,%d, size %d,%d, stride is %d, row length %d, alignment %d"
% (rgb_format, bpp, x, y, width, height, rowstride, row_length, alignment)
)
# Upload data as temporary RGB texture
if bpp == 24:
if rgb_format == "BGR":
pformat = GL_BGR
else:
assert rgb_format in ("RGB", None), "invalid 24-bit format: %s" % rgb_format
pformat = GL_RGB
else:
assert bpp == 32
if rgb_format == "BGRA":
pformat = GL_BGRA
else:
assert rgb_format in ("RGBA", None), "invalid 32-bit format: %s" % rgb_format
pformat = GL_RGBA
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, width, height, 0, pformat, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y + height)
glTexCoord2i(width, height)
glVertex2i(x + width, y + height)
glTexCoord2i(width, 0)
glVertex2i(x + width, y)
glEnd()
# Present update to screen
self.present_fbo(drawable)
# present_fbo has reset state already
finally:
drawable.gl_end()
return True
def _do_paint_rgb(self, bpp, img_data, x, y, width, height, rowstride, options):
log("%s._do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d)", self, bpp, len(img_data), x, y, width, height, rowstride)
drawable = self.gl_init()
if not drawable:
log("%s._do_paint_rgb(..) drawable is not set!", self)
return False
#deal with buffers uploads by wrapping them if we can, or copy to a string:
if type(img_data)==buffer:
if memoryview_type is not None:
img_data = memoryview_type(img_data)
else:
img_data = str(img_data)
try:
self.set_rgb_paint_state()
rgb_format = options.get("rgb_format")
if not rgb_format:
#Older servers may not tell us the pixel format, so we must infer it:
if bpp==24:
rgb_format = "RGB"
else:
assert bpp==32
rgb_format = "RGBA"
#convert it to a GL constant:
pformat = PIXEL_FORMAT_TO_CONSTANT.get(rgb_format)
assert pformat is not None, "could not find pixel format for %s (bpp=%s)" % (rgb_format, bpp)
bytes_per_pixel = len(rgb_format) #ie: BGRX -> 4
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a-1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (rowstride - width * bytes_per_pixel) / bytes_per_pixel
self.gl_marker("%s %sbpp update at (%d,%d) size %dx%d (%s bytes), stride=%d, row length %d, alignment %d, using GL upload format=%s" % (rgb_format, bpp, x, y, width, height, len(img_data), rowstride, row_length, alignment, CONSTANT_TO_PIXEL_FORMAT.get(pformat)))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, self.texture_pixel_format, width, height, 0, pformat, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y+height)
glTexCoord2i(width, height)
glVertex2i(x+width, y+height)
glTexCoord2i(width, 0)
glVertex2i(x+width, y)
glEnd()
# Present update to screen
self.present_fbo(drawable)
# present_fbo has reset state already
finally:
drawable.gl_end()
return True
def update_texture_yuv(self, img_data, x, y, width, height, rowstrides,
pixel_format):
window_width, window_height = self.size
assert self.textures is not None, "no OpenGL textures!"
if self.pixel_format is None or self.pixel_format != pixel_format:
self.pixel_format = pixel_format
divs = self.get_subsampling_divs(pixel_format)
log(
"GL creating new YUV textures for pixel format %s using divs=%s",
pixel_format, divs)
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
mag_filter = GL_NEAREST
if div > 1:
mag_filter = GL_LINEAR
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MAG_FILTER, mag_filter)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width / div, window_height / div, 0,
GL_LUMINANCE, GL_UNSIGNED_BYTE, 0)
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv_shader:
self.yuv_shader = [1]
glGenProgramsARB(1, self.yuv_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB, len(prog),
prog)
err = glGetString(GL_PROGRAM_ERROR_STRING_ARB)
if err:
#FIXME: maybe we should do something else here?
log.error(err)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv_shader[0])
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
divs = self.get_subsampling_divs(pixel_format)
for texture, index in ((GL_TEXTURE0, 0), (GL_TEXTURE1, 1),
(GL_TEXTURE2, 2)):
div = divs[index]
glActiveTexture(texture)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[index])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[index])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width / div,
height / div, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[index])
glFlush()
def update_texture_yuv420(self, img_data, x, y, width, height, rowstrides):
drawable = self.glarea.get_gl_drawable()
context = self.glarea.get_gl_context()
window_width, window_height = self.get_size()
if not drawable.gl_begin(context):
raise Exception("** Cannot create OpenGL rendering context!")
assert self.textures is not None
if self.current_mode == GLClientWindow.MODE_RGB:
raise Exception("** RGB -> YUV mode change unimplemented!")
elif self.current_mode == GLClientWindow.MODE_UNINITIALIZED:
log("Creating new YUV textures")
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width, window_height, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, 0)
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width / 2, window_height / 2, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, 0)
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
window_width / 2, window_height / 2, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, 0)
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [1]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,
self.yuv420_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
GL_PROGRAM_FORMAT_ASCII_ARB, len(prog),
prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,
self.yuv420_shader[0])
self.current_mode = GLClientWindow.MODE_YUV
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width, height,
GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0])
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width / 2,
height / 2, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[1])
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width / 2,
height / 2, GL_LUMINANCE, GL_UNSIGNED_BYTE,
img_data[2])
drawable.gl_end()
self.render_image()
def _do_paint_rgb(self, bpp, img_data, x, y, width, height, rowstride,
options):
log(
"%s._do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d)",
self, bpp, len(img_data), x, y, width, height, rowstride)
drawable = self.gl_init()
if not drawable:
log("%s._do_paint_rgb(..) drawable is not set!", self)
return False
#deal with buffers uploads by wrapping them if we can, or copy to a string:
if type(img_data) == buffer:
if memoryview_type is not None:
img_data = memoryview_type(img_data)
else:
img_data = str(img_data)
try:
self.set_rgb_paint_state()
rgb_format = options.get("rgb_format")
if not rgb_format:
#Older servers may not tell us the pixel format, so we must infer it:
if bpp == 24:
rgb_format = "RGB"
else:
assert bpp == 32
rgb_format = "RGBA"
#convert it to a GL constant:
pformat = PIXEL_FORMAT_TO_CONSTANT.get(rgb_format)
assert pformat is not None, "could not find pixel format for %s (bpp=%s)" % (
rgb_format, bpp)
bytes_per_pixel = len(rgb_format) #ie: BGRX -> 4
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a - 1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (
rowstride - width * bytes_per_pixel) / bytes_per_pixel
self.gl_marker(
"%s %sbpp update at (%d,%d) size %dx%d (%s bytes), stride=%d, row length %d, alignment %d, using GL upload format=%s"
% (rgb_format, bpp, x, y, width, height, len(img_data),
rowstride, row_length, alignment,
CONSTANT_TO_PIXEL_FORMAT.get(pformat)))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_BORDER)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_BORDER)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,
self.texture_pixel_format, width, height, 0, pformat,
GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y + height)
glTexCoord2i(width, height)
glVertex2i(x + width, y + height)
glTexCoord2i(width, 0)
glVertex2i(x + width, y)
glEnd()
# Present update to screen
self.present_fbo(drawable)
# present_fbo has reset state already
finally:
drawable.gl_end()
return True
def update_texture_yuv420(self, img_data, x, y, width, height, rowstrides):
drawable = self.glarea.get_gl_drawable()
context = self.glarea.get_gl_context()
window_width, window_height = self.get_size()
if not drawable.gl_begin(context):
raise Exception("** Cannot create OpenGL rendering context!")
assert self.textures is not None
if self.current_mode == GLClientWindow.MODE_RGB:
raise Exception("** RGB -> YUV mode change unimplemented!")
elif self.current_mode == GLClientWindow.MODE_UNINITIALIZED:
log("Creating new YUV textures")
# Create textures of the same size as the window's
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width, window_height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width/2, window_height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glEnable(GL_TEXTURE_RECTANGLE_ARB)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE, window_width/2, window_height/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
log("Assigning fragment program")
glEnable(GL_FRAGMENT_PROGRAM_ARB)
if not self.yuv420_shader:
self.yuv420_shader = [ 1 ]
glGenProgramsARB(1, self.yuv420_shader)
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
prog = GL_COLORSPACE_CONVERSIONS
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len(prog), prog)
log.error(glGetString(GL_PROGRAM_ERROR_STRING_ARB))
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, self.yuv420_shader[0])
self.current_mode = GLClientWindow.MODE_YUV
# Clamp width and height to the actual texture size
if x + width > window_width:
width = window_width - x
if y + height > window_height:
height = window_height - y
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[0])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[0])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[0])
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[1])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[1])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[1])
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[2])
glPixelStorei(GL_UNPACK_ROW_LENGTH, rowstrides[2])
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, img_data[2])
drawable.gl_end()
self.render_image()
def setup(self): ''' Construct the texture atlas for the font ''' face = Face(self.filename) face.set_pixel_sizes(0, self.size) rowh, roww = 0,0 # Determine image size for i in xrange(32,128): face.load_char( chr(i), FT_LOAD_RENDER) bitmap = face.glyph.bitmap if roww + bitmap.width + 1 >= 1024: # max texture width self.w = max(self.w, roww) self.h += rowh roww = 0 rowh = 0 roww += bitmap.width + 1 rowh = max(rowh, bitmap.rows) self.w = max(self.w, roww) self.h += rowh ## Create texture to hold ASCII glyphs # Ensure no texture is currently selected glActiveTexture(GL_TEXTURE0) self.texid = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, self.texid) glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, self.w, self.h, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0) # We require 1 byte alignment when uploading texture data glPixelStorei(GL_UNPACK_ALIGNMENT, 1) # Clamping to edges is important to prevent artifacts when scaling glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE) # Linear filtering looks better for text glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) # Add glyphs to texture ox = 0 oy = 0 rowh = 0 # class to hold data class CharInfo: pass for i in xrange(32,128): face.load_char( chr(i), FT_LOAD_RENDER) g = face.glyph bitmap = g.bitmap if ox + bitmap.width + 1 >= 1024: # max texture width oy += rowh rowh = 0 ox = 0 glTexSubImage2D(GL_TEXTURE_2D, 0, ox, oy, bitmap.width, bitmap.rows, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.buffer) ci = CharInfo() ci.ax = float(g.advance.x >> 6) ci.ay = float(g.advance.y >> 6) ci.bw = float(bitmap.width) ci.bh = float(bitmap.rows) ci.bl = float(g.bitmap_left) ci.bt = float(g.bitmap_top) ci.tx = float(ox) / float(self.w) ci.ty = float(oy) / float(self.h) self.c[chr(i)] = ci rowh = max(rowh, bitmap.rows) ox += bitmap.width + 1
def _do_paint_rgb(self, bpp, img_data, x, y, width, height, rowstride, options):
log("%s._do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d, options=%s)", self, bpp, len(img_data), x, y, width, height, rowstride, options)
context = self.gl_context()
if not context:
log("%s._do_paint_rgb(..) no context!", self)
return False
#TODO: move this code up to the decode thread section
upload, img_data = self.pixels_for_upload(img_data)
with context:
self.gl_init()
self.set_rgb_paint_state()
rgb_format = options.get(b"rgb_format")
if not rgb_format:
#Older servers may not tell us the pixel format, so we must infer it:
if bpp==24:
rgb_format = "RGB"
else:
assert bpp==32
rgb_format = "RGBA"
else:
rgb_format = rgb_format.decode()
#convert it to a GL constant:
pformat = PIXEL_FORMAT_TO_CONSTANT.get(rgb_format)
assert pformat is not None, "could not find pixel format for %s (bpp=%s)" % (rgb_format, bpp)
bytes_per_pixel = len(rgb_format) #ie: BGRX -> 4
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a-1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (rowstride - width * bytes_per_pixel) // bytes_per_pixel
self.gl_marker("%s %sbpp update at (%d,%d) size %dx%d (%s bytes), stride=%d, row length %d, alignment %d, using GL %s format=%s",
rgb_format, bpp, x, y, width, height, len(img_data), rowstride, row_length, alignment, upload, CONSTANT_TO_PIXEL_FORMAT.get(pformat))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 0)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAX_LEVEL, 0)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, self.texture_pixel_format, width, height, 0, pformat, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y+height)
glTexCoord2i(width, height)
glVertex2i(x+width, y+height)
glTexCoord2i(width, 0)
glVertex2i(x+width, y)
glEnd()
self.paint_box(options.get("encoding"), options.get("delta", -1)>=0, x, y, width, height)
# Present update to screen
self.present_fbo(x, y, width, height, options.get("flush", 0))
# present_fbo has reset state already
return True
def do_paint_rgb(self, rgb_format, img_data, x, y, width, height, rowstride, options, callbacks):
log("%s.do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d, options=%s)", self, rgb_format, len(img_data), x, y, width, height, rowstride, options)
context = self.gl_context()
if not context:
log("%s._do_paint_rgb(..) no context!", self)
fire_paint_callbacks(callbacks, False, "no opengl context")
return
if not options.get("paint", True):
fire_paint_callbacks(callbacks)
return
try:
upload, img_data = self.pixels_for_upload(img_data)
with context:
self.gl_init()
self.set_rgb_paint_state()
#convert it to a GL constant:
pformat = PIXEL_FORMAT_TO_CONSTANT.get(rgb_format.decode())
assert pformat is not None, "could not find pixel format for %s" % rgb_format
bytes_per_pixel = len(rgb_format) #ie: BGRX -> 4
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a-1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (rowstride - width * bytes_per_pixel) // bytes_per_pixel
self.gl_marker("%s update at (%d,%d) size %dx%d (%s bytes), stride=%d, row length %d, alignment %d, using GL %s format=%s",
rgb_format, x, y, width, height, len(img_data), rowstride, row_length, alignment, upload, CONSTANT_TO_PIXEL_FORMAT.get(pformat))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
set_texture_level()
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, self.texture_pixel_format, width, height, 0, pformat, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y+height)
glTexCoord2i(width, height)
glVertex2i(x+width, y+height)
glTexCoord2i(width, 0)
glVertex2i(x+width, y)
glEnd()
self.paint_box(options.get("encoding"), options.get("delta", -1)>=0, x, y, width, height)
# Present update to screen
self.present_fbo(x, y, width, height, options.get("flush", 0))
# present_fbo has reset state already
fire_paint_callbacks(callbacks)
except Exception as e:
log("Error in %s paint of %i bytes, options=%s)", rgb_format, len(img_data), options)
fire_paint_callbacks(callbacks, False, "OpenGL %s paint error: %s" % (rgb_format, e))
uv_data, GL_STATIC_DRAW)
glVertexAttribPointer(program.attribute_location('vin_uv'),
2, GL_FLOAT, GL_FALSE, 0, None)
glEnableVertexAttribArray(1)
# Lets unbind our vbo and vao state
# We will bind these again in the draw loop
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
running = True
img = Image.open(sys.path[0] + '/../art/enthought.png')
img_data = numpy.array(list(img.getdata()), numpy.int8)
texture_id = glGenTextures(1)
glPixelStorei(GL_UNPACK_ALIGNMENT, 4)
glBindTexture(GL_TEXTURE_2D, texture_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, img.size[0], img.size[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, img_data)
while running:
glClear(GL_COLOR_BUFFER_BIT)
# Specify shader to be used
glUseProgram(program.program_id)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, texture_id)
def do_paint_rgb(self, rgb_format, img_data, x, y, width, height,
rowstride, options, callbacks):
log(
"%s.do_paint_rgb(%s, %s bytes, x=%d, y=%d, width=%d, height=%d, rowstride=%d, options=%s)",
self, rgb_format, len(img_data), x, y, width, height, rowstride,
options)
context = self.gl_context()
if not context:
log("%s._do_paint_rgb(..) no context!", self)
fire_paint_callbacks(callbacks, False, "no opengl context")
return
if not options.get("paint", True):
fire_paint_callbacks(callbacks)
return
try:
upload, img_data = self.pixels_for_upload(img_data)
with context:
self.gl_init()
self.set_rgb_paint_state()
#convert it to a GL constant:
pformat = PIXEL_FORMAT_TO_CONSTANT.get(rgb_format.decode())
assert pformat is not None, "could not find pixel format for %s" % rgb_format
bytes_per_pixel = len(rgb_format) #ie: BGRX -> 4
# Compute alignment and row length
row_length = 0
alignment = 1
for a in [2, 4, 8]:
# Check if we are a-aligned - ! (var & 0x1) means 2-aligned or better, 0x3 - 4-aligned and so on
if (rowstride & a - 1) == 0:
alignment = a
# If number of extra bytes is greater than the alignment value,
# then we also have to set row_length
# Otherwise it remains at 0 (= width implicitely)
if (rowstride - width * bytes_per_pixel) >= alignment:
row_length = width + (
rowstride - width * bytes_per_pixel) // bytes_per_pixel
self.gl_marker(
"%s update at (%d,%d) size %dx%d (%s bytes), stride=%d, row length %d, alignment %d, using GL %s format=%s",
rgb_format, x, y, width, height, len(img_data), rowstride,
row_length, alignment, upload,
CONSTANT_TO_PIXEL_FORMAT.get(pformat))
# Upload data as temporary RGB texture
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self.textures[TEX_RGB])
glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length)
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER, GL_NEAREST)
set_texture_level()
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_BORDER)
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_BORDER)
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,
self.texture_pixel_format, width, height, 0,
pformat, GL_UNSIGNED_BYTE, img_data)
# Draw textured RGB quad at the right coordinates
glBegin(GL_QUADS)
glTexCoord2i(0, 0)
glVertex2i(x, y)
glTexCoord2i(0, height)
glVertex2i(x, y + height)
glTexCoord2i(width, height)
glVertex2i(x + width, y + height)
glTexCoord2i(width, 0)
glVertex2i(x + width, y)
glEnd()
self.paint_box(options.get("encoding"),
options.get("delta", -1) >= 0, x, y, width,
height)
# Present update to screen
self.present_fbo(x, y, width, height, options.get("flush", 0))
# present_fbo has reset state already
fire_paint_callbacks(callbacks)
except Exception as e:
log("Error in %s paint of %i bytes, options=%s)", rgb_format,
len(img_data), options)
fire_paint_callbacks(callbacks, False,
"opengl %s paint error: %s" % (rgb_format, e))
