def testMultiple(self): """Test a dual stream encoding with separates sources""" settings = RenderSettings(settings=[self.asettings, self.vsettings], muxer="oggmux") sf = RenderSinkFactory(RenderFactory(settings=settings), common.FakeSinkFactory()) a = RenderAction() a.addConsumers(sf) a.addProducers(self.vsrc, self.asrc) p = Pipeline() a.setPipeline(p) a.activate() self.assertEquals(len(a._links), 2) p.play() time.sleep(3) p.getState() p.stop() a.deactivate() a.unsetPipeline() p.release()
def testSimpleStreams(self): """Test a RenderSettings with exact stream settings""" # let's force the video to some unusual size outs = VideoStream(gst.Caps("video/x-raw-yuv,width=624,height=230,framerate=10/1")) fset = StreamEncodeSettings(encoder="theoraenc", input_stream=outs) settings = RenderSettings(settings=[fset], muxer="oggmux") sf = RenderSinkFactory(RenderFactory(settings=settings), common.FakeSinkFactory()) a = RenderAction() a.addConsumers(sf) a.addProducers(self.vsrc) p = Pipeline() a.setPipeline(p) a.activate() self.assertEquals(len(a._links), 1) p.play() time.sleep(3) p.getState() p.stop() a.deactivate() p.release()
def testSimpleStreams(self): """Test a RenderSettings with exact stream settings""" # let's force the video to some unusual size outs = VideoStream( gst.Caps("video/x-raw-yuv,width=624,height=230,framerate=10/1")) fset = StreamEncodeSettings(encoder="theoraenc", input_stream=outs) settings = RenderSettings(settings=[fset], muxer="oggmux") sf = RenderSinkFactory(RenderFactory(settings=settings), common.FakeSinkFactory()) a = RenderAction() a.addConsumers(sf) a.addProducers(self.vsrc) p = Pipeline() a.setPipeline(p) a.activate() self.assertEquals(len(a._links), 1) p.play() time.sleep(3) p.getState() p.stop() a.deactivate() p.release()
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 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 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()