def testVideoProperties(self): expected = { 'videotype': 'video/x-raw-rgb', 'width': 320, 'height': 240, 'framerate': gst.Fraction(30, 1), 'format': None, 'par': gst.Fraction(1, 1), 'dar': gst.Fraction(4, 3) } stream = VideoStream(self.unfixed_caps) self.checkProperties(stream, expected) expected['videotype'] = 'video/x-raw-yuv' expected['format'] = gst.Fourcc('I420') stream = VideoStream(self.fixed_caps) self.checkProperties(stream, expected) expected['videotype'] = 'video/x-theora' expected['width'] = None expected['height'] = None expected['format'] = None expected['framerate'] = gst.Fraction(1, 1) stream = VideoStream(self.non_raw_caps) self.checkProperties(stream, expected)
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 = FakeSourceFactory() 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)
def testLoadTimeline(self): # we need a project for this to work self.formatter.project = Project() # create fake document tree timeline_element = Element("timeline") tracks_element = SubElement(timeline_element, "tracks") track_element = SubElement(tracks_element, "track") stream_element = SubElement(track_element, "stream", id="1", type="pitivi.stream.VideoStream", caps="video/x-raw-rgb") track_objects_element = SubElement(track_element, "track-objects") track_object = SubElement( track_objects_element, "track-object", type="pitivi.timeline.track.SourceTrackObject", start=ts(1 * gst.SECOND), duration=ts(10 * gst.SECOND), in_point=ts(5 * gst.SECOND), media_duration=ts(15 * gst.SECOND), priority=ts(5), id="1") factory_ref = SubElement(track_object, "factory-ref", id="1") stream_ref = SubElement(track_object, "stream-ref", id="1") timeline_objects_element = SubElement(timeline_element, "timeline-objects") timeline_object_element = \ SubElement(timeline_objects_element, "timeline-object") factory_ref = SubElement(timeline_object_element, "factory-ref", id="1") stream_ref = SubElement(timeline_object_element, "stream-ref", id="1") track_object_refs = SubElement(timeline_object_element, "track-object-refs") track_object_ref = SubElement(track_object_refs, "track-object-ref", id="1") # insert fake streams and factories into context factory = VideoTestSourceFactory() self.formatter._context.factories["1"] = factory stream = VideoStream(gst.Caps("video/x-raw-rgb")) self.formatter._context.streams["1"] = stream video_stream = VideoStream(gst.Caps("video/x-raw-yuv")) source1 = VideoTestSourceFactory() self.formatter._context.factories["2"] = source1 self.formatter._context.track_objects["1"] = SourceTrackObject( source1, video_stream) # point gun at foot; pull trigger self.formatter._loadTimeline(timeline_element) self.failUnlessEqual(len(self.formatter.project.timeline.tracks), 1)
def testMakeStreamBin(self): # streams are usually populated by the discoverer so here we have to do # that ourselves video1 = VideoStream(gst.Caps('video/x-raw-rgb, width=2048'), pad_name='src0') video2 = VideoStream(gst.Caps('video/x-raw-rgb, width=320'), pad_name='src1') audio = AudioStream(gst.Caps('audio/x-raw-int'), pad_name='src2') self.factory.addOutputStream(video1) self.factory.addOutputStream(video2) self.factory.addOutputStream(audio)
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 testSaveStreamRef(self): # save a stream so that a mapping is created in the context stream = VideoStream(gst.Caps("video/x-raw-rgb, blah=meh")) element = self.formatter._saveStream(stream) element_ref = self.formatter._saveStreamRef(stream) self.failUnlessEqual(element_ref.tag, "stream-ref") self.failUnlessEqual(element_ref.attrib["id"], element.attrib["id"])
def testLoadTrack(self): # create fake document tree element = Element("track") stream_element = SubElement(element, "stream", id="1", type="pitivi.stream.VideoStream", caps="video/x-raw-rgb") track_objects_element = SubElement(element, "track-objects") track_object = SubElement( track_objects_element, "track-object", type="pitivi.timeline.track.SourceTrackObject", start=ts(1 * gst.SECOND), duration=ts(10 * gst.SECOND), in_point=ts(5 * gst.SECOND), media_duration=ts(15 * gst.SECOND), priority=ts(5), id="1") factory_ref = SubElement(track_object, "factory-ref", id="1") stream_ref = SubElement(track_object, "stream-ref", id="1") # insert fake factories and streams into current context factory = VideoTestSourceFactory() self.formatter._context.factories["1"] = factory stream = VideoStream(gst.Caps("video/x-raw-rgb")) self.formatter._context.streams["1"] = stream # point gun at foot; pull trigger track = self.formatter._loadTrack(element) self.failUnlessEqual(len(track.track_objects), 1) # FIXME: this is an hack self.failUnlessEqual(str(track.stream), str(stream))
def testSaveStream(self): stream = VideoStream(gst.Caps("video/x-raw-rgb, blah=meh")) element = self.formatter._saveStream(stream) self.failUnlessEqual(element.tag, "stream") self.failUnless("id" in element.attrib) self.failUnlessEqual(element.attrib["type"], qual(stream.__class__)) self.failUnlessEqual(element.attrib["caps"], str(stream.caps))
def setUp(self): TestCase.setUp(self) self.factory = StubFactory() self.stream = VideoStream(gst.Caps('video/x-raw-rgb')) self.factory.addOutputStream(self.stream) self.track1 = Track(self.stream) self.track2 = Track(self.stream)
def testSaveTimeline(self): video_stream = VideoStream(gst.Caps("video/x-raw-yuv")) audio_stream = AudioStream(gst.Caps("audio/x-raw-int")) source1 = VideoTestSourceFactory() source1.addOutputStream(video_stream) self.formatter._saveSource(source1) self.formatter._saveStream(video_stream) track_object = SourceTrackObject(source1, video_stream, start=10 * gst.SECOND, duration=20 * gst.SECOND, in_point=5 * gst.SECOND, media_duration=15 * gst.SECOND, priority=10) track = Track(video_stream) track.addTrackObject(track_object) self.formatter._saveTrackObject(track_object) timeline_object = TimelineObject(source1) timeline_object.addTrackObject(track_object) self.formatter._saveTimelineObject(timeline_object) timeline = Timeline() timeline.addTrack(track) element = self.formatter._saveTimeline(timeline) self.failUnlessEqual(element.tag, "timeline") tracks = element.find("tracks") self.failUnlessEqual(len(tracks), 1)
def testMakeAndReleaseBin(self): caps = gst.Caps('video/x-raw-yuv') stream1 = VideoStream(caps) # calling factory.makeBin(stream) with a stream that doesn't belong to a # factory should result in an error self.failUnlessRaises(ObjectFactoryError, self.factory.makeBin, stream1) self.failUnlessEqual(self.factory.current_bins, 0) self.failUnlessEqual(self.monitor.bin_created_count, 0) # check makeBin with a specific stream bin1 = self.factory.makeBin(self.stream) self.failUnlessEqual(self.factory.current_bins, 1) self.failUnlessEqual(self.monitor.bin_created_count, 1) self.failUnless(isinstance(bin1, gst.Bin)) # now check the "default" bin case bin2 = self.factory.makeBin() self.failUnlessEqual(self.factory.current_bins, 2) self.failUnlessEqual(self.monitor.bin_created_count, 2) self.failUnless(isinstance(bin2, gst.Bin)) self.factory.releaseBin(bin1) self.failUnlessEqual(self.factory.current_bins, 1) self.failUnlessEqual(self.monitor.bin_released_count, 1) self.factory.releaseBin(bin2) self.failUnlessEqual(self.factory.current_bins, 0) self.failUnlessEqual(self.monitor.bin_released_count, 2)
def testPads(self): timeline = Timeline() stream1 = VideoStream(gst.Caps('video/x-raw-rgb'), 'src0') stream2 = AudioStream(gst.Caps('audio/x-raw-int'), 'src1') track1 = Track(stream1) track2 = Track(stream2) timeline.addTrack(track1) timeline.addTrack(track2) factory = TimelineSourceFactory(timeline) bin = factory.makeBin() self.failUnlessEqual(len(list(bin.src_pads())), 0) pad1 = gst.Pad('src0', gst.PAD_SRC) pad1.set_caps(gst.Caps('asd')) pad1.set_active(True) track1.composition.add_pad(pad1) pad2 = gst.Pad('src0', gst.PAD_SRC) pad2.set_caps(gst.Caps('asd')) pad2.set_active(True) track2.composition.add_pad(pad2) self.failUnlessEqual(len(list(bin.src_pads())), 2) track1.composition.remove_pad(pad1) self.failUnlessEqual(len(list(bin.src_pads())), 1) track2.composition.remove_pad(pad2) self.failUnlessEqual(len(list(bin.src_pads())), 0) factory.clean()
def testSavetimelineObjects(self): video_stream = VideoStream(gst.Caps("video/x-raw-yuv")) audio_stream = AudioStream(gst.Caps("audio/x-raw-int")) source1 = FileSourceFactory("file1.ogg") source1.addOutputStream(video_stream) # these two calls are needed to populate the context for the -ref # elements self.formatter._saveSource(source1) self.formatter._saveStream(video_stream) track_object = SourceTrackObject(source1, video_stream, start=10 * gst.SECOND, duration=20 * gst.SECOND, in_point=5 * gst.SECOND, media_duration=15 * gst.SECOND, priority=10) track = Track(video_stream) track.addTrackObject(track_object) self.formatter._saveTrackObject(track_object) timeline_object = TimelineObject(source1) timeline_object.addTrackObject(track_object) element = self.formatter._saveTimelineObjects([timeline_object]) self.failUnlessEqual(len(element), 1)
def testLoadStreamRef(self): stream = VideoStream(gst.Caps("meh")) self.formatter._context.streams["1"] = stream element = Element("stream-ref") element.attrib["id"] = "1" stream1 = self.formatter._loadStreamRef(element) self.failUnlessEqual(stream, stream1)
def testTracks(self): timeline = Timeline() stream1 = VideoStream(gst.Caps('video/x-raw-rgb'), 'src0') stream2 = AudioStream(gst.Caps('audio/x-raw-int'), 'src1') track1 = Track(stream1) track2 = Track(stream2) # start with 2 tracks timeline.addTrack(track1) timeline.addTrack(track2) factory = TimelineSourceFactory(timeline) bin = factory.makeBin() self.failUnlessEqual(len(list(bin)), 2) self.failUnlessEqual(set(factory.getOutputStreams()), set([stream1, stream2])) # add a new track stream3 = AudioStream(gst.Caps('audio/x-raw-int'), 'src2') track3 = Track(stream3) timeline.addTrack(track3) self.failUnlessEqual(len(list(bin)), 3) self.failUnlessEqual(set(factory.getOutputStreams()), set([stream1, stream2, stream3])) # remove a track timeline.removeTrack(track3) self.failUnlessEqual(len(list(bin)), 2) self.failUnlessEqual(set(factory.getOutputStreams()), set([stream1, stream2])) factory.clean()
def testSaveTrack(self): video_stream = VideoStream(gst.Caps("video/x-raw-yuv")) audio_stream = AudioStream(gst.Caps("audio/x-raw-int")) source1 = VideoTestSourceFactory() # these two calls are needed to populate the context for the -ref # elements self.formatter._saveSource(source1) self.formatter._saveStream(video_stream) track_object = SourceTrackObject(source1, video_stream, start=10 * gst.SECOND, duration=20 * gst.SECOND, in_point=5 * gst.SECOND, media_duration=15 * gst.SECOND, priority=10) track = Track(video_stream) track.addTrackObject(track_object) element = self.formatter._saveTrack(track) self.failUnlessEqual(element.tag, "track") track_objects_element = element.find("track-objects") self.failUnlessEqual(len(track_objects_element), 1)
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 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 newBlankProject(self): """ start up a new blank project """ # if there's a running project we must close it if self.current is not None and not self.closeRunningProject(): return False # we don't have an URI here, None means we're loading a new project self.emit("new-project-loading", None) project = Project(_("New Project")) self.emit("new-project-created", project) self.current = project # FIXME: this should not be hard-coded # add default tracks for a new project video = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv')) track = Track(video) project.timeline.addTrack(track) audio = AudioStream(gst.Caps('audio/x-raw-int; audio/x-raw-float')) track = Track(audio) project.timeline.addTrack(track) project.connect("project-changed", self._projectChangedCb) self.emit("new-project-loaded", self.current) return True
def testPendingLink(self): a = Action() p = Pipeline() src = common.FakeGnlFactory() src.addOutputStream(VideoStream(gst.Caps("video/x-raw-yuv"), pad_name="src")) sink = common.FakeSinkFactory() sink.addInputStream(MultimediaStream(gst.Caps("any"), pad_name="sink")) # set the link, it will be activated once the pad is added a.setLink(src, sink) # Let's see if the link is present self.assertEquals(a._links, [(src, sink, None, None)]) p.setAction(a) gst.debug("about to activate action") a.activate() # only the producer and the consumer are created, the other elements are # created dinamically self.assertEquals(len(list(p._pipeline.elements())), 2) p.setState(STATE_PLAYING) time.sleep(1) # and make sure that all other elements were created (4) # FIXME if it's failing here, run the test a few times trying to raise # the time.sleep() above, it may just be racy... self.assertEquals(len(list(p._pipeline.elements())), 4) a.deactivate() p.setState(STATE_NULL) self.assertEquals(len(list(p._pipeline.elements())), 0) p.release()
def testParAndDar(self): caps = gst.Caps('video/x-raw-int, width=320, height=240, ' 'pixel-aspect-ratio=2/1') stream = VideoStream(caps) self.failUnlessEqual(stream.par, gst.Fraction(2, 1)) self.failUnlessEqual(stream.dar, gst.Fraction(640, 240)) caps = gst.Caps('video/x-raw-int, width=320, height=240') stream = VideoStream(caps) self.failUnlessEqual(stream.par, gst.Fraction(1, 1)) self.failUnlessEqual(stream.dar, gst.Fraction(320, 240)) # no width and height, default to 4/3 caps = gst.Caps('video/x-raw-int') stream = VideoStream(caps) self.failUnlessEqual(stream.par, gst.Fraction(1, 1)) self.failUnlessEqual(stream.dar, gst.Fraction(4, 3))
def testDefaultMakeBin(self): # the default bin for FileSource is a bin containing decodebin # what we're testing here is that the method does return a bin and # doesn't rise exceptions. We're NOT changing the state of the bin. video1 = VideoStream(gst.Caps('video/x-raw-rgb, width=2048'), pad_name='src0') self.factory.addOutputStream(video1) bin = self.factory.makeBin() self.failUnless(isinstance(bin, gst.Bin)) self.factory.releaseBin(bin)
def setUp(self): common.TestCase.setUp(self) self.vsrc = common.FakeSourceFactory("videotestsrc") self.vsrc.addOutputStream( VideoStream(gst.Caps("video/x-raw-yuv"), pad_name="src")) self.asrc = common.FakeSourceFactory("audiotestsrc") self.asrc.addOutputStream( AudioStream(gst.Caps("audio/x-raw-float"), pad_name="src")) self.vsettings = StreamEncodeSettings(encoder="theoraenc") self.asettings = StreamEncodeSettings(encoder="vorbisenc")
def testMatchStreamNoMatch(self): s1 = AudioStream(gst.Caps("audio/x-vorbis")) s2 = VideoStream(gst.Caps("video/x-theora")) stream, rank = match_stream(s1, []) self.failUnlessEqual(stream, None) self.failUnlessEqual(rank, STREAM_MATCH_NONE) stream, rank = match_stream(s1, [s2]) self.failUnlessEqual(stream, None) self.failUnlessEqual(rank, STREAM_MATCH_NONE)
def setUp(self): TestCase.setUp(self) self.factory = StubSourceFactory('name') caps = gst.Caps('video/x-raw-rgb') self.stream = VideoStream(caps, pad_name='src0') # source factories can't have input streams self.failUnlessRaises(AssertionError, self.factory.addInputStream, self.stream) self.factory.addOutputStream(self.stream) self.monitor = SignalMonitor(self.factory, 'bin-created', 'bin-released')
def _fillTimeline(self): # audio and video track video = VideoStream(gst.Caps('video/x-raw-rgb; video/x-raw-yuv')) track = Track(video) self.project.timeline.addTrack(track) audio = AudioStream(gst.Caps('audio/x-raw-int; audio/x-raw-float')) track = Track(audio) self.project.timeline.addTrack(track) for uri in self._uris: factory = self.project.sources.getUri(uri) self.project.timeline.addSourceFactory(factory)
def testSaveFactoryRef(self): video_stream = VideoStream(gst.Caps("video/x-raw-yuv")) audio_stream = AudioStream(gst.Caps("audio/x-raw-int")) source1 = FileSourceFactory("file1.ogg") source1.addOutputStream(video_stream) source1.addOutputStream(audio_stream) element = self.formatter._saveSource(source1) element_ref = self.formatter._saveFactoryRef(source1) self.failUnlessEqual(element_ref.tag, "factory-ref") self.failUnlessEqual(element_ref.attrib["id"], element.attrib["id"])
def testSaveSource(self): video_stream = VideoStream(gst.Caps("video/x-raw-yuv")) audio_stream = AudioStream(gst.Caps("audio/x-raw-int")) source1 = FileSourceFactory("file1.ogg") source1.addOutputStream(video_stream) source1.addOutputStream(audio_stream) element = self.formatter._saveSource(source1) self.failUnlessEqual(element.tag, "source") self.failUnlessEqual(element.attrib["type"], qual(source1.__class__)) self.failUnlessEqual(element.attrib["filename"], "file1.ogg") streams = element.find("output-streams") self.failUnlessEqual(len(streams), 2)
def testMakeStreamBin(self): # streams are usually populated by the discoverer so here we have to do # that ourselves video = VideoStream(gst.Caps('video/x-raw-rgb'), pad_name='src0') audio = AudioStream(gst.Caps('audio/x-raw-int'), pad_name='src1') self.factory.addOutputStream(video) self.factory.addOutputStream(audio) bin = self.factory.makeBin(video) self.failUnless(hasattr(bin, "decodebin")) self.failUnless(isinstance(bin.decodebin, StubSingleDecodeBin)) self.failUnlessEqual(bin.decodebin.uri, 'file:///path/to/file') self.failUnlessEqual(video.caps, bin.decodebin.caps) self.failUnlessEqual(video, bin.decodebin.stream) self.factory.releaseBin(bin)
def testDefaultBinGhostPads(self): caps = gst.Caps('video/x-raw-rgb, width=2048') video1 = VideoStream(caps, pad_name='src0') self.factory.addOutputStream(video1) bin = self.factory.makeBin() pad = gst.Pad('src', gst.PAD_SRC) pad.set_caps(caps) self.failUnlessEqual(bin.get_pad('src'), None) bin.decodebin.add_pad(pad) self.failIfEqual(bin.get_pad('src'), None) bin.decodebin.remove_pad(pad) self.failUnlessEqual(bin.get_pad('src'), None) self.factory._releaseBin(bin)