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)
