def onInit(self):
# avg.VideoWriter requires a canvas as source
# (can be the main canvas returned by player.getMainCanvas())
canvas = player.createCanvas(id='source_canvas', size=self.size)
root = canvas.getRootNode()
# some nodes in source canvas
self._text = avg.WordsNode(parent=root, text='000000', fontsize=42)
self._text.pos = (self.size - self._text.size) / 2
self._rect = avg.RectNode(parent=root, size=(200, 200))
self._rect.pos = (self.size - self._rect.size) / 2
# show source canvas on screen (not required for video recording)
avg.ImageNode(parent=self, href='canvas:source_canvas')
# start writing source canvas to video file
fps = int(player.getFramerate())
self._video_writer = avg.VideoWriter(canvas, 'video_writer.avi', fps)
self._writing = True
# these nodes are not included in the video (outside source canvas)
avg.WordsNode(parent=self,
text='writing to "%s"' % self._video_writer.filename)
self._btn = widget.TextButton(parent=self,
pos=(0, 20),
size=(100, 25),
text='PAUSE')
self._btn.subscribe(widget.Button.CLICKED, self._onButton)
def startWriter(fps, syncToPlayback):
self.videoWriter = avg.VideoWriter(canvas, "test.mov", fps, 3, 5,
syncToPlayback)
self.assertEqual(self.videoWriter.filename, "test.mov")
self.assertEqual(self.videoWriter.framerate, fps)
self.assertEqual(self.videoWriter.qmin, 3)
self.assertEqual(self.videoWriter.qmax, 5)
self.assertEqual(self.videoWriter.synctoplayback, syncToPlayback)
def onInit(self):
self.curFrame = 0
avg.logger.info("Creating camera:")
avg.logger.info("driver=%(driver)s device=%(device)s" % self.optdict)
avg.logger.info(
"width=%(width)d height=%(height)d pixelformat=%(pixelFormat)s" %
self.optdict)
avg.logger.info(
"unit=%(unit)d framerate=%(framerate)d fw800=%(fw800)s" %
self.optdict)
self.canvas = player.createCanvas(id="canvas", size=self.size)
self.camNode = avg.CameraNode(driver=self.optdict["driver"],
device=self.optdict["device"],
unit=self.optdict["unit"],
fw800=self.optdict["fw800"],
framerate=self.optdict["framerate"],
capturewidth=self.optdict["width"],
captureheight=self.optdict["height"],
pixelformat=self.optdict["pixelFormat"],
parent=self.canvas.getRootNode())
if not self.optdict["noinfo"]:
self.infoText = (
"Driver=%(driver)s (dev=%(device)s unit=%(unit)d) "
"%(width)dx%(height)d@%(framerate)f" % self.optdict)
avg.WordsNode(text=self.infoText,
color="ff3333",
pos=(5, 5),
fontsize=14,
rawtextmode=True,
parent=self.canvas.getRootNode())
self.frameText = avg.WordsNode(color="ff3333",
pos=(5, 25),
fontsize=14,
parent=self.canvas.getRootNode())
else:
self.frameText = None
self.canvasImage = avg.ImageNode(href="canvas:canvas",
size=self.size,
parent=self)
if self.capture:
self.videoWriter = avg.VideoWriter(self.canvas, "camera.mov", 60,
3, 5, True)
self.setupKeys()
self.camNode.play()
player.setTimeout(100, self.checkCamera)
def testCreateException():
self.assertRaises(avg.Exception,
lambda: avg.VideoWriter(player.getMainCanvas(),
"nonexistentdir/test.mov", 30))
def testVideoWriter(self):
def startWriter(fps, syncToPlayback):
self.videoWriter = avg.VideoWriter(canvas, "test.mov", fps, 3, 5,
syncToPlayback)
self.assertEqual(self.videoWriter.filename, "test.mov")
self.assertEqual(self.videoWriter.framerate, fps)
self.assertEqual(self.videoWriter.qmin, 3)
self.assertEqual(self.videoWriter.qmax, 5)
self.assertEqual(self.videoWriter.synctoplayback, syncToPlayback)
def stopWriter():
self.videoWriter.stop()
def killWriter():
self.videoWriter = None
def pauseWriter():
self.videoWriter.pause()
def playWriter():
self.videoWriter.play()
def hideVideo():
videoNode.opacity = 0
def showVideo():
videoNode.opacity = 1
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 testCreateException():
self.assertRaises(avg.Exception,
lambda: avg.VideoWriter(player.getMainCanvas(),
"nonexistentdir/test.mov", 30))
if not(self._isCurrentDirWriteable()):
self.skip("Current dir not writeable.")
return
if player.isUsingGLES():
self.skip("VideoWriter not supported under GLES.")
return
self.assertRaises(avg.Exception, lambda:
avg.VideoWriter(player.getMainCanvas(), "test.mov", 30, 3, 5, False))
for useCanvas in (False, True):
player.setFakeFPS(30)
root = self.loadEmptyScene()
videoNode = avg.VideoNode(href="mpeg1-48x48.mov", threaded=False)
if useCanvas:
canvas = player.createCanvas(id="canvas", size=(48,48),
mediadir="media")
canvas.getRootNode().appendChild(videoNode)
avg.ImageNode(parent=root, href="canvas:canvas")
testImageName = "testVideoWriterCanvas"
else:
root.appendChild(videoNode)
canvas = player.getMainCanvas()
testImageName = "testVideoWriter"
self.start(False,
(videoNode.play,
lambda: startWriter(30, True),
lambda: self.delay(100),
stopWriter,
killWriter,
lambda: checkVideo(4),
hideVideo,
lambda: self.compareImage(testImageName+"1"),
showVideo,
testCreateException,
lambda: startWriter(15, False),
lambda: self.delay(150),
stopWriter,
killWriter,
lambda: checkVideo(2),
lambda: startWriter(30, False),
pauseWriter,
lambda: self.delay(200),
playWriter,
stopWriter,
killWriter,
lambda: checkVideo(1),
lambda: startWriter(30, False),
killWriter,
lambda: checkVideo(1),
))
os.remove("test.mov")
def startWriter(fps, syncToPlayback):
self.videoWriter = avg.VideoWriter(canvas, "test.mov", fps, 3, 5,
syncToPlayback)