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 testVideoInfo(self):
def checkInfo():
node.pause()
self.assertEqual(node.getContainerFormat(), "avi")
self.assertEqual(node.getCurFrame(), 0)
self.assertEqual(node.getCurTime(), 0)
self.assertEqual(node.getDuration(), 1000)
self.assertEqual(node.getBitrate(), 224064)
self.assertEqual(node.getVideoCodec(), "mpeg4")
self.assertEqual(node.getStreamPixelFormat(), "yuv420p")
self.assertEqual(node.getVideoDuration(), 1000)
if isThreaded:
self.assertEqual(node.getAudioCodec(), "mp2")
self.assertEqual(node.getAudioSampleRate(), 44100)
self.assertEqual(node.getNumAudioChannels(), 2)
self.assert_(node.getVideoDuration() >= 1000)
def checkEnableSound():
node = avg.VideoNode(href="mpeg1-48x48-sound.avi", threaded=isThreaded,
enablesound=False, parent=root)
node.pause()
self.assertEqual(node.getVideoCodec(), "mpeg4")
self.assertException(node.getAudioCodec)
def checkExceptions():
node = avg.VideoNode(href="mpeg1-48x48.mov", threaded=isThreaded)
self.assertException(node.getDuration)
self.assertException(node.getBitrate)
self.assertException(node.getVideoCodec)
self.assertException(node.getStreamPixelFormat)
node.pause()
self.assertException(node.getAudioCodec)
self.assertException(node.getAudioSampleRate)
self.assertException(node.getNumAudioChannels)
root.appendChild(node)
def checkAudioFile():
node = avg.VideoNode(href="44.1kHz_16bit_stereo.wav", threaded=isThreaded,
parent=root)
self.assertException(node.pause)
sys.stderr.write("\n")
for isThreaded in (False, True):
sys.stderr.write(" Threaded: " + str(isThreaded) + "\n")
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48-sound.avi", threaded=isThreaded,
parent=root)
checkInfo()
checkEnableSound()
checkExceptions()
self.start(False,
(checkInfo,
checkExceptions,
checkAudioFile,
))
sys.stderr.write(" Nonstandard queue length\n")
root = self.loadEmptyScene()
node = avg.VideoNode(href="mpeg1-48x48-sound.avi", queuelength=23, parent=root)
self.assertEqual(node.queuelength, 23)
def testVideoAccel(self):
accelConfig = avg.VideoNode.getVideoAccelConfig()
video = avg.VideoNode(accelerated=False, href="media/mpeg1-48x48.mov")
video.play()
self.assertEqual(video.accelerated, False)
video = avg.VideoNode(accelerated=True, href="media/mpeg1-48x48.mov")
video.play()
self.assertEqual(video.accelerated, (accelConfig != avg.NO_ACCELERATION))
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 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 __init__(self, mediabase, shadowdiv, parent=None, **kwargs):
super(_Aircraft, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.__alive = False
self.__aircraftVid = avg.VideoNode(href=mediabase+'.mov', loop=True, parent=self)
self.__aircraftVid.pause()
self.__destroyVid = avg.VideoNode(href='explosion.mov', active=False,
threaded=False, parent=self)
self.__destroyVid.pause()
self.__destroyVid.subscribe(avg.VideoNode.END_OF_FILE, self._hide)
self.__shadowImg = avg.ImageNode(href=mediabase+'.gif', opacity=0.5,
pos=self.pos + _Aircraft.__SHADOW_OFFSET, parent=shadowdiv)
self.__shadowImg.size *= _Aircraft.__SHADOW_SCALE
if not player.isUsingGLES():
self.__shadowImg.setEffect(avg.BlurFXNode(6.0))
self.size = self.__aircraftVid.size
def testVideoFile(filename, isThreaded):
def setVolume(volume):
node.volume = volume
def testGetVolume(volume):
self.assertAlmostEqual(node.volume, volume)
def checkImage(filename):
if not (isThreaded):
self.compareImage("testVideo-" + filename + "1")
def testInfo():
if filename == "mpeg1-48x48-sound.avi" and isThreaded:
self.assert_(node.hasAudio())
else:
self.assert_(not (node.hasAudio()))
self.assert_(
(filename == "rgba-48x48.mov"
or filename == "vp6a-yuva-48x48.flv") == node.hasAlpha())
root = self.loadEmptyScene()
node = avg.VideoNode(href=filename,
volume=0.8,
size=(96, 96),
threaded=isThreaded)
self.assertEqual(node.threaded, isThreaded)
setVolume(0.6)
root.appendChild(node)
self.assertRaises(RuntimeError, node.hasAudio)
self.start(False,
(lambda: setVolume(0.5), lambda: testGetVolume(0.5),
lambda: node.play(), lambda: checkImage(filename),
lambda: setVolume(0.3), lambda: testGetVolume(0.3),
testInfo, lambda: node.stop()))
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 onInit(self):
player.showCursor(True)
self.videoListNode = avg.DivNode(parent=self)
self.videoNodes = []
fileNames = os.listdir(self.__folder)
i = 0
for fileName in fileNames:
try:
videoNode = avg.VideoNode(pos=(i * (self.__thumbWidth + 20),
0),
href=self.__folder + '/' + fileName,
loop=True,
mipmap=True,
enablesound=False,
parent=self.videoListNode)
videoNode.play()
self.videoNodes.append(videoNode)
size = videoNode.getMediaSize()
height = (self.__thumbWidth * size.y) / size.x
videoNode.size = (self.__thumbWidth, height)
videoNode.subscribe(videoNode.CURSOR_DOWN,
lambda event, videoNode=videoNode: self.
chooseVideo(event, videoNode))
i += 1
except RuntimeError:
pass
self.subscribe(self.CURSOR_MOTION, self.onMouseMove)
self.bigVideoNode = None
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 testInvalidVideoFilename(self):
def tryplay():
assertRaises(SystemError, lambda: video.play())
root = self.loadEmptyScene()
video = avg.VideoNode(href="filedoesntexist.avi", parent=root)
self.start(False, (lambda: tryplay, lambda: video.stop()))
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(RuntimeError, node.play)
def testVideoBroken():
node = avg.VideoNode(href="rgb24-64x64.png")
self.assertRaises(RuntimeError, 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 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 __getFileNames(self, args):
self._fileNameList = []
filePaths = []
for arg in args:
if arg == ".":
filePaths.extend(os.listdir(os.curdir))
if options.recursion:
for folder in filePaths:
if os.path.isdir(folder):
filePaths.extend(self.__getFilesInFolder(folder))
elif arg == ".." or os.path.isdir(arg):
filePaths.extend(self.__getFilesInFolder(arg))
else:
if os.path.isfile(arg):
filePaths.append(arg)
for fileName in filePaths:
try:
if os.path.isfile(fileName):
self._node.href = str(fileName)
self._node.play()
self._fileNameList.append(self._node.href)
except RuntimeError, err:
sys.stderr.write(str(err) + "\n")
self._node = avg.VideoNode()
def checkVideo(numFrames):
savedVideoNode = avg.VideoNode(href="../test.mov", pos=(48,0),
threaded=False, parent=root)
savedVideoNode.pause()
self.assertEqual(savedVideoNode.getVideoCodec(), "mjpeg")
self.assertEqual(savedVideoNode.getNumFrames(), numFrames)
self.assertEqual(savedVideoNode.getStreamPixelFormat(), "yuvj420p")
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()
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 checkEnableSound():
node = avg.VideoNode(href="mpeg1-48x48-sound.avi",
threaded=isThreaded,
enablesound=False,
parent=root)
node.pause()
self.assertEqual(node.getVideoCodec(), "mpeg4")
self.assertRaises(RuntimeError, node.getAudioCodec)
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()
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()
def showVideo():
node.unlink(True)
self.videoNode = avg.VideoNode(parent=root,
size=(96, 96),
threaded=False,
href="mpeg1-48x48.mov",
intensity=(0.5, 0.5, 0.5))
self.videoNode.play()
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 testVideoSizeChanged(self):
def onResize(newSize):
self.messageReceived = True
self.messageReceived = False
root = self.loadEmptyScene()
self.video = avg.VideoNode(href="mpeg1-48x48.mov", parent=root)
self.video.subscribe(self.video.SIZE_CHANGED, onResize)
self.video.play()
self.assert_(self.messageReceived)
def checkExceptions():
node = avg.VideoNode(href="mpeg1-48x48.mov", threaded=isThreaded)
self.assertRaises(avg.Exception, node.getBitrate)
self.assertRaises(avg.Exception, node.getVideoCodec)
self.assertRaises(avg.Exception, node.getStreamPixelFormat)
node.pause()
self.assertRaises(avg.Exception, node.getAudioCodec)
self.assertRaises(avg.Exception, node.getAudioSampleRate)
self.assertRaises(avg.Exception, node.getNumAudioChannels)
root.appendChild(node)
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 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 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 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 onArgvParsed(self, options, args, parser):
if len(args) != 1:
parser.print_help()
sys.exit(1)
self.node = avg.VideoNode(href=args[0],
accelerated=not (options.disableAccel))
self.node.pause()
mediaSize = self.node.getMediaSize()
size = avg.Point2D(max(mediaSize.x, 320), max(mediaSize.y, 120))
screenSize = player.getScreenResolution()
size = avg.Point2D(min(size.x, screenSize.x),
min(size.y, screenSize.y - 80))
self.settings.set("app_resolution", "%dx%d" % (size.x, size.y))
def chooseVideo(self, event, videoNode):
if self.bigVideoNode:
self.removeBigVideo()
destSize = videoNode.size * 2
destPos = Point2D(720, 550) - destSize / 2
absPos = videoNode.getAbsPos(Point2D(0, 0))
frame = videoNode.getCurFrame()
self.bigVideoNode = avg.VideoNode(href=videoNode.href,
loop=True,
sensitive=False,
parent=self)
self.bigVideoNode.play()
self.bigVideoNode.seekToFrame(frame)
avg.EaseInOutAnim(self.bigVideoNode, "pos", 1000, absPos, destPos,
False, 300, 300).start()
avg.EaseInOutAnim(self.bigVideoNode, "size", 1000, videoNode.size,
destSize, False, 300, 300).start()
