class TestStillImage(TestCase):
clip_duration = 3 * Gst.SECOND
def setUp(self):
self.mainloop = GObject.MainLoop()
samples = os.path.join(os.path.dirname(__file__), "samples")
self.facs = []
self.facs.append([PictureFileSourceFactory('file://' + os.path.join(samples, "flat_colour1_640x480.png")), VideoStream(Gst.Caps("video/x-raw-rgb,bpp=(int)24,depth=(int)24,endianness=(int)4321,red_mask=(int)16711680,green_mask=(int)65280,blue_mask=(int)255"))])
self.facs.append([PictureFileSourceFactory('file://' + os.path.join(samples, "flat_colour2_640x480.png")), VideoStream(Gst.Caps("video/x-raw-rgb,bpp=(int)24,depth=(int)24,endianness=(int)4321,red_mask=(int)16711680,green_mask=(int)65280,blue_mask=(int)255"))])
self.facs.append([PictureFileSourceFactory('file://' + os.path.join(samples, "flat_colour3_320x180.png")), VideoStream(Gst.Caps("video/x-raw-rgb,bpp=(int)24,depth=(int)24,endianness=(int)4321,red_mask=(int)16711680,green_mask=(int)65280,blue_mask=(int)255"))])
# one video with a different resolution
self.facs.append([VideoTestSourceFactory(), VideoStream(Gst.Caps('video/x-raw-yuv,width=(int)640,height=(int)480,format=(fourcc)I420'))])
# configure durations and add output streams to factories
for fac in self.facs:
factory = fac[0]
stream = fac[1]
factory.duration = self.clip_duration
factory.addOutputStream(stream)
self.track_objects = []
self.track = Track(self.facs[0][1])
self.timeline = Timeline()
self.timeline.addTrack(self.track)
vsettings = StreamEncodeSettings(renderer="theoraenc")
rsettings = RenderSettings(settings=[vsettings],
muxer="oggmux")
self.fakesink = common.FakeSinkFactory()
rendersink = RenderSinkFactory(RenderFactory(settings=rsettings),
self.fakesink)
self.render = RenderAction()
self.pipeline = Pipeline()
self.pipeline.connect("eos", self._renderEOSCb)
self.pipeline.connect("error", self._renderErrorCb)
self.pipeline.addAction(self.render)
self.render.addConsumers(rendersink)
timeline_factory = TimelineSourceFactory(self.timeline)
self.render.addProducers(timeline_factory)
def tearDown(self):
self.mainloop.quit()
def configureStreams(self, inputs, offsets):
count = 0
for i in inputs:
factory = self.facs[i][0]
stream = self.facs[i][1]
track_object = SourceTrackObject(factory, stream)
self.track_objects.append(track_object)
track_object.start = offsets[count]
self.track.addTrackObject(track_object)
count += 1
def startRender(self):
self.render.activate()
self.data_written = 0
self.fakesink.bins[0].props.signal_handoffs = True
self.fakesink.bins[0].connect("handoff", self._fakesinkHandoffCb)
self.pipeline.play()
self.mainloop.run()
def _fakesinkHandoffCb(self, fakesink, buf, pad):
self.data_written += buf.size
def _renderEOSCb(self, obj):
self.mainloop.quit()
# check the render was successful
self.assertTrue(self.data_written > 0)
def _renderErrorCb(self, obj, error, details):
print "Error: %s\nDetails: %s" % (str(error), str(details))
self.fail("Pipeline rendering error")
def cleanUp(self):
self.render.deactivate()
self.track.removeAllTrackObjects()
self.track_objects = []
def testRendering(self):
# use one of the still image streams
self.configureStreams(range(1), [0])
self.startRender()
self.cleanUp()
# use two images with the same resolution and concatenate them
self.configureStreams(range(2), [0, self.clip_duration])
self.startRender()
self.cleanUp()
# concatenate images with different resolutions
self.configureStreams(range(3), [0, self.clip_duration, 2 * self.clip_duration])
self.startRender()
self.cleanUp()
# mix images with different resolutions by overlapping
self.configureStreams(range(3), [0, self.clip_duration // 2, self.clip_duration])
self.startRender()
self.cleanUp()
# mix images and videos with the same resolution
self.configureStreams([0, 1, 3], [0, self.clip_duration, 2 * self.clip_duration])
self.startRender()
self.cleanUp()
# mix images and videos with different resolutions
self.configureStreams(range(4), [0, self.clip_duration, 2 * self.clip_duration, 3 * self.clip_duration])
self.startRender()
self.cleanUp()
# mix images and videos with different resolutions by overlapping
self.configureStreams(range(4), [0, self.clip_duration // 2, self.clip_duration, (3 * self.clip_duration) // 2])
self.startRender()
self.cleanUp()
class TestStillImage(TestCase):
clip_duration = 3 * gst.SECOND
def setUp(self):
self.mainloop = gobject.MainLoop()
samples = os.path.join(os.path.dirname(__file__), "samples")
self.facs = []
self.facs.append([
PictureFileSourceFactory(
'file://' + os.path.join(samples, "flat_colour1_640x480.png")),
VideoStream(
gst.Caps(
"video/x-raw-rgb,bpp=(int)24,depth=(int)24,endianness=(int)4321,red_mask=(int)16711680,green_mask=(int)65280,blue_mask=(int)255"
))
])
self.facs.append([
PictureFileSourceFactory(
'file://' + os.path.join(samples, "flat_colour2_640x480.png")),
VideoStream(
gst.Caps(
"video/x-raw-rgb,bpp=(int)24,depth=(int)24,endianness=(int)4321,red_mask=(int)16711680,green_mask=(int)65280,blue_mask=(int)255"
))
])
self.facs.append([
PictureFileSourceFactory(
'file://' + os.path.join(samples, "flat_colour3_320x180.png")),
VideoStream(
gst.Caps(
"video/x-raw-rgb,bpp=(int)24,depth=(int)24,endianness=(int)4321,red_mask=(int)16711680,green_mask=(int)65280,blue_mask=(int)255"
))
])
# one video with a different resolution
self.facs.append([
VideoTestSourceFactory(),
VideoStream(
gst.Caps(
'video/x-raw-yuv,width=(int)640,height=(int)480,format=(fourcc)I420'
))
])
# configure durations and add output streams to factories
for fac in self.facs:
factory = fac[0]
stream = fac[1]
factory.duration = self.clip_duration
factory.addOutputStream(stream)
self.track_objects = []
self.track = Track(self.facs[0][1])
self.timeline = Timeline()
self.timeline.addTrack(self.track)
vsettings = StreamEncodeSettings(encoder="theoraenc")
rsettings = RenderSettings(settings=[vsettings], muxer="oggmux")
self.fakesink = common.FakeSinkFactory()
rendersink = RenderSinkFactory(RenderFactory(settings=rsettings),
self.fakesink)
self.render = RenderAction()
self.pipeline = Pipeline()
self.pipeline.connect("eos", self._renderEOSCb)
self.pipeline.connect("error", self._renderErrorCb)
self.pipeline.addAction(self.render)
self.render.addConsumers(rendersink)
timeline_factory = TimelineSourceFactory(self.timeline)
self.render.addProducers(timeline_factory)
def tearDown(self):
self.mainloop.quit()
def configureStreams(self, inputs, offsets):
count = 0
for i in inputs:
factory = self.facs[i][0]
stream = self.facs[i][1]
track_object = SourceTrackObject(factory, stream)
self.track_objects.append(track_object)
track_object.start = offsets[count]
self.track.addTrackObject(track_object)
count += 1
def startRender(self):
self.render.activate()
self.data_written = 0
self.fakesink.bins[0].props.signal_handoffs = True
self.fakesink.bins[0].connect("handoff", self._fakesinkHandoffCb)
self.pipeline.play()
self.mainloop.run()
def _fakesinkHandoffCb(self, fakesink, buf, pad):
self.data_written += buf.size
def _renderEOSCb(self, obj):
self.mainloop.quit()
# check the render was successful
self.assertTrue(self.data_written > 0)
def _renderErrorCb(self, obj, error, details):
print "Error: %s\nDetails: %s" % (str(error), str(details))
self.fail("Pipeline rendering error")
def cleanUp(self):
self.render.deactivate()
self.track.removeAllTrackObjects()
self.track_objects = []
def testRendering(self):
# use one of the still image streams
self.configureStreams(range(1), [0])
self.startRender()
self.cleanUp()
# use two images with the same resolution and concatenate them
self.configureStreams(range(2), [0, self.clip_duration])
self.startRender()
self.cleanUp()
# concatenate images with different resolutions
self.configureStreams(range(3),
[0, self.clip_duration, 2 * self.clip_duration])
self.startRender()
self.cleanUp()
# mix images with different resolutions by overlapping
self.configureStreams(range(3),
[0, self.clip_duration // 2, self.clip_duration])
self.startRender()
self.cleanUp()
# mix images and videos with the same resolution
self.configureStreams([0, 1, 3],
[0, self.clip_duration, 2 * self.clip_duration])
self.startRender()
self.cleanUp()
# mix images and videos with different resolutions
self.configureStreams(range(4), [
0, self.clip_duration, 2 * self.clip_duration,
3 * self.clip_duration
])
self.startRender()
self.cleanUp()
# mix images and videos with different resolutions by overlapping
self.configureStreams(range(4), [
0, self.clip_duration // 2, self.clip_duration,
(3 * self.clip_duration) // 2
])
self.startRender()
self.cleanUp()
class TestPipeline(TestCase):
def setUp(self):
TestCase.setUp(self)
gst.debug("start")
self.pipeline = Pipeline()
self.monitor = SignalMonitor(self.pipeline, 'action-added',
'action-removed', 'factory-added',
'factory-removed', 'state-changed')
self.assertEquals(self.monitor.action_added_count, 0)
self.assertEquals(self.monitor.action_added_collect, [])
def tearDown(self):
self.pipeline.setState(STATE_NULL)
self.pipeline.release()
self.monitor.disconnectFromObj(self.pipeline)
del self.pipeline
del self.monitor
TestCase.tearDown(self)
def testAddRemoveActionSimple(self):
""" Simple add/remove of Actions """
ac1 = BogusAction()
# add the action to the pipeline
res = self.pipeline.addAction(ac1)
# the returned value should be the given action
self.assertEquals(res, ac1)
# it should now be in the list of actions...
self.failUnlessEqual(self.pipeline.actions, [ac1])
# ... and the action should be set to that pipeline
self.failUnlessEqual(ac1.pipeline, self.pipeline)
# the 'action-added' signal should be triggered once
self.assertEquals(self.monitor.action_added_count, 1)
# And it contained our action
self.assertEquals(self.monitor.action_added_collect, [(ac1, )])
# if we try to add that action again, it should be silently ignored
res = self.pipeline.addAction(ac1)
self.assertEquals(res, ac1)
# the list of actions shouldn't have changed
self.failUnlessEqual(self.pipeline.actions, [ac1])
# it shouldn't have changed the pipeline set on action
self.failUnlessEqual(ac1.pipeline, self.pipeline)
# the 'action-added' signal should NOT have been triggered again
self.assertEquals(self.monitor.action_added_count, 1)
# And now to remove it
self.pipeline.removeAction(ac1)
# the 'action-removed' signal should have been triggered once..
self.assertEquals(self.monitor.action_removed_count, 1)
# .. with the action as an argument
self.assertEquals(self.monitor.action_removed_collect, [(ac1, )])
# And there should be no actions left on the pipeline
self.assertEquals(self.pipeline.actions, [])
def testAddRemoveActionAdvanced(self):
""" Advanced add/remove of Actions """
ac1 = BogusAction()
ac2 = BogusAction()
p2 = Pipeline()
res = self.pipeline.addAction(ac1)
self.assertEquals(self.pipeline.actions, [ac1])
# we can't add an action to two pipelines at the same time
self.failUnlessRaises(PipelineError, p2.addAction, ac1)
self.pipeline.removeAction(ac1)
self.assertEquals(self.pipeline.actions, [])
res = self.pipeline.setAction(ac1)
self.assertEquals(res, ac1)
self.assertEquals(self.pipeline.actions, [ac1])
# calling setAction while a similar action is already set should
# return the existing action and not change anything else
res = self.pipeline.setAction(ac2)
self.assertEquals(res, ac1)
self.assertEquals(self.pipeline.actions, [ac1])
# we can't remove active actions while in PAUSED/PLAYING
self.pipeline.setState(STATE_PAUSED)
ac1.state = STATE_ACTIVE
self.assertEquals(self.pipeline.getState(), STATE_PAUSED)
self.failUnlessRaises(PipelineError, self.pipeline.removeAction, ac1)
# but we can remove deactivated actions while in PAUSED/PLAYING
self.pipeline.setState(STATE_PAUSED)
ac1.state = STATE_NOT_ACTIVE
self.assertEquals(self.pipeline.getState(), STATE_PAUSED)
self.pipeline.removeAction(ac1)
# we can add actions while in PAUSED/PLAYING
res = self.pipeline.addAction(ac2)
self.assertEquals(res, ac2)
self.assertEquals(self.pipeline.actions, [ac2])
self.pipeline.removeAction(ac2)
p2.release()
def testStateChange(self):
loop = gobject.MainLoop()
bag = {"last_state": None}
def state_changed_cb(pipeline, state, bag, loop):
bag["last_state"] = state
loop.quit()
self.pipeline.connect('state-changed', state_changed_cb, bag, loop)
# playing
self.pipeline.setState(STATE_PLAYING)
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_PLAYING)
self.failUnlessEqual(self.pipeline.getState(), STATE_PLAYING)
self.assertEquals(self.monitor.state_changed_count, 1)
# playing again
self.pipeline.setState(STATE_PLAYING)
self.assertEquals(self.monitor.state_changed_count, 1)
# ready
self.pipeline.setState(STATE_READY)
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_READY)
self.failUnlessEqual(self.pipeline.getState(), STATE_READY)
self.assertEquals(self.monitor.state_changed_count, 2)
# PLAYING
self.pipeline.play()
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_PLAYING)
self.failUnlessEqual(self.pipeline.getState(), STATE_PLAYING)
self.assertEquals(self.monitor.state_changed_count, 3)
# PAUSE
self.pipeline.pause()
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_PAUSED)
self.failUnlessEqual(self.pipeline.getState(), STATE_PAUSED)
self.assertEquals(self.monitor.state_changed_count, 4)
self.pipeline.stop()
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_READY)
self.failUnlessEqual(self.pipeline.getState(), STATE_READY)
self.assertEquals(self.monitor.state_changed_count, 5)
def testGetReleaseBinForFactoryStream(self):
factory = VideoTestSourceFactory()
stream = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv'),
'src0')
factory.addOutputStream(stream)
# try to get a cached instance
self.failUnlessRaises(PipelineError,
self.pipeline.getBinForFactoryStream, factory, stream, False)
# create a bin
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.failUnless(isinstance(bin1, gst.Element))
# return the cached instance
bin2 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.failUnlessEqual(id(bin1), id(bin2))
self.pipeline.releaseBinForFactoryStream(factory, stream)
self.pipeline.releaseBinForFactoryStream(factory, stream)
# the bin has been destroyed at this point
self.failUnlessRaises(PipelineError,
self.pipeline.releaseBinForFactoryStream, factory, stream)
# we should get a new instance
bin2 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.pipeline.releaseBinForFactoryStream(factory, stream)
def testGetReleaseTeeForFactoryStream(self):
factory = VideoTestSourceFactory()
stream = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv'),
'src')
factory.addOutputStream(stream)
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory, stream, True)
# getBinForFactoryStream(factory, stream) must be called before
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory, stream, True)
# create the bin
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
# try to get a cached tee
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory, stream, False)
# create tee
tee1 = self.pipeline.getTeeForFactoryStream(factory, stream, True)
self.failUnless(isinstance(tee1, gst.Element))
# get the cached instance
tee2 = self.pipeline.getTeeForFactoryStream(factory, stream, True)
self.failUnlessEqual(id(tee1), id(tee2))
# release
self.pipeline.releaseTeeForFactoryStream(factory, stream)
# there's still a tee alive, so we can't release the bin
#self.failUnlessRaises(PipelineError,
# self.pipeline.releaseBinForFactoryStream, factory, stream)
self.pipeline.releaseTeeForFactoryStream(factory, stream)
self.failUnlessRaises(PipelineError,
self.pipeline.releaseTeeForFactoryStream, factory, stream)
# should always fail with a sink bin
factory2 = FakeSinkFactory()
stream2 = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv'),
'src')
factory2.addInputStream(stream2)
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory2, stream2, True)
self.pipeline.releaseBinForFactoryStream(factory, stream)
def testGetReleaseQueueForFactoryStream(self):
factory = FakeSinkFactory()
stream = VideoStream(gst.Caps('any'), 'sink')
factory.addInputStream(stream)
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory, stream, True)
# getBinForFactoryStream(factory, stream) must be called before
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory, stream, True)
# create the bin
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
# try to get a cached queue
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory, stream, False)
# create queue
queue1 = self.pipeline.getQueueForFactoryStream(factory, stream, True)
self.failUnless(isinstance(queue1, gst.Element))
gst.debug("pouet")
# get the cached instance
queue2 = self.pipeline.getQueueForFactoryStream(factory, stream, True)
self.failUnlessEqual(id(queue1), id(queue2))
# release
self.pipeline.releaseQueueForFactoryStream(factory, stream)
gst.debug("pouet")
# there's still a queue alive, so we can't release the bin
self.failUnlessRaises(PipelineError,
self.pipeline.releaseBinForFactoryStream, factory, stream)
self.pipeline.releaseQueueForFactoryStream(factory, stream)
gst.debug("pouet2")
self.failUnlessRaises(PipelineError,
self.pipeline.releaseQueueForFactoryStream, factory, stream)
# should always fail with a src bin
factory2 = VideoTestSourceFactory()
stream2 = VideoStream(gst.Caps('any'), 'src')
factory2.addOutputStream(stream2)
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory2, stream2, True)
self.pipeline.releaseBinForFactoryStream(factory, stream)
self.pipeline.releaseBinForFactoryStream(factory, stream)
self.assertEquals(factory.current_bins, 0)
class TestPipeline(TestCase):
def setUp(self):
TestCase.setUp(self)
gst.debug("start")
self.pipeline = Pipeline()
self.monitor = SignalMonitor(self.pipeline, 'action-added',
'action-removed', 'factory-added',
'factory-removed', 'state-changed')
self.assertEquals(self.monitor.action_added_count, 0)
self.assertEquals(self.monitor.action_added_collect, [])
def tearDown(self):
self.pipeline.setState(STATE_NULL)
self.pipeline.release()
self.monitor.disconnectFromObj(self.pipeline)
del self.pipeline
del self.monitor
TestCase.tearDown(self)
def testAddRemoveActionSimple(self):
""" Simple add/remove of Actions """
ac1 = BogusAction()
# add the action to the pipeline
res = self.pipeline.addAction(ac1)
# the returned value should be the given action
self.assertEquals(res, ac1)
# it should now be in the list of actions...
self.failUnlessEqual(self.pipeline.actions, [ac1])
# ... and the action should be set to that pipeline
self.failUnlessEqual(ac1.pipeline, self.pipeline)
# the 'action-added' signal should be triggered once
self.assertEquals(self.monitor.action_added_count, 1)
# And it contained our action
self.assertEquals(self.monitor.action_added_collect, [(ac1, )])
# if we try to add that action again, it should be silently ignored
res = self.pipeline.addAction(ac1)
self.assertEquals(res, ac1)
# the list of actions shouldn't have changed
self.failUnlessEqual(self.pipeline.actions, [ac1])
# it shouldn't have changed the pipeline set on action
self.failUnlessEqual(ac1.pipeline, self.pipeline)
# the 'action-added' signal should NOT have been triggered again
self.assertEquals(self.monitor.action_added_count, 1)
# And now to remove it
self.pipeline.removeAction(ac1)
# the 'action-removed' signal should have been triggered once..
self.assertEquals(self.monitor.action_removed_count, 1)
# .. with the action as an argument
self.assertEquals(self.monitor.action_removed_collect, [(ac1, )])
# And there should be no actions left on the pipeline
self.assertEquals(self.pipeline.actions, [])
def testAddRemoveActionAdvanced(self):
""" Advanced add/remove of Actions """
ac1 = BogusAction()
ac2 = BogusAction()
p2 = Pipeline()
res = self.pipeline.addAction(ac1)
self.assertEquals(self.pipeline.actions, [ac1])
# we can't add an action to two pipelines at the same time
self.failUnlessRaises(PipelineError, p2.addAction, ac1)
self.pipeline.removeAction(ac1)
self.assertEquals(self.pipeline.actions, [])
res = self.pipeline.setAction(ac1)
self.assertEquals(res, ac1)
self.assertEquals(self.pipeline.actions, [ac1])
# calling setAction while a similar action is already set should
# return the existing action and not change anything else
res = self.pipeline.setAction(ac2)
self.assertEquals(res, ac1)
self.assertEquals(self.pipeline.actions, [ac1])
# we can't remove active actions while in PAUSED/PLAYING
self.pipeline.setState(STATE_PAUSED)
ac1.state = STATE_ACTIVE
self.assertEquals(self.pipeline.getState(), STATE_PAUSED)
self.failUnlessRaises(PipelineError, self.pipeline.removeAction, ac1)
# but we can remove deactivated actions while in PAUSED/PLAYING
self.pipeline.setState(STATE_PAUSED)
ac1.state = STATE_NOT_ACTIVE
self.assertEquals(self.pipeline.getState(), STATE_PAUSED)
self.pipeline.removeAction(ac1)
# we can add actions while in PAUSED/PLAYING
res = self.pipeline.addAction(ac2)
self.assertEquals(res, ac2)
self.assertEquals(self.pipeline.actions, [ac2])
self.pipeline.removeAction(ac2)
p2.release()
def testStateChange(self):
loop = gobject.MainLoop()
bag = {"last_state": None}
def state_changed_cb(pipeline, state, bag, loop):
bag["last_state"] = state
loop.quit()
self.pipeline.connect('state-changed', state_changed_cb, bag, loop)
# playing
self.pipeline.setState(STATE_PLAYING)
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_PLAYING)
self.failUnlessEqual(self.pipeline.getState(), STATE_PLAYING)
self.assertEquals(self.monitor.state_changed_count, 1)
# playing again
self.pipeline.setState(STATE_PLAYING)
self.assertEquals(self.monitor.state_changed_count, 1)
# ready
self.pipeline.setState(STATE_READY)
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_READY)
self.failUnlessEqual(self.pipeline.getState(), STATE_READY)
self.assertEquals(self.monitor.state_changed_count, 2)
# PLAYING
self.pipeline.play()
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_PLAYING)
self.failUnlessEqual(self.pipeline.getState(), STATE_PLAYING)
self.assertEquals(self.monitor.state_changed_count, 3)
# PAUSE
self.pipeline.pause()
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_PAUSED)
self.failUnlessEqual(self.pipeline.getState(), STATE_PAUSED)
self.assertEquals(self.monitor.state_changed_count, 4)
self.pipeline.stop()
loop.run()
self.failUnlessEqual(bag["last_state"], STATE_READY)
self.failUnlessEqual(self.pipeline.getState(), STATE_READY)
self.assertEquals(self.monitor.state_changed_count, 5)
def testGetReleaseBinForFactoryStream(self):
factory = VideoTestSourceFactory()
stream = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv'),
'src0')
factory.addOutputStream(stream)
# try to get a cached instance
self.failUnlessRaises(PipelineError,
self.pipeline.getBinForFactoryStream, factory,
stream, False)
# create a bin
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.failUnless(isinstance(bin1, gst.Element))
# return the cached instance
bin2 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.failUnlessEqual(id(bin1), id(bin2))
self.pipeline.releaseBinForFactoryStream(factory, stream)
self.pipeline.releaseBinForFactoryStream(factory, stream)
# the bin has been destroyed at this point
self.failUnlessRaises(PipelineError,
self.pipeline.releaseBinForFactoryStream,
factory, stream)
# we should get a new instance
bin2 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.pipeline.releaseBinForFactoryStream(factory, stream)
def testGetReleaseTeeForFactoryStream(self):
factory = VideoTestSourceFactory()
stream = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv'),
'src')
factory.addOutputStream(stream)
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory,
stream, True)
# getBinForFactoryStream(factory, stream) must be called before
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory,
stream, True)
# create the bin
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
# try to get a cached tee
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory,
stream, False)
# create tee
tee1 = self.pipeline.getTeeForFactoryStream(factory, stream, True)
self.failUnless(isinstance(tee1, gst.Element))
# get the cached instance
tee2 = self.pipeline.getTeeForFactoryStream(factory, stream, True)
self.failUnlessEqual(id(tee1), id(tee2))
# release
self.pipeline.releaseTeeForFactoryStream(factory, stream)
# there's still a tee alive, so we can't release the bin
#self.failUnlessRaises(PipelineError,
# self.pipeline.releaseBinForFactoryStream, factory, stream)
self.pipeline.releaseTeeForFactoryStream(factory, stream)
self.failUnlessRaises(PipelineError,
self.pipeline.releaseTeeForFactoryStream,
factory, stream)
# should always fail with a sink bin
factory2 = FakeSinkFactory()
stream2 = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv'),
'src')
factory2.addInputStream(stream2)
self.failUnlessRaises(PipelineError,
self.pipeline.getTeeForFactoryStream, factory2,
stream2, True)
self.pipeline.releaseBinForFactoryStream(factory, stream)
def testGetReleaseQueueForFactoryStream(self):
factory = FakeSinkFactory()
stream = VideoStream(gst.Caps('any'), 'sink')
factory.addInputStream(stream)
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory,
stream, True)
# getBinForFactoryStream(factory, stream) must be called before
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory,
stream, True)
# create the bin
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
# try to get a cached queue
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory,
stream, False)
# create queue
queue1 = self.pipeline.getQueueForFactoryStream(factory, stream, True)
self.failUnless(isinstance(queue1, gst.Element))
gst.debug("pouet")
# get the cached instance
queue2 = self.pipeline.getQueueForFactoryStream(factory, stream, True)
self.failUnlessEqual(id(queue1), id(queue2))
# release
self.pipeline.releaseQueueForFactoryStream(factory, stream)
gst.debug("pouet")
# there's still a queue alive, so we can't release the bin
self.failUnlessRaises(PipelineError,
self.pipeline.releaseBinForFactoryStream,
factory, stream)
self.pipeline.releaseQueueForFactoryStream(factory, stream)
gst.debug("pouet2")
self.failUnlessRaises(PipelineError,
self.pipeline.releaseQueueForFactoryStream,
factory, stream)
# should always fail with a src bin
factory2 = VideoTestSourceFactory()
stream2 = VideoStream(gst.Caps('any'), 'src')
factory2.addOutputStream(stream2)
bin1 = self.pipeline.getBinForFactoryStream(factory, stream, True)
self.failUnlessRaises(PipelineError,
self.pipeline.getQueueForFactoryStream, factory2,
stream2, True)
self.pipeline.releaseBinForFactoryStream(factory, stream)
self.pipeline.releaseBinForFactoryStream(factory, stream)
self.assertEquals(factory.current_bins, 0)
