Change license, flat file hier, do not use gpp, join .py and .pyx, simpler makefile1.1.2

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 358 insertions, 0 deletions

diff --git a/test b/test
new file mode 100755
index 0000000..407c668
--- /dev/null
+++ b/test
@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+# See LICENSE file for copyright and license details.
+
+import os, sys, time, errno, select
+
+os.chdir('/'.join(sys.argv[0].split('/')[:-1]))
+sys.path.append('../bin')
+
+import libcoopgamma
+cg = libcoopgamma
+
+if len(sys.argv) == 1:
+    print('\033[1m%s:\033[m' % 'Methods')
+    for m in cg.get_methods():
+        print(m)
+    print()
+    
+    print('\033[1m%s:\033[m' % 'Method')
+    print(cg.get_method_and_site()[0])
+    print()
+    
+    print('\033[1m%s:\033[m' % 'Site')
+    print(cg.get_method_and_site()[1])
+    print()
+    
+    print('\033[1m%s:\033[m' % 'PID file')
+    print(cg.get_pid_file())
+    print()
+    
+    print('\033[1m%s:\033[m' % 'Socket')
+    print(cg.get_socket_file())
+    print()
+    
+    g = cg.Context()
+    g.connect()
+    g.detach()
+    gstr = repr(g)
+    del g
+    
+    argv0 = './' + sys.argv[0].split('/')[-1]
+    os.execl(argv0, argv0, gstr)
+else:
+    g = eval(sys.argv[1])
+    g.attach()
+    pass
+
+print('\033[1m%s:\033[m' % 'CRTC:s')
+crtcs = g.get_crtcs_sync()
+for crtc in crtcs:
+    print(crtc)
+print()
+
+info = g.get_gamma_info_sync(crtc)
+print('\033[1m%s:\033[m' % 'CRTC info')
+print('Cooperative:', 'yes' if info.cooperative else 'no')
+if info.depth is not None:
+    print('Depth:', cg.Depth.str(info.depth))
+print('Supported:', cg.Support.str(info.supported))
+if info.red_size is not None:
+    print('Red stops:', info.red_size)
+if info.green_size is not None:
+    print('Green stops:', info.green_size)
+if info.blue_size is not None:
+    print('Blue stops:', info.blue_size)
+print('Colourspace:', cg.Colourspace.str(info.colourspace))
+if info.gamut is not None:
+    print('Red point:', str(info.gamut.red))
+    print('Green point:', str(info.gamut.green))
+    print('Blue point:', str(info.gamut.blue))
+    print('White point:', str(info.gamut.white))
+print()
+
+table = g.get_gamma_sync(cg.FilterQuery(crtc = crtc, coalesce = False))
+print('\033[1m%s:\033[m' % 'Filter table')
+print('Red stops:', table.red_size)
+print('Green stops:', table.green_size)
+print('Blue stops:', table.blue_size)
+print('Depth:', cg.Depth.str(table.depth))
+for i, fltr in enumerate(table.filters):
+    print('Filter %i:' % i)
+    print('  Priority:', fltr.priority)
+    print('  Class:', fltr.fclass)
+    print('  Ramps:')
+    rr, gr, br = fltr.ramps.red, fltr.ramps.green, fltr.ramps.blue
+    n = max(len(rr), len(gr), len(br))
+    fmt = '    \033[31m%s \033[32m%s \033[34m%s\033[m'
+    rr = [str(rr[i]) if i < len(rr) else '' for i in range(n)]
+    gr = [str(gr[i]) if i < len(gr) else '' for i in range(n)]
+    br = [str(br[i]) if i < len(br) else '' for i in range(n)]
+    for y in zip(rr, gr, br):
+        print(fmt % y)
+print()
+table_nc = table
+
+table = g.get_gamma_sync(cg.FilterQuery(crtc = crtc, coalesce = True))
+print('\033[1m%s:\033[m' % 'Filter table')
+print('Red stops:', table.red_size)
+print('Green stops:', table.green_size)
+print('Blue stops:', table.blue_size)
+print('Depth:', cg.Depth.str(table.depth))
+for fltr in table.filters:
+    print('Ramps:')
+    rr, gr, br = fltr.ramps.red, fltr.ramps.green, fltr.ramps.blue
+    n = max(len(rr), len(gr), len(br))
+    fmt = '  \033[31m%s \033[32m%s \033[34m%s\033[m'
+    rr = [str(rr[i]) if i < len(rr) else '' for i in range(n)]
+    gr = [str(gr[i]) if i < len(gr) else '' for i in range(n)]
+    br = [str(br[i]) if i < len(br) else '' for i in range(n)]
+    for y in zip(rr, gr, br):
+        print(fmt % y)
+print()
+table_c = table
+
+fltr = cg.Filter(0, crtc, 'pylibcoopgamma::test::test', cg.Lifespan.UNTIL_DEATH, table.depth,
+                 cg.Ramps(table.red_size, table.green_size, table.blue_size))
+
+if table.depth < 0:
+    Y = lambda x : x
+else:
+    m = 2 ** table.depth - 1
+    Y = lambda x : int(x * m)
+
+redzero = fltr.ramps.red
+greenzero = fltr.ramps.green
+redid = [Y(x / (table.red_size - 1)) for x in range(table.red_size)]
+greenid = [Y(x / (table.green_size - 1)) for x in range(table.green_size)]
+blueid = [Y(x / (table.blue_size - 1)) for x in range(table.blue_size)]
+
+fltr.ramps.red = redid
+g.set_gamma_sync(fltr)
+time.sleep(0.5)
+fltr.ramps.red = redzero
+
+fltr.ramps.green = greenid
+g.set_gamma_sync(fltr)
+time.sleep(0.5)
+fltr.ramps.green = greenzero
+
+fltr.ramps.blue = blueid
+g.set_gamma_sync(fltr)
+time.sleep(0.5)
+
+g.set_nonbreaking(False)
+
+asynch = cg.AsyncContext()
+
+def flush(e):
+    if e.errno in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
+        while True:
+            try:
+                g.flush()
+            except OSError as ex:
+                if ex.errno in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
+                    continue
+                else:
+                    raise ex
+            break
+    else:
+        raise e
+
+try:
+    g.get_crtcs_send(asynch)
+except OSError as e:
+    flush(e)
+if g.synchronise([asynch]) != 0:
+     sys.exit(1)
+if g.get_crtcs_recv(asynch) != crtcs:
+    sys.exit(2)
+
+try:
+    g.get_gamma_info_send(crtc, asynch)
+except OSError as e:
+    flush(e)
+if g.synchronise([asynch]) != 0:
+     sys.exit(3)
+info2 = g.get_gamma_info_recv(asynch)
+if info2.cooperative != info.cooperative:
+    sys.exit(4)
+if info2.depth != info.depth:
+    sys.exit(4)
+if info2.supported != info.supported:
+    sys.exit(4)
+if info2.red_size != info.red_size:
+    sys.exit(4)
+if info2.green_size != info.green_size:
+    sys.exit(4)
+if info2.blue_size != info.blue_size:
+    sys.exit(4)
+if info2.colourspace != info.colourspace:
+    sys.exit(4)
+if (info2.gamut is None) != (info.gamut is None):
+    sys.exit(4)
+if info.gamut is not None:
+    if info2.gamut.red.x_raw != info.gamut.red.x_raw or info2.gamut.red.x != info.gamut.red.x:
+        sys.exit(4)
+    if info2.gamut.red.y_raw != info.gamut.red.y_raw or info2.gamut.red.y != info.gamut.red.y:
+        sys.exit(4)
+    if info2.gamut.green.x_raw != info.gamut.green.x_raw or info2.gamut.green.x != info.gamut.green.x:
+        sys.exit(4)
+    if info2.gamut.green.y_raw != info.gamut.green.y_raw or info2.gamut.green.y != info.gamut.green.y:
+        sys.exit(4)
+    if info2.gamut.blue.x_raw != info.gamut.blue.x_raw or info2.gamut.blue.x != info.gamut.blue.x:
+        sys.exit(4)
+    if info2.gamut.blue.y_raw != info.gamut.blue.y_raw or info2.gamut.blue.y != info.gamut.blue.y:
+        sys.exit(4)
+    if info2.gamut.white.x_raw != info.gamut.white.x_raw or info2.gamut.white.x != info.gamut.white.x:
+        sys.exit(4)
+    if info2.gamut.white.y_raw != info.gamut.white.y_raw or info2.gamut.white.y != info.gamut.white.y:
+        sys.exit(4)
+
+try:
+    g.set_gamma_send(cg.Filter(crtc = crtc, fclass = 'pylibcoopgamma::test::test',
+                               lifespan = cg.Lifespan.REMOVE), asynch)
+except OSError as e:
+    flush(e)
+if g.synchronise([asynch]) != 0:
+     sys.exit(1)
+g.set_gamma_recv(asynch)
+
+try:
+    g.get_gamma_send(cg.FilterQuery(crtc = crtc, coalesce = False), asynch)
+except OSError as e:
+    flush(e)
+if g.synchronise([asynch]) != 0:
+     sys.exit(5)
+table = g.get_gamma_recv(asynch)
+if table.red_size != table_nc.red_size:
+    sys.exit(6)
+if table.green_size != table_nc.green_size:
+    sys.exit(6)
+if table.blue_size != table_nc.blue_size:
+    sys.exit(6)
+if table.depth != table_nc.depth:
+    sys.exit(6)
+if len(table.filters) != len(table_nc.filters):
+    sys.exit(6)
+for i, (fltr1, fltr2) in enumerate(zip(table.filters, table_nc.filters)):
+    if fltr1.priority != fltr2.priority:
+        sys.exit(6)
+    if fltr1.fclass != fltr2.fclass:
+        sys.exit(6)
+    if fltr1.ramps.red != fltr2.ramps.red:
+        sys.exit(6)
+    if fltr1.ramps.green != fltr2.ramps.green:
+        sys.exit(6)
+    if fltr1.ramps.blue != fltr2.ramps.blue:
+        sys.exit(6)
+
+try:
+    g.get_gamma_send(cg.FilterQuery(crtc = crtc, coalesce = True), asynch)
+except OSError as e:
+    flush(e)
+if g.synchronise([asynch]) != 0:
+     sys.exit(7)
+table = g.get_gamma_recv(asynch)
+if table.red_size != table_c.red_size:
+    sys.exit(8)
+if table.green_size != table_c.green_size:
+    sys.exit(8)
+if table.blue_size != table_c.blue_size:
+    sys.exit(8)
+if table.depth != table_c.depth:
+    sys.exit(8)
+if len(table.filters) != len(table_c.filters):
+    sys.exit(8)
+for i, (fltr1, fltr2) in enumerate(zip(table.filters, table_c.filters)):
+    if fltr1.ramps.red != fltr2.ramps.red:
+        sys.exit(8)
+    if fltr1.ramps.green != fltr2.ramps.green:
+        sys.exit(8)
+    if fltr1.ramps.blue != fltr2.ramps.blue:
+        sys.exit(8)
+
+
+fltr = cg.Filter(0, crtc, 'pylibcoopgamma::test::test', cg.Lifespan.UNTIL_DEATH, table.depth,
+                 cg.Ramps(table.red_size, table.green_size, table.blue_size))
+
+fltr.ramps.red = list(reversed(redid))
+fltr.ramps.green = list(reversed(greenid))
+fltr.ramps.blue = list(reversed(blueid))
+try:
+    g.set_gamma_send(fltr, asynch)
+except OSError as e:
+    flush(e)
+if g.synchronise([asynch]) != 0:
+    sys.exit(9)
+g.skip_message()
+time.sleep(0.5)
+
+fltr.ramps.red = redid
+fltr.ramps.green = greenid
+fltr.ramps.blue = blueid
+g.set_gamma_sync(fltr)
+
+g.set_nonbreaking(True)
+
+async1 = asynch
+async2 = cg.AsyncContext()
+async3 = cg.AsyncContext()
+time.sleep(0.5)
+
+fltr.ramps.red = list(reversed(redid))
+fltr.fclass = 'pylibcoopgamma::test::red'
+try:
+    g.set_gamma_send(fltr, async1)
+    need_flush = True
+except OSError as e:
+    if e.errno not in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
+        sys.exit(10)
+    need_flush = False
+fltr.ramps.red = redid
+
+fltr.ramps.green = list(reversed(greenid))
+fltr.fclass = 'pylibcoopgamma::test::green'
+try:
+    g.set_gamma_send(fltr, async2)
+    need_flush = True
+except OSError as e:
+    if e.errno not in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
+        sys.exit(10)
+    need_flush = False
+fltr.ramps.green = greenid
+
+fltr.ramps.blue = list(reversed(blueid))
+fltr.fclass = 'pylibcoopgamma::test::blue'
+try:
+    g.set_gamma_send(fltr, async3)
+    need_flush = True
+except OSError as e:
+    if e.errno not in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
+        sys.exit(10)
+    need_flush = False
+fltr.ramps.blue = blueid
+
+while need_flush:
+    try:
+        g.flush()
+        break
+    except OSError as e:
+        if e.errno in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
+            continue
+        else:
+            sys.exit(11)
+
+poll = select.poll()
+poll.register(g.fd, select.POLLIN | select.POLLPRI)
+
+unsynced = [True] * 3
+while any(unsynced):
+    poll.poll()
+    n = g.synchronise([async1, async2, async3])
+    if n < 0 or n >= 3 or not unsynced[n]:
+        sys.exit(12)
+    unsynced[n] = False
+    g.set_gamma_recv([async1, async2, async3][n])
+
+time.sleep(0.5)
+del g