def testMultiContactRegistration(self):
def onDown(event):
contact = event.contact
self.motionListenerID = contact.subscribe(avg.Contact.CURSOR_MOTION,
onContact2)
self.upListenerID = contact.subscribe(avg.Contact.CURSOR_UP, onContact2)
contact.subscribe(avg.Contact.CURSOR_MOTION, onContact1)
contact.subscribe(avg.Contact.CURSOR_UP, onContact1)
def onContact1(event):
if self.numContact1Callbacks == 0:
event.contact.unsubscribe(self.motionListenerID)
event.contact.unsubscribe(self.upListenerID)
self.numContact1Callbacks += 1
def onContact2(event):
self.assertEqual(self.numContact1Callbacks, 0)
self.numContact2Callbacks += 1
root = self.loadEmptyScene()
root.subscribe(avg.Node.CURSOR_DOWN, onDown)
player.setFakeFPS(25)
self.numContact1Callbacks = 0
self.numContact2Callbacks = 0
self.start(False,
(lambda: self._sendTouchEvent(1, avg.Event.CURSOR_DOWN, 10, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 20, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_UP, 10, 10),
))
self.assertEqual(self.numContact1Callbacks, 2)
# The order of callbacks is unspecified, so onContact2 might be called once.
self.assert_(self.numContact2Callbacks <= 1)
def initScene(self):
root = self.loadEmptyScene()
self.__node = avg.ImageNode(id="test",
pos=(64, 30),
href="rgb24-65x65.png",
parent=root)
player.setFakeFPS(10)
def testContactRegistration(self):
def onDown(event):
root.setEventCapture(event.cursorid)
root.releaseEventCapture(event.cursorid)
def onMotion(event):
contact = event.contact
self.contactID = contact.subscribe(avg.Contact.CURSOR_MOTION, onContactMotion)
self.numMotionCallbacks += 1
root.unsubscribe(avg.Node.CURSOR_DOWN, onDown)
root.unsubscribe(avg.Node.CURSOR_MOTION, onMotion)
def onContactMotion(event):
contact = event.contact
contact.unsubscribe(self.contactID)
self.assertRaises(avg.Exception, lambda: contact.unsubscribe(self.contactID))
self.numContactCallbacks += 1
root = self.loadEmptyScene()
root.subscribe(avg.Node.CURSOR_DOWN, onDown)
self.numMotionCallbacks = 0
root.subscribe(avg.Node.CURSOR_MOTION, onMotion)
self.numContactCallbacks = 0
player.setFakeFPS(25)
self.start(False,
(lambda: self._sendTouchEvent(1, avg.Event.CURSOR_DOWN, 10, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 20, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 30, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 40, 10),
))
self.assertEqual(self.numContactCallbacks, 1)
self.assertEqual(self.numMotionCallbacks, 1)
def testMultiWindowFX(self):
def setHueSat(node):
effect = avg.HueSatFXNode()
effect.saturation = -200
node.setEffect(effect)
def setBlur(node):
node.setEffect(avg.BlurFXNode(3))
def startVideo():
node.unlink(True)
self.videoNode = avg.VideoNode(href="mpeg1-48x48.mov",
size=(96, 96),
threaded=False,
parent=root)
self.videoNode.setEffect(avg.NullFXNode())
self.videoNode.play()
root = self.loadEmptyScene()
player.setWindowConfig("avgwindowconfig.xml")
node = avg.ImageNode(pos=(0, 0), href="rgb24-64x64.png", parent=root)
node.setEffect(avg.NullFXNode())
player.setFakeFPS(25)
self.start(False, (
lambda: self.compareImage("testMultiWindowFX1"),
lambda: setHueSat(node),
lambda: self.compareImage("testMultiWindowFX2"),
lambda: setBlur(node),
lambda: self.compareImage("testMultiWindowFX3"),
startVideo,
lambda: self.compareImage("testMultiWindowFXVideo1"),
lambda: setHueSat(self.videoNode),
lambda: self.compareImage("testMultiWindowFXVideo2"),
))
def testWarp(self):
def moveVertex():
grid = image.getWarpedVertexCoords()
grid[1][1] = (grid[1][1][0]+0.06, grid[1][1][1]+0.06)
image.setWarpedVertexCoords(grid)
grid = video.getWarpedVertexCoords()
grid[0][0] = (grid[0][0][0]+0.06, grid[0][0][1]+0.06)
grid[1][1] = (grid[1][1][0]-0.06, grid[1][1][1]-0.06)
video.setWarpedVertexCoords(grid)
def flip():
grid = image.getOrigVertexCoords()
grid = [ [ (1-pos[0], pos[1]) for pos in line ] for line in grid]
image.setWarpedVertexCoords(grid)
root = self.loadEmptyScene()
image = avg.ImageNode(href="rgb24-64x64.png",
maxtilewidth=32, maxtileheight=16, parent=root)
video = avg.VideoNode(pos=(40,0), size=(80,80), opacity=0.5, loop=True,
href="mpeg1-48x48.mov", threaded=False, fps=30, parent=root)
self.assertException(image.getOrigVertexCoords)
self.assertException(image.getWarpedVertexCoords)
player.setFakeFPS(30)
self.start(False,
(lambda: video.play(),
lambda: self.compareImage("testWarp1"),
moveVertex,
lambda: self.compareImage("testWarp2"),
flip,
lambda: self.compareImage("testWarp3")
))
def testVideoSeek(self):
def seek(frame):
videoNode.seekToFrame(frame)
def checkCurFrame():
self.assertEqual(videoNode.getCurFrame(), 26)
player.setFakeFPS(25)
for useCustomFPS in [False, True]:
root = self.loadEmptyScene()
if useCustomFPS:
videoNode = avg.VideoNode(parent=root,
loop=True,
size=(96, 96),
fps=25,
threaded=False,
href="mjpeg-48x48.avi")
else:
videoNode = avg.VideoNode(parent=root,
loop=True,
size=(96, 96),
threaded=False,
href="mjpeg-48x48.avi")
videoNode.play()
seek(26)
self.start(
False,
(checkCurFrame, lambda: self.compareImage("testVideoSeek0"),
lambda: seek(100),
lambda: self.compareImage("testVideoSeek1"),
lambda: videoNode.pause(), lambda: seek(26), None,
lambda: self.compareImage("testVideoSeek2"),
lambda: videoNode.play(), None,
lambda: self.compareImage("testVideoSeek3")))
def testSound(self):
def testSoundFile(filename):
def setVolume(volume):
node.volume = volume
def testGetVolume(volume):
self.assertAlmostEqual(node.volume, volume)
root = self.loadEmptyScene()
node = avg.SoundNode(href=filename, parent=root)
self.start(False,
(lambda: setVolume(0.5), lambda: testGetVolume(0.5),
lambda: node.play(), None, lambda: node.stop(),
lambda: node.play(), lambda: node.pause(),
lambda: node.play(), lambda: setVolume(0.5),
lambda: testGetVolume(0.5), lambda: node.pause(),
lambda: node.stop(), lambda: setVolume(0.3),
lambda: testGetVolume(0.3), lambda: node.pause()))
player.setFakeFPS(-1)
player.volume = 0
# "44.1kHz_mono.ogg" not tested for now - broken under Windows.
# Assuming buggy ffmpeg version.
for filename in [
"22.050Hz_16bit_mono.wav", "44.1kHz_16bit_stereo.aif",
"44.1kHz_16bit_stereo.wav", "44.1kHz_stereo.mp3",
"48kHz_24bit_stereo.wav"
]:
testSoundFile(filename)
def testMultiContactRegistration(self):
def onDown(event):
contact = event.contact
self.motionListenerID = contact.subscribe(
avg.Contact.CURSOR_MOTION, onContact2)
self.upListenerID = contact.subscribe(avg.Contact.CURSOR_UP,
onContact2)
contact.subscribe(avg.Contact.CURSOR_MOTION, onContact1)
contact.subscribe(avg.Contact.CURSOR_UP, onContact1)
def onContact1(event):
if self.numContact1Callbacks == 0:
event.contact.unsubscribe(self.motionListenerID)
event.contact.unsubscribe(self.upListenerID)
self.numContact1Callbacks += 1
def onContact2(event):
self.assertEqual(self.numContact1Callbacks, 0)
self.numContact2Callbacks += 1
root = self.loadEmptyScene()
root.subscribe(avg.Node.CURSOR_DOWN, onDown)
player.setFakeFPS(25)
self.numContact1Callbacks = 0
self.numContact2Callbacks = 0
self.start(False, (
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_DOWN, 10, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 20, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_UP, 10, 10),
))
self.assertEqual(self.numContact1Callbacks, 2)
# The order of callbacks is unspecified, so onContact2 might be called once.
self.assert_(self.numContact2Callbacks <= 1)
def testContactRegistration(self):
def onDown(event):
root.setEventCapture(event.cursorid)
root.releaseEventCapture(event.cursorid)
def onMotion(event):
contact = event.contact
self.contactID = contact.subscribe(avg.Contact.CURSOR_MOTION,
onContactMotion)
self.numMotionCallbacks += 1
root.unsubscribe(avg.Node.CURSOR_DOWN, onDown)
root.unsubscribe(avg.Node.CURSOR_MOTION, onMotion)
def onContactMotion(event):
contact = event.contact
contact.unsubscribe(self.contactID)
self.assertException(lambda: contact.unsubscribe(self.contactID))
self.numContactCallbacks += 1
root = self.loadEmptyScene()
root.subscribe(avg.Node.CURSOR_DOWN, onDown)
self.numMotionCallbacks = 0
root.subscribe(avg.Node.CURSOR_MOTION, onMotion)
self.numContactCallbacks = 0
player.setFakeFPS(25)
self.start(False, (
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_DOWN, 10, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 20, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 30, 10),
lambda: self._sendTouchEvent(1, avg.Event.CURSOR_MOTION, 40, 10),
))
self.assertEqual(self.numContactCallbacks, 1)
self.assertEqual(self.numMotionCallbacks, 1)
def testException(self):
class TestException(Exception):
pass
def throwException():
raise TestException
player.setFakeFPS(0.1)
videoNode = avg.VideoNode(threaded = False)
videoNode.href = "../testmediadir/mjpeg-48x48.avi"
videoNode.subscribe(avg.Node.END_OF_FILE, throwException)
root = self.loadEmptyScene()
root.appendChild(videoNode)
self.__exceptionThrown = False
try:
self.start(False,
(videoNode.pause,
lambda: videoNode.seekToFrame(videoNode.getNumFrames()),
videoNode.play,
lambda: None
))
except TestException:
self.__exceptionThrown = True
self.assert_(self.__exceptionThrown)
def testContrast(self):
def setContrast(val):
node.contrast = val
def showVideo():
node.unlink(True)
videoNode = avg.VideoNode(parent=root,
size=(96, 96),
threaded=False,
href="mpeg1-48x48.mov",
contrast=(0.5, 0.5, 0.5))
videoNode.play()
root = self.loadEmptyScene()
node = avg.ImageNode(parent=root,
href="colorramp.png",
contrast=(0.5, 0.5, 0.5))
self.assertEqual(node.contrast, (0.5, 0.5, 0.5))
player.setFakeFPS(10)
self.start(False, (
lambda: self.compareImage("testContrast1"),
lambda: setContrast((1.5, 2.0, 2.5)),
lambda: self.assertEqual(node.contrast, (1.5, 2.0, 2.5)),
lambda: self.compareImage("testContrast2"),
showVideo,
lambda: self.compareImage("testContrast3"),
))
player.setFakeFPS(-1)
def testVideoHRef(self):
def testGetMediaSize():
self.assertEqual(node.getMediaSize(), (48, 48))
def setHRefLoaded():
node.href = "h264-48x48.h264"
def setHRefUnloaded():
node = avg.VideoNode()
node.href = "h264-48x48.h264"
node.play()
def testVideoNotFound():
# Missing file, but no play() or pause(): Should just work.
node = avg.VideoNode(href="MissingFile.mov")
node.href = "SecondMissingFile.mov"
# Now libavg notices the missing file.
self.assertRaises(avg.Exception, node.play)
def testVideoBroken():
node = avg.VideoNode(href="SimpleSkin.xml")
self.assertRaises(avg.Exception, node.play)
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov",
threaded=False,
parent=root)
player.setFakeFPS(25)
testVideoNotFound()
testVideoBroken()
setHRefUnloaded()
self.start(False,
(lambda: node.play(), testGetMediaSize, setHRefLoaded,
lambda: self.compareImage("testVideoHRef1"),
testGetMediaSize, testVideoNotFound, testVideoBroken))
def testMultiWindowFX(self):
def setHueSat(node):
effect = avg.HueSatFXNode()
effect.saturation = -200
node.setEffect(effect)
def setBlur(node):
node.setEffect(avg.BlurFXNode(3))
def startVideo():
node.unlink(True)
self.videoNode = avg.VideoNode(href="mpeg1-48x48.mov", size=(96,96),
threaded=False, parent=root)
self.videoNode.setEffect(avg.NullFXNode())
self.videoNode.play()
root = self.loadEmptyScene()
player.setWindowConfig("avgwindowconfig.xml")
node = avg.ImageNode(pos=(0,0), href="rgb24-64x64.png", parent=root)
node.setEffect(avg.NullFXNode())
player.setFakeFPS(25)
self.start(False,
(self.skipIfMinimalShader,
lambda: self.compareImage("testMultiWindowFX1"),
lambda: setHueSat(node),
lambda: self.compareImage("testMultiWindowFX2"),
lambda: setBlur(node),
lambda: self.compareImage("testMultiWindowFX3"),
startVideo,
lambda: self.compareImage("testMultiWindowFXVideo1"),
lambda: setHueSat(self.videoNode),
lambda: self.compareImage("testMultiWindowFXVideo2"),
))
def testComplexDiv(self):
def setImageID(imgNode):
imgNode.id = "imageid"
def createDiv():
imgNode = player.createNode("image",
{"id":"imageid", "href":"rgb24-64x64.png"})
node = player.createNode("div", {"id":"divid"})
node.appendChild(imgNode)
imgNode.id = "imageid"
root.appendChild(node)
self.assertRaises(RuntimeError, lambda: setImageID(imgNode))
def removeDiv():
node = player.getElementByID("divid")
imgNode = player.getElementByID("imageid")
node.unlink()
imgNode.id = "imageid"
imgNode.unlink()
root.appendChild(node)
node.appendChild(imgNode)
self.assertRaises(RuntimeError, lambda: setImageID(imgNode))
root = self.loadEmptyScene()
createDiv()
removeDiv()
player.stop()
root = self.loadEmptyScene()
player.setFakeFPS(25)
self.start(False,
(createDiv,
lambda: self.compareImage("testComplexDiv1"),
removeDiv,
lambda: self.compareImage("testComplexDiv1"),
))
def testWarp(self):
def moveVertex():
grid = image.getWarpedVertexCoords()
grid[1][1] = (grid[1][1][0]+0.06, grid[1][1][1]+0.06)
image.setWarpedVertexCoords(grid)
grid = video.getWarpedVertexCoords()
grid[0][0] = (grid[0][0][0]+0.06, grid[0][0][1]+0.06)
grid[1][1] = (grid[1][1][0]-0.06, grid[1][1][1]-0.06)
video.setWarpedVertexCoords(grid)
def flip():
grid = image.getOrigVertexCoords()
grid = [ [ (1-pos[0], pos[1]) for pos in line ] for line in grid]
image.setWarpedVertexCoords(grid)
root = self.loadEmptyScene()
image = avg.ImageNode(href="rgb24-64x64.png",
maxtilewidth=32, maxtileheight=16, parent=root)
video = avg.VideoNode(pos=(40,0), size=(80,80), opacity=0.5, loop=True,
href="mpeg1-48x48.mpg", threaded=False, fps=30, parent=root)
self.assertException(image.getOrigVertexCoords)
self.assertException(image.getWarpedVertexCoords)
player.setFakeFPS(30)
self.start(False,
(lambda: video.play(),
lambda: self.compareImage("testWarp1"),
moveVertex,
lambda: self.compareImage("testWarp2"),
flip,
lambda: self.compareImage("testWarp3")
))
def testLoop(self):
def onEOF():
self.eof = True
def onFrame():
if self.eof:
if not threaded:
self.compareImage("testVideoLoop")
player.stop()
for audio, threaded in [(False, False), (False, True), (True, True)]:
self.eof = False
if audio:
player.setFakeFPS(-1)
else:
player.setFakeFPS(25)
root = self.loadEmptyScene()
if audio:
node = avg.SoundNode(parent=root, loop=True,
href="48kHz_16bit_mono.wav")
else:
node = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96),
threaded=threaded, href="mpeg1-48x48.mov")
node.subscribe(avg.Node.END_OF_FILE, onEOF)
node.play()
player.subscribe(player.ON_FRAME, onFrame)
player.play()
def testVideoSeek(self):
def seek(frame):
videoNode.seekToFrame(frame)
self.assert_(videoNode.isSeeking())
def checkCurFrame():
self.assertEqual(videoNode.getCurFrame(), 26)
self.assert_(not(videoNode.isSeeking())),
player.setFakeFPS(25)
for useCustomFPS in [False, True]:
root = self.loadEmptyScene()
if useCustomFPS:
videoNode = avg.VideoNode(parent=root, loop=True, size=(96,96), fps=25,
threaded=False, href="mjpeg-48x48.avi")
else:
videoNode = avg.VideoNode(parent=root, loop=True, size=(96,96),
threaded=False, href="mjpeg-48x48.avi")
videoNode.play()
videoNode.seekToFrame(26)
self.start(False,
(checkCurFrame,
lambda: self.compareImage("testVideoSeek0"),
lambda: seek(100),
lambda: self.compareImage("testVideoSeek1"),
lambda: videoNode.pause(),
lambda: seek(26),
None,
lambda: self.compareImage("testVideoSeek2"),
lambda: videoNode.play(),
None,
lambda: self.compareImage("testVideoSeek3")
))
def testException(self):
class TestException(Exception):
pass
def throwException():
raise TestException
player.setFakeFPS(0.1)
videoNode = avg.VideoNode(threaded=False)
videoNode.href = "../testmediadir/mjpeg-48x48.avi"
videoNode.subscribe(avg.Node.END_OF_FILE, throwException)
root = self.loadEmptyScene()
root.appendChild(videoNode)
self.__exceptionThrown = False
try:
self.start(
False,
(videoNode.pause,
lambda: videoNode.seekToFrame(videoNode.getNumFrames()),
videoNode.play, lambda: None))
except TestException:
self.__exceptionThrown = True
self.assert_(self.__exceptionThrown)
def testWithFile(filename, testImgName):
def setMask(href):
video.maskhref = href
video.masksize = (32,32)
def setOpacity():
video.opacity = 0.5
def setMaskBitmap():
video.setMaskBitmap(avg.Bitmap("media/mask4.png"))
print " ", filename
player.setFakeFPS(25)
root = self.loadEmptyScene()
video = avg.VideoNode(href=filename, threaded=False,
parent=root)
video.play()
self.start(False,
(lambda: setMask("mask4.png"),
lambda: self.compareImage(testImgName+"1"),
lambda: video.seekToFrame(10),
lambda: setMask(""),
lambda: self.compareImage(testImgName+"2"),
lambda: setMask("mask2.png"),
lambda: self.compareImage(testImgName+"3"),
setOpacity,
lambda: self.compareImage(testImgName+"4"),
setMaskBitmap,
lambda: self.compareImage(testImgName+"5"),
))
def testWithFile(filename, testImgName):
def setMask(href):
video.maskhref = href
video.masksize = (32, 32)
def setOpacity():
video.opacity = 0.5
def setMaskBitmap():
video.setMaskBitmap(avg.Bitmap("media/mask4.png"))
print " ", filename
player.setFakeFPS(25)
root = self.loadEmptyScene()
video = avg.VideoNode(href=filename, threaded=False, parent=root)
video.play()
self.start(False, (
lambda: setMask("mask4.png"),
lambda: self.compareImage(testImgName + "1"),
lambda: video.seekToFrame(10),
lambda: setMask(""),
lambda: self.compareImage(testImgName + "2"),
lambda: setMask("mask2.png"),
lambda: self.compareImage(testImgName + "3"),
setOpacity,
lambda: self.compareImage(testImgName + "4"),
setMaskBitmap,
lambda: self.compareImage(testImgName + "5"),
))
def testLoop(self):
def onEOF():
self.eof = True
def onFrame():
if self.eof:
if not threaded:
self.compareImage("testVideoLoop")
player.stop()
for audio, threaded in [(False, False), (False, True), (True, True)]:
self.eof = False
if audio:
player.setFakeFPS(-1)
else:
player.setFakeFPS(25)
root = self.loadEmptyScene()
if audio:
node = avg.SoundNode(parent=root,
loop=True,
href="48kHz_16bit_mono.wav")
else:
node = avg.VideoNode(parent=root,
loop=True,
fps=25,
size=(96, 96),
threaded=threaded,
href="mpeg1-48x48.mov")
node.subscribe(avg.Node.END_OF_FILE, onEOF)
node.play()
player.subscribe(player.ON_FRAME, onFrame)
player.play()
def testSound(self):
def testSoundFile(filename):
def setVolume(volume):
node.volume = volume
def testGetVolume(volume):
self.assertAlmostEqual(node.volume, volume)
root = self.loadEmptyScene()
node = avg.SoundNode(href=filename, parent=root)
self.start(False,
(lambda: setVolume(0.5),
lambda: testGetVolume(0.5),
lambda: node.play(),
None,
lambda: node.stop(),
lambda: node.play(),
lambda: node.pause(),
lambda: node.play(),
lambda: setVolume(0.5),
lambda: testGetVolume(0.5),
lambda: node.pause(),
lambda: node.stop(),
lambda: setVolume(0.3),
lambda: testGetVolume(0.3),
lambda: node.pause()
))
player.setFakeFPS(-1)
player.volume = 0
# "44.1kHz_mono.ogg" not tested for now - broken under Windows.
# Assuming buggy ffmpeg version.
for filename in ["22.050Hz_16bit_mono.wav", "44.1kHz_16bit_stereo.aif",
"44.1kHz_16bit_stereo.wav", "44.1kHz_stereo.mp3",
"48kHz_24bit_stereo.wav"]:
testSoundFile(filename)
def testVideoState(self):
for accelerated in [True, False]:
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov",
size=(96, 96),
threaded=False,
accelerated=accelerated,
parent=root)
player.setFakeFPS(25)
self.start(False, (
lambda: node.play(),
lambda: self.compareImage("testVideoState1"),
lambda: node.pause(),
lambda: self.compareImage("testVideoState2"),
lambda: self.compareImage("testVideoState2"),
lambda: node.play(),
lambda: self.compareImage("testVideoState3"),
lambda: node.stop(),
lambda: self.compareImage("testVideoState4"),
lambda: node.pause(),
lambda: self.compareImage("testVideoState5"),
lambda: self.compareImage("testVideoState5"),
lambda: node.stop(),
lambda: self.compareImage("testVideoState4"),
))
def testBitmapManager(self):
WAIT_TIMEOUT = 5000
def expectException(returnValue, nextAction):
if isinstance(returnValue, Exception):
nextAction()
else:
raise RuntimeError("Expected exception, got %s (%s)" % (
returnValue, type(returnValue)))
def loadValidBitmap():
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
player.setTimeout(0, loadBitmapWithPixelFormat)
bitmapManager.loadBitmap("media/rgb24alpha-64x64.png", validBitmapCb)
def loadBitmapWithPixelFormat():
def validBitmapCb(bitmap):
self.assert_(not isinstance(bitmap, Exception))
self.assert_(bitmap.getFormat() == avg.B5G6R5)
player.setTimeout(0, loadUnexistentBitmap)
bitmapManager.loadBitmap("media/rgb24alpha-64x64.png",
validBitmapCb, avg.B5G6R5)
def loadUnexistentBitmap():
bitmapManager.loadBitmap("nonexistent.png",
lambda bmp: expectException(
returnValue=bmp,
nextAction=lambda: player.setTimeout(0, loadBrokenBitmap)))
def loadBrokenBitmap():
import tempfile
tempFileName = os.path.join(tempfile.gettempdir(),
"broken.png")
open(tempFileName, "w")
def cleanupAndTestReturnValue(returnValue):
os.unlink(tempFileName)
expectException(returnValue=returnValue, nextAction=player.stop)
bitmapManager.loadBitmap(tempFileName, cleanupAndTestReturnValue)
def reportStuck():
raise RuntimeError("BitmapManager didn't reply "
"within %dms timeout" % WAIT_TIMEOUT)
player.setFakeFPS(-1)
sys.stderr.write("\n")
for multithread in [False, True]:
bitmapManager = avg.BitmapManager.get()
sys.stderr.write(" Multithread: "+str(multithread)+"\n")
self.loadEmptyScene()
if multithread:
bitmapManager.setNumThreads(2)
player.setTimeout(WAIT_TIMEOUT, reportStuck)
loadValidBitmap()
player.play()
avg.BitmapManager.get().setNumThreads(1)
def testVideoNullFX(self):
root = self.loadEmptyScene()
player.setFakeFPS(25)
node = avg.VideoNode(parent=root, href="mjpeg-48x48.avi",
threaded=False)
node.setEffect(avg.NullFXNode())
node.play()
self.start(False, (lambda: self.compareImage("testVideoNullFX"),))
def testVideoNullFX(self):
root = self.loadEmptyScene()
player.setFakeFPS(25)
node = avg.VideoNode(parent=root, href="mjpeg-48x48.avi",
threaded=False)
node.setEffect(avg.NullFXNode())
node.play()
self.start(False, (lambda: self.compareImage("testVideoNullFX"),))
def testFakeTime(self):
def checkTime():
self.assertEqual(player.getFrameTime(), 50)
self.assertEqual(player.getFrameDuration(), 50)
self.assertEqual(player.getEffectiveFramerate(), 20)
self.loadEmptyScene()
player.setFakeFPS(20)
self.start(False, (checkTime, ))
def testFakeTime(self):
def checkTime():
self.assertEqual(player.getFrameTime(), 50)
self.assertEqual(player.getFrameDuration(), 50)
self.assertEqual(player.getEffectiveFramerate(), 20)
self.loadEmptyScene()
player.setFakeFPS(20)
self.start(False, (checkTime,))
def test2VideosAtOnce(self):
player.setFakeFPS(25)
self.loadEmptyScene()
root = player.getRootNode()
for pos in ((0,0), (80,0)):
video = avg.VideoNode(pos=pos, threaded=False, href="mpeg1-48x48.mov",
parent=root)
video.play()
self.start(False,
[lambda: self.compareImage("test2VideosAtOnce1"),])
def test2VideosAtOnce(self):
player.setFakeFPS(25)
self.loadEmptyScene()
root = player.getRootNode()
for pos in ((0,0), (80,0)):
video = avg.VideoNode(pos=pos, threaded=False, href="mpeg1-48x48.mov",
parent=root)
video.play()
self.start(False,
[lambda: self.compareImage("test2VideosAtOnce1"),])
def testCropMovie(self):
def playMovie():
node = player.getElementByID("movie")
node.play()
def moveTLCrop():
node = player.getElementByID("movie")
node.x = -20
node.y = -20
def moveBRCrop():
node = player.getElementByID("movie")
node.x = 60
node.y = 40
def moveTLNegative():
node = player.getElementByID("movie")
node.x = -60
node.y = -50
def moveBRGone():
node = player.getElementByID("movie")
node.x = 140
node.y = 100
def rotate():
node = player.getElementByID("movie")
node.x = 10
node.y = 10
player.getElementByID("nestedavg").angle = 1.0
player.getElementByID("bkgd").angle = 1.0
player.setFakeFPS(30)
root = self.loadEmptyScene()
avg.ImageNode(id="bkgd", href="crop_bkgd.png", parent=root)
root.appendChild(
player.createNode("""
<div id="nestedavg" x="40" y="30" width="80" height="60" crop="True">
<video id="movie" x="10" y="10" width="40" height="40"
threaded="false" href="mpeg1-48x48.mov"
fps="30"/>
</div>
"""))
self.start(
False,
(playMovie, lambda: self.compareImage("testCropMovie1"),
moveTLCrop, lambda: self.compareImage("testCropMovie2"),
moveBRCrop, lambda: self.compareImage("testCropMovie3"),
moveTLNegative, lambda: self.compareImage("testCropMovie4"),
moveBRGone, lambda: self.compareImage("testCropMovie5"), rotate,
lambda: self.compareImage("testCropMovie6"), moveTLCrop,
lambda: self.compareImage("testCropMovie7"), moveBRCrop,
lambda: self.compareImage("testCropMovie8"), moveTLNegative,
lambda: self.compareImage("testCropMovie9"), moveBRGone,
lambda: self.compareImage("testCropMovie10")))
def testVideoFPS(self):
player.setFakeFPS(25)
root = self.loadEmptyScene()
root = root
videoNode = avg.VideoNode(size=(80,80), loop=True, threaded=False,
href="mjpeg-48x48.avi", fps=250, parent=root)
self.start(False,
(lambda: videoNode.play(),
None,
lambda: self.compareImage("testVideoFPS")
))
def testNonNodeAttrAnim(self):
class GenericClass(object):
def __init__(self):
self.numberValue = 0
self.pointValue = avg.Point2D(0.0, 0.0)
def on1Stop():
self.__onStopCalled = True
def on2Start():
self.__onStopBeforeOnStart = self.__onStopCalled
self.loadEmptyScene()
player.setFakeFPS(10)
genericObject1 = GenericClass()
genericObject2 = genericObject1
genericObject3 = GenericClass()
anim1 = avg.LinearAnim(genericObject1, "numberValue", 1000, 0, 100,
False, None, on1Stop)
anim2 = avg.LinearAnim(genericObject2, "numberValue", 1200, 0, 200,
False, on2Start)
anim3 = avg.LinearAnim(genericObject1, "pointValue", 800, (0, 0), (100, 200))
anim4 = avg.LinearAnim(genericObject3, "numberValue", 400, 0, 42)
self.__onStopCalled = False
self.__onStopBeforeOnStart = False
self.start(False,
(lambda: anim1.start(),
lambda: self.assert_(anim1.isRunning()),
lambda: self.assert_(not(self.__onStopCalled)),
lambda: anim2.start(),
lambda: self.assert_(self.__onStopBeforeOnStart),
lambda: self.assert_(not(anim1.isRunning())),
lambda: self.assert_(anim2.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 1),
lambda: anim3.start(),
lambda: self.assert_(anim2.isRunning()),
lambda: self.assert_(anim3.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 2),
lambda: anim4.start(),
lambda: self.assert_(anim4.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 3),
lambda: self.delay(200),
lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
lambda: self.assert_(genericObject1.numberValue == 200),
lambda: self.assert_(genericObject2.pointValue == (100, 200)),
lambda: self.assert_(genericObject3.numberValue == 42)
))
anim1 = None
anim2 = None
anim3 = None
anim4 = None
genericObject1 = None
genericObject2 = None
genericObject3 = None
def testSoundSeek(self):
player.setFakeFPS(-1)
player.volume = 0
root = self.loadEmptyScene()
soundNode = avg.SoundNode(parent=root, href="44.1kHz_16bit_stereo.wav")
soundNode.play()
soundNode.seekToTime(500)
self.start(False,
(None,
lambda: soundNode.seekToTime(200),
))
def testSoundSeek(self):
player.setFakeFPS(-1)
player.volume = 0
root = self.loadEmptyScene()
soundNode = avg.SoundNode(parent=root, href="44.1kHz_16bit_stereo.wav")
soundNode.play()
soundNode.seekToTime(500)
self.start(False,
(None,
lambda: soundNode.seekToTime(200),
))
def testVideoFPS(self):
player.setFakeFPS(25)
root = self.loadEmptyScene()
root = root
videoNode = avg.VideoNode(size=(80,80), loop=True, threaded=False,
href="mjpeg-48x48.avi", fps=250, parent=root)
self.start(False,
(lambda: videoNode.play(),
None,
lambda: self.compareImage("testVideoFPS")
))
def testPlayBeforeConnect(self):
node = avg.VideoNode(href="media/mpeg1-48x48.mov", threaded=False)
node.play()
player.createMainCanvas(size=(160,120))
root = player.getRootNode()
root.insertChild(node, 0)
player.setFakeFPS(25)
self.start(False,
(lambda: self.assertEqual(node.size, (48, 48)),
lambda: self.compareImage("testPlayBeforeConnect"),
))
def testPlayBeforeConnect(self):
node = avg.VideoNode(href="media/mpeg1-48x48.mov", threaded=False)
node.play()
player.createMainCanvas(size=(160,120))
root = player.getRootNode()
root.insertChild(node, 0)
player.setFakeFPS(25)
self.start(False,
(lambda: self.assertEqual(node.size, (48, 48)),
lambda: self.compareImage("testPlayBeforeConnect"),
))
def testNonNodeAttrAnim(self):
class GenericClass(object):
def __init__(self):
self.numberValue = 0
self.pointValue = avg.Point2D(0.0, 0.0)
def on1Stop():
self.__onStopCalled = True
def on2Start():
self.__onStopBeforeOnStart = self.__onStopCalled
self.loadEmptyScene()
player.setFakeFPS(10)
genericObject1 = GenericClass()
genericObject2 = genericObject1
genericObject3 = GenericClass()
anim1 = avg.LinearAnim(genericObject1, "numberValue", 1000, 0, 100,
False, None, on1Stop)
anim2 = avg.LinearAnim(genericObject2, "numberValue", 1200, 0, 200,
False, on2Start)
anim3 = avg.LinearAnim(genericObject1, "pointValue", 800, (0, 0),
(100, 200))
anim4 = avg.LinearAnim(genericObject3, "numberValue", 400, 0, 42)
self.__onStopCalled = False
self.__onStopBeforeOnStart = False
self.start(
False,
(lambda: anim1.start(), lambda: self.assert_(anim1.isRunning()),
lambda: self.assert_(not (self.__onStopCalled)),
lambda: anim2.start(),
lambda: self.assert_(self.__onStopBeforeOnStart),
lambda: self.assert_(not (anim1.isRunning())),
lambda: self.assert_(anim2.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 1),
lambda: anim3.start(), lambda: self.assert_(anim2.isRunning()),
lambda: self.assert_(anim3.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 2),
lambda: anim4.start(), lambda: self.assert_(anim4.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 3),
lambda: self.delay(200),
lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
lambda: self.assert_(genericObject1.numberValue == 200),
lambda: self.assert_(genericObject2.pointValue == (100, 200)),
lambda: self.assert_(genericObject3.numberValue == 42)))
anim1 = None
anim2 = None
anim3 = None
anim4 = None
genericObject1 = None
genericObject2 = None
genericObject3 = None
def testWarp(self):
def moveVertex():
grid = image.getWarpedVertexCoords()
grid[1][1] = (grid[1][1][0] + 0.06, grid[1][1][1] + 0.06)
image.setWarpedVertexCoords(grid)
grid = video.getWarpedVertexCoords()
grid[0][0] = (grid[0][0][0] + 0.06, grid[0][0][1] + 0.06)
grid[1][1] = (grid[1][1][0] - 0.06, grid[1][1][1] - 0.06)
video.setWarpedVertexCoords(grid)
def flip():
grid = image.getOrigVertexCoords()
grid = [[(1 - pos[0], pos[1]) for pos in line] for line in grid]
image.setWarpedVertexCoords(grid)
def changeHref():
image.href = "rgb24-65x65.png"
grid = image.getWarpedVertexCoords()
self.assert_(len(grid) == 6)
self.assert_(len(grid[0]) == 4)
root = self.loadEmptyScene()
image = avg.ImageNode(href="rgb24-64x64.png",
maxtilewidth=32,
maxtileheight=16,
parent=root)
video = avg.VideoNode(pos=(40, 0),
size=(80, 80),
opacity=0.5,
loop=True,
href="mpeg1-48x48.mov",
threaded=False,
fps=30,
parent=root)
self.assertRaises(avg.Exception, image.getOrigVertexCoords)
self.assertRaises(avg.Exception, image.getWarpedVertexCoords)
player.setFakeFPS(30)
self.start(False, (
lambda: video.play(),
lambda: self.compareImage("testWarp1"),
moveVertex,
lambda: self.compareImage("testWarp2"),
flip,
lambda: self.compareImage("testWarp3"),
changeHref,
lambda: self.compareImage("testWarp4"),
lambda: image.setMirror(avg.RasterNode.HORIZONTAL),
lambda: self.compareImage("testWarp5"),
lambda: image.setMirror(avg.RasterNode.VERTICAL),
lambda: self.compareImage("testWarp6"),
))
def testFXUpdate(self):
# This tests if the FX render-on-demand functionality doesn't forget updates.
def changeTexture():
node.href = "colorramp.png"
def addMaskTex():
node.maskhref = "mask.png"
def changeMaskTex():
node.maskhref = "mask2.png"
def changeMaskPos():
node.maskpos = (10, 10)
def changeFX():
effect.radius = 2
def addVideo():
node.unlink(True)
videoNode = avg.VideoNode(parent=root, threaded=False, size=(96,96),
href="mpeg1-48x48.mpg")
effect = avg.BlurFXNode()
effect.radius = 0
videoNode.setEffect(effect)
videoNode.play()
if player.isUsingGLES():
self.skip("Not supported under GLES")
return
root = self.loadEmptyScene()
node = avg.ImageNode(parent=root, href="rgb24alpha-64x64.png")
effect = avg.BlurFXNode()
effect.radius = 0
node.setEffect(effect)
player.setFakeFPS(25)
self.start(False,
(changeTexture,
lambda: self.compareImage("testFXUpdateTex"),
addMaskTex,
lambda: self.compareImage("testFXUpdateMaskTex1"),
changeMaskTex,
lambda: self.compareImage("testFXUpdateMaskTex2"),
changeMaskPos,
lambda: self.compareImage("testFXUpdateMaskPos"),
changeFX,
lambda: self.compareImage("testFXUpdateFX"),
addVideo,
None,
lambda: self.compareImage("testFXUpdateVideo"),
))
def testFXUpdate(self):
# This tests if the FX render-on-demand functionality doesn't forget updates.
def changeTexture():
node.href = "colorramp.png"
def addMaskTex():
node.maskhref = "mask4.png"
node.masksize = (32, 32)
def changeMaskTex():
node.maskhref = "mask2.png"
def changeMaskPos():
node.maskpos = (32, 32)
def changeFX():
effect.radius = 2
def addVideo():
node.unlink(True)
videoNode = avg.VideoNode(parent=root,
threaded=False,
size=(96, 96),
href="mpeg1-48x48.mov")
effect = avg.BlurFXNode()
effect.radius = 0
videoNode.setEffect(effect)
videoNode.play()
root = self.loadEmptyScene()
node = avg.ImageNode(parent=root, href="rgb24alpha-64x64.png")
effect = avg.BlurFXNode()
effect.radius = 0
player.setFakeFPS(25)
self.start(False, (
self.skipIfMinimalShader,
lambda: node.setEffect(effect),
changeTexture,
lambda: self.compareImage("testFXUpdateTex"),
addMaskTex,
lambda: self.compareImage("testFXUpdateMaskTex1"),
changeMaskTex,
lambda: self.compareImage("testFXUpdateMaskTex2"),
changeMaskPos,
lambda: self.compareImage("testFXUpdateMaskPos"),
changeFX,
lambda: self.compareImage("testFXUpdateFX"),
addVideo,
None,
lambda: self.compareImage("testFXUpdateVideo"),
))
def testCallFromThread(self):
def onAsyncCall():
self.asyncCalled = True
def threadFunc():
player.callFromThread(onAsyncCall)
def startThread():
self.thread = threading.Thread(target=threadFunc)
self.thread.start()
self.initDefaultImageScene()
self.asyncCalled = False
player.setFakeFPS(-1)
self.start(False, (startThread, lambda: self.thread.join(), None, lambda: self.assert_(self.asyncCalled)))
def runTest(useXml):
self.root = self.loadEmptyScene()
createNode1(useXml)
player.stop()
self.root = self.loadEmptyScene()
player.setFakeFPS(25)
self.start(warnOnImageDiff,
(lambda: createNode1(useXml),
lambda: self.compareImage(testName + "1"),
lambda: createNode2(useXml),
lambda: self.compareImage(testName + "2"), reorderNode,
lambda: self.compareImage(testName + "3"), removeNodes,
lambda: self.compareImage(testName + "4"), reAddNode,
lambda: self.compareImage(testName + "5"), killNode,
reAddNode, reAddNode2, removeAgain))
def testDragRecognizerRelCoords(self):
def onDrag(offset):
self.assertAlmostEqual(offset, (-40,-40))
player.setFakeFPS(100)
for self.friction in (-1, 100):
root = self.loadEmptyScene()
div = avg.DivNode(pos=(64,64), angle=math.pi, parent=root)
image = avg.ImageNode(parent=div, href="rgb24-64x64.png")
ui.DragRecognizer(image, moveHandler=onDrag, friction=self.friction)
self.start(False,
(lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 30, 30),
lambda: self._sendMouseEvent(avg.Event.CURSOR_MOTION, 70, 70),
))
player.setFakeFPS(-1)
def testSimpleScrollArea(self):
def onContentPosChanged(newPos):
self.messageTester.setMessageReceived(self.node.CONTENT_POS_CHANGED)
root = self.loadEmptyScene()
image = avg.ImageNode(href="rgb24-64x64.png", size=(200,400))
self.node = simple.ScrollArea(contentNode=image, size=(115,115),
friction=-1, parent=root)
self.messageTester = MessageTester(self.node, [self.node.PRESSED,
self.node.RELEASED], self)
self.node.subscribe(self.node.CONTENT_POS_CHANGED, onContentPosChanged)
player.setFakeFPS(10)
self.start(False,
(lambda: self.compareImage("testSimpleScrollArea1"),
lambda: self.node.setContentSize((400,200)),
lambda: self.compareImage("testSimpleScrollArea2"),
lambda: self.node.setContentPos((200,100)),
lambda: self.messageTester.assertState([self.node.CONTENT_POS_CHANGED]),
lambda: self.compareImage("testSimpleScrollArea3"),
lambda: self.node.setContentPos((0,0)),
# Scroll via gesture
self.messageTester.reset,
self._genMouseEventFrames(avg.Event.CURSOR_DOWN, 90, 90,
[self.node.PRESSED,]),
self._genMouseEventFrames(avg.Event.CURSOR_MOTION, 10, 90,
[self.node.CONTENT_POS_CHANGED]),
lambda: self.compareImage("testSimpleScrollArea4"),
self._genMouseEventFrames(avg.Event.CURSOR_UP, 10, 10,
[self.node.RELEASED,self.node.CONTENT_POS_CHANGED]),
lambda: self.compareImage("testSimpleScrollArea5"),
lambda: self.delay(1000), # Wait for end of inertia.
lambda: self.node.setContentPos((0,0)),
# Scroll using scroll bars
self.messageTester.reset,
lambda: self.compareImage("testSimpleScrollArea2"),
lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 110, 0),
lambda: self._sendMouseEvent(avg.Event.CURSOR_UP, 110, 50),
lambda: self.messageTester.assertState([self.node.CONTENT_POS_CHANGED]),
lambda: self.compareImage("testSimpleScrollArea6"),
lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 0, 110),
lambda: self._sendMouseEvent(avg.Event.CURSOR_UP, 50, 110),
lambda: self.messageTester.assertState([self.node.CONTENT_POS_CHANGED]),
lambda: self.compareImage("testSimpleScrollArea7"),
))
player.setFakeFPS(-1)
def testVideoActive(self):
def deactivate():
node.active = 0
def activate():
node.active = 1
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov",
size=(96, 96),
threaded=False,
parent=root)
player.setFakeFPS(25)
self.start(False,
(lambda: node.play(), deactivate,
lambda: self.compareImage("testVideoActive1"), activate,
lambda: self.compareImage("testVideoActive2")))
def testWithFile(filename, testImgName):
def hide():
self.videoNode.opacity = 0
def show():
self.videoNode.opacity = 1
player.setFakeFPS(25)
root = self.loadEmptyScene()
self.videoNode = avg.VideoNode(href=filename,
loop=True,
threaded=False,
parent=root)
self.start(
False,
(lambda: self.videoNode.play(), None,
lambda: self.compareImage(testImgName + "1"), hide, None,
None, show, lambda: self.compareImage(testImgName + "2")))
def testVideoActive(self):
def deactivate():
node.active=0
def activate():
node.active=1
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov", size=(96,96), threaded=False,
parent=root)
player.setFakeFPS(25)
self.start(False,
(lambda: node.play(),
deactivate,
lambda: self.compareImage("testVideoActive1"),
activate,
lambda: self.compareImage("testVideoActive2")
))
def testWarp(self):
def moveVertex():
grid = image.getWarpedVertexCoords()
grid[1][1] = (grid[1][1][0]+0.06, grid[1][1][1]+0.06)
image.setWarpedVertexCoords(grid)
grid = video.getWarpedVertexCoords()
grid[0][0] = (grid[0][0][0]+0.06, grid[0][0][1]+0.06)
grid[1][1] = (grid[1][1][0]-0.06, grid[1][1][1]-0.06)
video.setWarpedVertexCoords(grid)
def flip():
grid = image.getOrigVertexCoords()
grid = [ [ (1-pos[0], pos[1]) for pos in line ] for line in grid]
image.setWarpedVertexCoords(grid)
def changeHref():
image.href = "rgb24-65x65.png"
grid = image.getWarpedVertexCoords()
self.assert_(len(grid) == 6)
self.assert_(len(grid[0]) == 4)
root = self.loadEmptyScene()
image = avg.ImageNode(href="rgb24-64x64.png",
maxtilewidth=32, maxtileheight=16, parent=root)
video = avg.VideoNode(pos=(40,0), size=(80,80), opacity=0.5, loop=True,
href="mpeg1-48x48.mov", threaded=False, fps=30, parent=root)
self.assertRaises(avg.Exception, image.getOrigVertexCoords)
self.assertRaises(avg.Exception, image.getWarpedVertexCoords)
player.setFakeFPS(30)
self.start(False,
(lambda: video.play(),
lambda: self.compareImage("testWarp1"),
moveVertex,
lambda: self.compareImage("testWarp2"),
flip,
lambda: self.compareImage("testWarp3"),
changeHref,
lambda: self.compareImage("testWarp4"),
lambda: image.setMirror(avg.RasterNode.HORIZONTAL),
lambda: self.compareImage("testWarp5"),
lambda: image.setMirror(avg.RasterNode.VERTICAL),
lambda: self.compareImage("testWarp6"),
))
def testCanvasDrag(self):
def onDrag(offset):
self.assertAlmostEqual(offset, (-40,-40))
self.__onDragCalled = True
player.setFakeFPS(100)
self.__onDragCalled = False
mainCanvas, offscreenCanvas = self.__setupCanvas(True)
self.node.angle = math.pi
image = avg.ImageNode(parent=offscreenCanvas.getRootNode(), size=(160,120),
href="rgb24-64x64.png")
dragRecognizer = gesture.DragRecognizer(image, moveHandler=onDrag,
friction=-1)
self.start(False,
(lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 30, 30),
lambda: self._sendMouseEvent(avg.Event.CURSOR_MOTION, 70, 70),
))
player.setFakeFPS(-1)
self.assert_(self.__onDragCalled)
def testCanvasDrag(self):
def onDrag(offset):
self.assertAlmostEqual(offset, (-40,-40))
self.__onDragCalled = True
player.setFakeFPS(100)
self.__onDragCalled = False
mainCanvas, offscreenCanvas = self.__setupCanvas(True)
self.node.angle = math.pi
image = avg.ImageNode(parent=offscreenCanvas.getRootNode(), size=(160,120),
href="rgb24-64x64.png")
dragRecognizer = gesture.DragRecognizer(image, moveHandler=onDrag,
friction=-1)
self.start(False,
(lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 30, 30),
lambda: self._sendMouseEvent(avg.Event.CURSOR_MOTION, 70, 70),
))
player.setFakeFPS(-1)
self.assert_(self.__onDragCalled)
def testVideoLoop(self):
def onEOF():
self.eof = True
def onFrame():
if self.eof:
if not(threaded):
self.compareImage("testVideoLoop")
player.stop()
for threaded in [False, True]:
self.eof = False
player.setFakeFPS(25)
root = self.loadEmptyScene()
videoNode = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96),
threaded=threaded, href="mpeg1-48x48.mpg")
videoNode.subscribe(avg.Node.END_OF_FILE, onEOF)
videoNode.play()
player.subscribe(player.ON_FRAME, onFrame)
player.play()
def testVideoSeekAfterEOF(self):
def onEOF():
node.seekToTime(0)
player.subscribe(avg.Player.ON_FRAME, onFrame)
def onFrame():
if node.getCurTime() < 100:
self.compareImage("testSeekAfterEOF")
player.stop()
def onNoEOF():
self.fail("No EOF")
player.setFakeFPS(25)
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov", parent=root)
node.play()
node.subscribe(avg.VideoNode.END_OF_FILE, onEOF)
player.setTimeout(100000, onNoEOF)
player.play()
def testCallFromThread(self):
def onAsyncCall():
self.asyncCalled = True
def threadFunc():
player.callFromThread(onAsyncCall)
def startThread():
self.thread = threading.Thread(target=threadFunc)
self.thread.start()
self.initDefaultImageScene()
self.asyncCalled = False
player.setFakeFPS(-1)
self.start(False, (
startThread,
lambda: self.thread.join(),
None,
lambda: self.assert_(self.asyncCalled),
))
def testVideoSeekAfterEOF(self):
def onEOF():
node.seekToTime(0)
player.subscribe(avg.Player.ON_FRAME, onFrame)
def onFrame():
if node.getCurTime() < 100:
self.compareImage("testSeekAfterEOF")
player.stop()
def onNoEOF():
self.fail("No EOF")
player.setFakeFPS(25)
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48.mov", parent=root)
node.play()
node.subscribe(avg.VideoNode.END_OF_FILE, onEOF)
player.setTimeout(100000, onNoEOF)
player.play()
def testVideoEOF(self):
player.setFakeFPS(25)
for filename in ["mpeg1-48x48.mov", "mpeg1-48x48-sound.avi"]:
node = avg.VideoNode(href=filename)
self.testEOF(node)
node = avg.VideoNode(href="mpeg1-48x48.mov", opacity=0)
self.testEOF(node)
root = self.loadEmptyScene()
video = avg.VideoNode(href="mpeg1-48x48.mov", threaded=False,
parent=root)
player.setFakeFPS(0.1)
# Should never be called
eofID = video.subscribe(avg.Node.END_OF_FILE, lambda: self.assert_(False))
self.start(False,
(lambda: video.unsubscribe(avg.Node.END_OF_FILE, eofID),
video.play,
None
))
def runTest(useXml):
self.root = self.loadEmptyScene()
createNode1(useXml)
player.stop()
self.root = self.loadEmptyScene()
player.setFakeFPS(25)
self.start(warnOnImageDiff,
(lambda: createNode1(useXml),
lambda: self.compareImage(testName+"1"),
lambda: createNode2(useXml),
lambda: self.compareImage(testName+"2"),
reorderNode,
lambda: self.compareImage(testName+"3"),
removeNodes,
lambda: self.compareImage(testName+"4"),
reAddNode,
lambda: self.compareImage(testName+"5"),
killNode,
reAddNode,
removeAgain
))
def testWithFile(filename, testImgName):
def hide():
self.videoNode.opacity=0
def show():
self.videoNode.opacity=1
player.setFakeFPS(25)
root = self.loadEmptyScene()
self.videoNode = avg.VideoNode(href=filename, loop=True, threaded=False,
parent=root)
self.start(False,
(lambda: self.videoNode.play(),
None,
lambda: self.compareImage(testImgName+"1"),
hide,
None,
None,
show,
lambda: self.compareImage(testImgName+"2")
))
