← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libavg/trusty-proposed

« back to all changes in this revision

Viewing changes to src/test/FXTest.py

  • Committer: Package Import Robot
  • Author(s): OXullo Intersecans
  • Date: 2011-12-06 22:44:56 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20111206224456-qc7250z3ya1vi8s9
Tags: 1.7.0-0ubuntu1
https://launchpad.net/bugs/899183
* New upstream release (LP: #899183)
* Remove patches 0002-libav-0.7.patch, 0003-fglrx-segfault-on-startup.patch
  now merged to upstream
* Remove unnecessary .la files
* Update debian/watch file
* Fix debian/copyright dep-5 compliancy
* Update standards to version 3.9.2
* Add man pages for avg_checktouch, avg_checkvsync, avg_showsvg
* Minor debian/rules enhancement
* Add librsvg2-dev, libgdk-pixbuf2.0-dev to Build-Depends
* Proper transition to dh_python2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/FXTest.py
1
1
#!/usr/bin/env python
2
2
# -*- coding: utf-8 -*-
3
3
# libavg - Media Playback Engine.
4
 
# Copyright (C) 2003-2008 Ulrich von Zadow
 
4
# Copyright (C) 2003-2011 Ulrich von Zadow
5
5
#
6
6
# This library is free software; you can redistribute it and/or
7
7
# modify it under the terms of the GNU Lesser General Public
20
20
# Current versions can be found at www.libavg.de
21
21
#
22
22
 
23
 
import unittest
24
 
 
25
 
import math
26
 
 
27
 
from libavg import avg
 
23
from libavg import avg, utils
28
24
from testcase import *
29
25
 
30
26
class FXTestCase(AVGTestCase):
33
29
 
34
30
    def testImageNullFX(self):
35
31
        def activateFX():
36
 
            node2.setEffect(avg.NullFXNode())
 
32
            for node in self.nodes[0]:
 
33
                node.setEffect(avg.NullFXNode())
37
34
 
38
35
        def newNode():
39
 
            node = avg.ImageNode(parent=root, href="rgb24-32x32.png", pos=(64,0))
40
 
            node.setEffect(avg.NullFXNode())
 
36
            self.newNode = avg.ImageNode(parent=root, href="rgb24-32x32.png", pos=(64,0))
 
37
            self.newNode.setEffect(avg.NullFXNode())
 
38
 
 
39
        def newFX():
 
40
            self.newNode.setEffect(avg.NullFXNode())
41
41
 
42
42
        def addBgNode():
43
 
            node = avg.RectNode(pos=(0,32), size=(64,32), fillopacity=1, opacity=0,
 
43
            node = avg.RectNode(pos=(0,0), size=(64,96), fillopacity=1, opacity=0,
44
44
                    fillcolor="FFFFFF")
45
45
            root.insertChild(node, 0)
46
46
 
47
 
        self.loadEmptyScene()
48
 
        root = Player.getRootNode()
49
 
        node = avg.ImageNode(parent=root, href="rgb24-32x32.png")
50
 
        node.setEffect(avg.NullFXNode())
51
 
        node = avg.ImageNode(parent=root, href="rgb24alpha-32x32.png", pos=(0,32))
52
 
        node.setEffect(avg.NullFXNode())
53
 
        node = avg.ImageNode(parent=root, href="rgb24alpha-32x32.png", pos=(32,32),
 
47
        # Initial setup is 3x2 images: 
 
48
        # rows: no alpha, alpha, alpha & opacity 0.6
 
49
        # cols: no FX, FX
 
50
        # The two cols should look the same.
 
51
        root = self.loadEmptyScene()
 
52
        self.nodes = []
 
53
        for fx in (False, True):
 
54
            curNodes = []
 
55
            self.nodes.append(curNodes)
 
56
            def configureNode(node, fx):
 
57
                curNodes.append(node)
 
58
                if fx:
 
59
                    node.x = 32
 
60
                    node.setEffect(avg.NullFXNode())
 
61
 
 
62
            node = avg.ImageNode(parent=root, href="rgb24-32x32.png", pos=(0,0))
 
63
            configureNode(node, fx)
 
64
            node = avg.ImageNode(parent=root, href="rgb24alpha-32x32.png", pos=(0,32))
 
65
            configureNode(node, fx)
 
66
            node = avg.ImageNode(parent=root, href="rgb24alpha-32x32.png", pos=(0,64),
54
67
                opacity=0.6)
55
 
        node.setEffect(avg.NullFXNode())
56
 
        node2 = avg.ImageNode(parent=root, href="rgb24-32x32.png", pos=(32,0))
57
 
        self.start(None,
58
 
                (lambda: self.compareImage("testImageNullFX1", False),
 
68
            configureNode(node, fx)
 
69
 
 
70
        self.start((
 
71
                 lambda: self.compareImage("testImageNullFX1", False),
 
72
                 addBgNode,
 
73
                 lambda: self.compareImage("testImageNullFX2", False),
59
74
                 activateFX,
60
 
                 lambda: self.compareImage("testImageNullFX1", False),
 
75
                 lambda: self.compareImage("testImageNullFX2", False),
61
76
                 newNode,
62
 
                 lambda: self.compareImage("testImageNullFX2", False),
63
 
                 addBgNode,
64
 
                 lambda: self.compareImage("testImageNullFX3", False),
 
77
                 lambda: self.compareImage("testImageNullFX3", False),
 
78
                 newFX,
 
79
                 lambda: self.compareImage("testImageNullFX3", False),
 
80
                 lambda: utils.initFXCache(10),
65
81
                ))
66
82
 
67
83
    def testVideoNullFX(self):
68
 
        self.loadEmptyScene()
69
 
        root = Player.getRootNode()
 
84
        root = self.loadEmptyScene()
70
85
        Player.setFakeFPS(25)
71
86
        node = avg.VideoNode(parent=root, href="../video/testfiles/mjpeg-48x48.avi",
72
87
                threaded=False)
73
88
        node.setEffect(avg.NullFXNode())
74
89
        node.play()
75
 
        self.start(None,
76
 
                (lambda: self.compareImage("testVideoNullFX", False),
77
 
                ))
 
90
        self.start((lambda: self.compareImage("testVideoNullFX", False),))
78
91
 
79
92
    def testWordsNullFX(self):
80
 
        self.loadEmptyScene()
81
 
        root = Player.getRootNode()
 
93
        root = self.loadEmptyScene()
82
94
        node = avg.WordsNode(parent=root, text="testtext", font="Bitstream Vera Sans")
83
95
        node.setEffect(avg.NullFXNode())
84
 
        self.start(None,
85
 
                (lambda: self.compareImage("testWordsNullFX", True),
 
96
        node = avg.WordsNode(parent=root, text="testtext", pos=(0,20),
 
97
                font="Bitstream Vera Sans")
 
98
        self.start((
 
99
                 lambda: self.compareImage("testWordsNullFX", True),
86
100
                ))
87
101
 
88
102
    def testCanvasNullFX(self):
89
103
        def setOpacity():
90
104
            node.opacity=0.6
91
105
 
92
 
        Player.loadCanvasString("""
93
 
            <canvas id="offscreen" width="160" height="120">
94
 
                <image href="rgb24-32x32.png"/>
95
 
                <image pos="(32,0)" href="rgb24alpha-32x32.png"/>
96
 
            </canvas>""")
97
 
        self.loadEmptyScene()
98
 
        root = Player.getRootNode()
 
106
        root = self.loadEmptyScene()
 
107
        self.__createOffscreenCanvas()
99
108
        node = avg.ImageNode(parent=root, href="canvas:offscreen")
100
109
        node.setEffect(avg.NullFXNode())
101
 
        self.start(None,
102
 
                (lambda: self.compareImage("testCanvasNullFX1", False),
 
110
        self.start((
 
111
                 lambda: self.compareImage("testCanvasNullFX1", False),
103
112
                 setOpacity,
104
113
                 lambda: self.compareImage("testCanvasNullFX2", False),
105
114
                ))
106
115
 
 
116
    def testNodeInCanvasNullFX(self):
 
117
        root = self.loadEmptyScene()
 
118
        canvas = self.__createOffscreenCanvas()
 
119
        avg.ImageNode(parent=root, href="canvas:offscreen")
 
120
        node = canvas.getElementByID("test")
 
121
        node.setEffect(avg.NullFXNode())
 
122
        rect = avg.RectNode(size=(100,100), strokewidth=0, fillcolor="FF0000",
 
123
                fillopacity=1)
 
124
        canvas.getRootNode().insertChild(rect, 0)
 
125
        
 
126
        self.start((
 
127
                 lambda: self.compareImage("testNodeInCanvasNullFX1", False),
 
128
                ))
 
129
 
 
130
    def testRenderPipeline(self):
 
131
        print
 
132
        for useSrcCanvas in (False, True):
 
133
            for useDestCanvas in (False, True):
 
134
                for useFX in (False, True):
 
135
                    for useColorConv in (False, True):
 
136
                        print "  ", useSrcCanvas, useDestCanvas, useFX, useColorConv
 
137
                        root = self.loadEmptyScene()
 
138
                        if useSrcCanvas:
 
139
                            srcCanvas = Player.createCanvas(id="src", size=(160,120))
 
140
                            avg.ImageNode(href="rgb24alpha-64x64.png", 
 
141
                                    parent=srcCanvas.getRootNode())
 
142
                            srcImg = avg.ImageNode(href="canvas:src")
 
143
                        else:
 
144
                            srcImg = avg.ImageNode(href="rgb24alpha-64x64.png")
 
145
                        if useFX:
 
146
                            srcImg.setEffect(avg.NullFXNode())
 
147
                        if useColorConv:
 
148
                            srcImg.contrast = (1.01, 1.0, 1.0)
 
149
                        if useDestCanvas:
 
150
                            destCanvas = Player.createCanvas(id="dest", size=(160,120))
 
151
                            destCanvas.getRootNode().appendChild(srcImg)
 
152
                            destImg = avg.ImageNode(href="canvas:dest", parent=root)
 
153
                        else:
 
154
                            root.appendChild(srcImg)
 
155
                        self.start((
 
156
                                lambda: self.compareImage("testRenderPipeline", False),
 
157
                                ))
 
158
 
107
159
    def testBlurFX(self):
 
160
        
 
161
        def setRadius(radius):
 
162
            self.effect.radius = radius
 
163
        
108
164
        def removeFX():
109
165
            self.node.setEffect(None)
110
166
 
113
169
 
114
170
        def addNewFX():
115
171
            effect = avg.BlurFXNode()
116
 
            effect.setParam(8)
 
172
            effect.radius = 8
117
173
            self.node.setEffect(effect)
118
174
 
119
 
        self.loadEmptyScene()
120
 
        root = Player.getRootNode()
121
 
        self.node = avg.ImageNode(parent=root, href="rgb24-64x64.png")
 
175
        root = self.loadEmptyScene()
 
176
        self.node = avg.ImageNode(parent=root, pos=(10,10), href="rgb24-64x64.png")
122
177
        self.effect = avg.BlurFXNode()
123
178
        self.node.setEffect(self.effect)
124
 
        self.start(None,
125
 
                (lambda: self.compareImage("testBlurFX1", False),
126
 
                 lambda: self.effect.setParam(8),
 
179
        self.start((
 
180
                 lambda: self.compareImage("testBlurFX1", False),
 
181
                 lambda: setRadius(8),
127
182
                 lambda: self.compareImage("testBlurFX2", False),
128
183
                 removeFX,
129
184
                 lambda: self.compareImage("testBlurFX3", False),
134
189
                 lambda: self.compareImage("testBlurFX2", False),
135
190
                ))
136
191
 
 
192
    def testHueSatFX(self):
 
193
 
 
194
        def resetFX():
 
195
            self.effect = avg.HueSatFXNode()
 
196
            self.node.setEffect(self.effect)
 
197
 
 
198
        def setParam(param, value):
 
199
            assert(hasattr(self.effect, param))
 
200
            setattr(self.effect, param, value)
 
201
 
 
202
        root = self.loadEmptyScene()
 
203
        self.node = avg.ImageNode(parent=root, pos=(10,10), href="rgb24alpha-64x64.png")
 
204
        resetFX()
 
205
        self.start((
 
206
                lambda: self.compareImage("testHueSatFX1", False),
 
207
                lambda: setParam('saturation', -50),
 
208
                lambda: self.compareImage("testHueSatFX2", False),
 
209
                lambda: setParam('saturation', -100),
 
210
                lambda: self.compareImage("testHueSatFX3", False),
 
211
                lambda: setParam('saturation', -150),
 
212
                lambda: self.compareImage("testHueSatFX3", False),
 
213
                resetFX,
 
214
                lambda: setParam('hue', 180),
 
215
                lambda: self.compareImage("testHueSatFX4", False),
 
216
                lambda: setParam('hue', -180),
 
217
                lambda: self.compareImage("testHueSatFX4", False),
 
218
        ))
 
219
 
 
220
    def testInvertFX(self):
 
221
 
 
222
        def resetFX():
 
223
            self.effect = avg.InvertFXNode()
 
224
            self.node.setEffect(self.effect)
 
225
 
 
226
        def redAlphaScene():
 
227
            self.redRect = avg.RectNode(parent=self.root, pos=(5, 5), fillcolor='FF0000',
 
228
                    fillopacity=1, opacity=0, size=(72, 72))
 
229
            self.node = avg.ImageNode(parent=self.root, pos=(10,10),
 
230
                    href="../graphics/testfiles/rgb24alpha-64x64.png")
 
231
            resetFX()
 
232
 
 
233
        self.root = self.loadEmptyScene()
 
234
        self.node = avg.ImageNode(parent=self.root, pos=(10,10),
 
235
                href="../graphics/testfiles/hsl.png")
 
236
        resetFX()
 
237
        self.start((
 
238
                lambda: self.compareImage("testInvertFX1", False),
 
239
                redAlphaScene,
 
240
                lambda: self.compareImage("testInvertFX2", False),
 
241
        ))
 
242
 
137
243
    def testShadowFX(self):
138
 
        self.loadEmptyScene()
139
 
        root = Player.getRootNode()
140
 
        node = avg.ImageNode(parent=root, href="shadow.png")
 
244
        
 
245
        def setParams(offset, radius, opacity, color):
 
246
            effect.offset = offset
 
247
            effect.radius = radius
 
248
            effect.opacity = opacity
 
249
            effect.color =  color
 
250
 
 
251
        root = self.loadEmptyScene()
 
252
        rect = avg.RectNode(parent=root, pos=(9.5,9.5), color="0000FF")
 
253
        node = avg.ImageNode(parent=root, pos=(10,10), href="shadow.png")
 
254
        rect.size = node.size + (1, 1)
141
255
        effect = avg.ShadowFXNode()
142
256
        node.setEffect(effect)
143
 
        self.start(None,
144
 
                (lambda: self.compareImage("testShadowFX1", False),
145
 
                 lambda: effect.setParams((0,0), 3, 0.2, "00FFFF"),
 
257
        self.start((
 
258
                 lambda: self.compareImage("testShadowFX1", False),
 
259
                 lambda: setParams((0,0), 3, 2, "00FFFF"),
146
260
                 lambda: self.compareImage("testShadowFX2", False),
147
 
                 lambda: effect.setParams((2,2), 2, 0.2, "FFFFFF"),
 
261
                 lambda: setParams((2,2), 0.1, 1, "FFFFFF"),
148
262
                 lambda: self.compareImage("testShadowFX3", False),
 
263
                 lambda: setParams((-2,-2), 0.1, 1, "FFFFFF"),
 
264
                 lambda: self.compareImage("testShadowFX4", False),
 
265
                 lambda: setParams((-2,-2), 3, 1, "FFFFFF"),
 
266
                 lambda: self.compareImage("testShadowFX5", False),
 
267
                 lambda: setParams((0,0), 0, 1, "FFFFFF"),
 
268
                 lambda: self.compareImage("testShadowFX6", False),
 
269
                ))
 
270
 
 
271
    def testWordsShadowFX(self):
 
272
        root = self.loadEmptyScene()
 
273
        node = avg.WordsNode(parent=root, pos=(10,10), text="testtext", 
 
274
                font="Bitstream Vera Sans")
 
275
        effect = avg.ShadowFXNode()
 
276
        effect.setParams((0,0), 1.5, 1.5, "FF0000")
 
277
        node.setEffect(effect)
 
278
        self.start((
 
279
                 lambda: self.compareImage("testWordsShadowFX1", True),
 
280
                 lambda: effect.setParams((2,2), 2, 2, "00FFFF"),
 
281
                 lambda: self.compareImage("testWordsShadowFX2", True),
149
282
                ))
150
283
 
151
284
    def testGamma(self):
152
285
        def setGamma(val):
153
286
            node.gamma = val
154
287
 
155
 
        self.loadEmptyScene()
156
 
        root = Player.getRootNode()
 
288
        root = self.loadEmptyScene()
157
289
        node = avg.ImageNode(parent=root, href="colorramp.png", gamma=(0.5,0.5,0.5))
158
 
        self.assert_(node.gamma == (0.5,0.5,0.5))
159
 
        self.start(None,
160
 
                (lambda: self.compareImage("testGamma1", False),
 
290
        self.assertEqual(node.gamma, (0.5,0.5,0.5))
 
291
        self.start((
 
292
                 lambda: self.compareImage("testGamma1", False),
161
293
                 lambda: setGamma((1.5,2.0,2.5)),
162
 
                 lambda: self.assert_(node.gamma==(1.5,2.0,2.5)),
 
294
                 lambda: self.assertEqual(node.gamma, (1.5,2.0,2.5)),
163
295
                 lambda: self.compareImage("testGamma2", False),
164
296
                ))
165
297
 
179
311
                    intensity=(0.5,0.5,0.5), text="Half-brightness text.",
180
312
                    width=140)
181
313
 
182
 
        self.loadEmptyScene()
183
 
        root = Player.getRootNode()
 
314
        root = self.loadEmptyScene()
184
315
        node = avg.ImageNode(parent=root, href="colorramp.png", intensity=(0.5,0.5,0.5))
185
 
        self.assert_(node.intensity == (0.5,0.5,0.5))
 
316
        self.assertEqual(node.intensity, (0.5,0.5,0.5))
186
317
        Player.setFakeFPS(10)
187
 
        self.start(None,
188
 
                (lambda: self.compareImage("testIntensity1", False),
 
318
        self.start((
 
319
                 lambda: self.compareImage("testIntensity1", False),
189
320
                 lambda: setIntensity((1.5,2.0,2.5)),
190
 
                 lambda: self.assert_(node.intensity==(1.5,2.0,2.5)),
 
321
                 lambda: self.assertEqual(node.intensity, (1.5,2.0,2.5)),
191
322
                 lambda: self.compareImage("testIntensity2", False),
192
323
                 showVideo,
193
324
                 lambda: self.compareImage("testIntensity3", False),
207
338
                    href="../video/testfiles/mpeg1-48x48.mpg", contrast=(0.5,0.5,0.5))
208
339
            videoNode.play()
209
340
 
210
 
        self.loadEmptyScene()
211
 
        root = Player.getRootNode()
 
341
        root = self.loadEmptyScene()
212
342
        node = avg.ImageNode(parent=root, href="colorramp.png", contrast=(0.5,0.5,0.5))
213
 
        self.assert_(node.contrast == (0.5,0.5,0.5))
 
343
        self.assertEqual(node.contrast, (0.5,0.5,0.5))
214
344
        Player.setFakeFPS(10)
215
 
        self.start(None,
216
 
                (lambda: self.compareImage("testContrast1", False),
 
345
        self.start((
 
346
                 lambda: self.compareImage("testContrast1", False),
217
347
                 lambda: setContrast((1.5,2.0,2.5)),
218
 
                 lambda: self.assert_(node.contrast==(1.5,2.0,2.5)),
 
348
                 lambda: self.assertEqual(node.contrast, (1.5,2.0,2.5)),
219
349
                 lambda: self.compareImage("testContrast2", False),
220
350
                 showVideo,
221
351
                 lambda: self.compareImage("testContrast3", False),
222
352
                ))
223
353
        Player.setFakeFPS(-1)
224
354
 
 
355
    def testFXUpdate(self):
 
356
        # This tests if the FX render-on-demand functionality doesn't forget updates.
 
357
        def changeTexture():
 
358
            node.href = "colorramp.png"
 
359
 
 
360
        def addMaskTex():
 
361
            node.maskhref = "mask.png"
 
362
 
 
363
        def changeMaskTex():
 
364
            node.maskhref = "mask2.png"
 
365
 
 
366
        def changeMaskPos():
 
367
            node.maskpos = (10, 10)
 
368
 
 
369
        def changeFX():
 
370
            effect.radius = 2
 
371
 
 
372
        def addVideo():
 
373
            node.unlink(True)
 
374
            videoNode = avg.VideoNode(parent=root, threaded=False, size=(96,96),
 
375
                    href="../video/testfiles/mpeg1-48x48.mpg")
 
376
            effect = avg.BlurFXNode()
 
377
            effect.radius = 0
 
378
            videoNode.setEffect(effect)
 
379
            videoNode.play()
 
380
 
 
381
        root = self.loadEmptyScene()
 
382
        node = avg.ImageNode(parent=root, href="rgb24alpha-64x64.png")
 
383
        effect = avg.BlurFXNode()
 
384
        effect.radius = 0
 
385
        node.setEffect(effect)
 
386
        Player.setFakeFPS(25)
 
387
        self.start((
 
388
                 changeTexture,
 
389
                 lambda: self.compareImage("testFXUpdateTex", False),
 
390
                 addMaskTex,
 
391
                 lambda: self.compareImage("testFXUpdateMaskTex1", False),
 
392
                 changeMaskTex,
 
393
                 lambda: self.compareImage("testFXUpdateMaskTex2", False),
 
394
                 changeMaskPos,
 
395
                 lambda: self.compareImage("testFXUpdateMaskPos", False),
 
396
                 changeFX,
 
397
                 lambda: self.compareImage("testFXUpdateFX", False),
 
398
                 addVideo,
 
399
                 None,
 
400
                 lambda: self.compareImage("testFXUpdateVideo", False),
 
401
                ))
 
402
 
 
403
    def __createOffscreenCanvas(self):
 
404
        canvas = Player.createCanvas(id="offscreen", size=(160,120))
 
405
        root = canvas.getRootNode()
 
406
        avg.ImageNode(href="rgb24-32x32.png", parent=root)
 
407
        avg.ImageNode(id="test", pos=(32,0), href="rgb24alpha-32x32.png", parent=root)
 
408
        return canvas
 
409
 
225
410
def areFXSupported():
226
411
    sceneString = """<avg id="avg" width="160" height="120"/>"""
227
412
    Player.loadString(sceneString)
 
413
    root = Player.getRootNode()
228
414
    # XXX: The second of the following two lines prevent an opengl error in
229
415
    # testImageNullFX on the Mac (Snow Leopard) for some reason. 
230
 
    node = avg.ImageNode(href="rgb24-65x65.png", parent=Player.getRootNode())
231
 
    node = avg.ImageNode(href="rgb24-65x65.png", parent=Player.getRootNode())
 
416
    node = avg.ImageNode(href="rgb24-65x65.png", parent=root)
 
417
    node = avg.ImageNode(href="rgb24-65x65.png", parent=root)
232
418
    node.setEffect(avg.BlurFXNode())
233
419
    Player.setTimeout(0, Player.stop)
234
420
    try:
245
431
                "testVideoNullFX",
246
432
                "testWordsNullFX",
247
433
                "testCanvasNullFX",
 
434
                "testNodeInCanvasNullFX",
 
435
                "testRenderPipeline",
248
436
                "testBlurFX",
 
437
                "testHueSatFX",
 
438
                "testInvertFX",
249
439
                "testShadowFX",
 
440
                "testWordsShadowFX",
250
441
                "testGamma",
251
442
                "testIntensity",
252
443
                "testContrast",
 
444
                "testFXUpdate",
253
445
            ]
254
 
        return createAVGTestSuite(availableTests, FXTestCase, tests)
255
446
    else:
256
 
        print "Skipping FX tests - no FX support with this graphics configuration."
257
 
        return lambda x: None
 
447
        availableTests = []
 
448
    return createAVGTestSuite(availableTests, FXTestCase, tests)
258
449
 
259
450
Player = avg.Player.get()