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 testConnectionAndDisconnection(self):
timeline = Timeline()
stream = new_stream()
factory = new_source_factory()
track = Track(stream)
track_object1 = SourceTrackObject(factory, stream)
track.addTrackObject(track_object1)
timeline.addTrack(track)
timeline_object1 = TimelineObject(factory)
timeline_object1.addTrackObject(track_object1)
timeline.addTimelineObject(timeline_object1)
self.observer.startObserving(timeline)
self.failUnless(timeline.connected)
self.failUnless(timeline_object1.connected)
timeline.removeTimelineObject(timeline_object1)
self.failIf(timeline_object1.connected)
timeline.addTimelineObject(timeline_object1)
self.failUnless(timeline_object1)
self.observer.stopObserving(timeline)
self.failIf(timeline.connected)
self.failIf(timeline_object1.connected)
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 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 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 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 testConnectionAndDisconnection(self):
timeline = Timeline()
stream = new_stream()
factory = new_source_factory()
track = Track(stream)
track_object1 = SourceTrackObject(factory, stream)
track.addTrackObject(track_object1)
timeline.addTrack(track)
timeline_object1 = TimelineObject(factory)
timeline_object1.addTrackObject(track_object1)
timeline.addTimelineObject(timeline_object1)
self.observer.startObserving(timeline)
self.failUnless(timeline.connected)
self.failUnless(timeline_object1.connected)
timeline.removeTimelineObject(timeline_object1)
self.failIf(timeline_object1.connected)
timeline.addTimelineObject(timeline_object1)
self.failUnless(timeline_object1)
self.observer.stopObserving(timeline)
self.failIf(timeline.connected)
self.failIf(timeline_object1.connected)
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 testAudioOnly(self):
audio_factory1 = AudioTestSourceFactory(3)
audio_factory1.duration = 10 * gst.SECOND
stream = AudioStream(gst.Caps('audio/x-raw-int'), 'src0')
audio_factory1.addOutputStream(stream)
timeline = Timeline()
track = Track(stream)
track_object1 = SourceTrackObject(audio_factory1, stream)
track_object1.start = 2 * gst.SECOND
track.addTrackObject(track_object1)
timeline.addTrack(track)
factory = TimelineSourceFactory(timeline)
bin = factory.makeBin()
self.failUnlessEqual(len(list(bin)), 1)
self.failUnlessEqual(factory.duration, 12 * gst.SECOND)
fakesink = gst.element_factory_make('fakesink')
def bin_pad_added_cb(bin, pad):
pad.link(fakesink.get_pad('sink'))
bin.connect('pad-added', bin_pad_added_cb)
def error_cb(bus, message):
gerror, debug = message.parse_error()
self.fail('%s: %s' % (gerror.message, debug))
def eos_cb(bus, message):
self.loop.quit()
pipeline = gst.Pipeline()
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message::error', error_cb)
bus.connect('message::eos', eos_cb)
pipeline.add(bin)
pipeline.add(fakesink)
pipeline.set_state(gst.STATE_PLAYING)
self.loop.run()
pipeline.set_state(gst.STATE_NULL)
factory.clean()
def testAudioOnly(self):
audio_factory1 = AudioTestSourceFactory(3)
audio_factory1.duration = 10 * gst.SECOND
stream = AudioStream(gst.Caps('audio/x-raw-int'), 'src0')
audio_factory1.addOutputStream(stream)
timeline = Timeline()
track = Track(stream)
track_object1 = SourceTrackObject(audio_factory1, stream)
track_object1.start = 2 * gst.SECOND
track.addTrackObject(track_object1)
timeline.addTrack(track)
factory = TimelineSourceFactory(timeline)
bin = factory.makeBin()
self.failUnlessEqual(len(list(bin)), 1)
self.failUnlessEqual(factory.duration, 12 * gst.SECOND)
fakesink = gst.element_factory_make('fakesink')
def bin_pad_added_cb(bin, pad):
pad.link(fakesink.get_pad('sink'))
bin.connect('pad-added', bin_pad_added_cb)
def error_cb(bus, message):
gerror, debug = message.parse_error()
self.fail('%s: %s' % (gerror.message, debug))
def eos_cb(bus, message):
self.loop.quit()
pipeline = gst.Pipeline()
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect('message::error', error_cb)
bus.connect('message::eos', eos_cb)
pipeline.add(bin)
pipeline.add(fakesink)
pipeline.set_state(gst.STATE_PLAYING)
self.loop.run()
pipeline.set_state(gst.STATE_NULL)
factory.clean()
def testLoadProject(self):
video_stream = VideoStream(gst.Caps("video/x-raw-yuv"))
audio_stream = AudioStream(gst.Caps("audio/x-raw-int"))
source1 = VideoTestSourceFactory()
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)
self.formatter._saveTimeline(timeline)
project = Project()
project.timeline = timeline
project.sources.addFactory(source1)
element = self.formatter._serializeProject(project)
self.failUnlessEqual(element.tag, "pitivi")
self.failIfEqual(element.find("factories"), None)
self.failIfEqual(element.find("timeline"), None)
indent(element)
f = file("/tmp/untitled.pptv", "w")
f.write(tostring(element))
f.close()
def testLoadProject(self):
video_stream = VideoStream(gst.Caps("video/x-raw-yuv"))
audio_stream = AudioStream(gst.Caps("audio/x-raw-int"))
source1 = VideoTestSourceFactory()
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)
self.formatter._saveTimeline(timeline)
project = Project()
project.timeline = timeline
project.sources.addFactory(source1)
element = self.formatter._serializeProject(project)
self.failUnlessEqual(element.tag, "pitivi")
self.failIfEqual(element.find("factories"), None)
self.failIfEqual(element.find("timeline"), None)
indent(element)
f = file("/tmp/untitled.pptv", "w")
f.write(tostring(element))
f.close()
class TestTimelineUndo(TestCase):
def setUp(self):
self.stream = new_stream()
self.factory = new_source_factory()
self.effect_factory = TestEffectFactory(self.stream)
self.track1 = Track(self.stream)
self.track2 = Track(self.stream)
self.timeline = Timeline()
self.timeline.addTrack(self.track1)
self.timeline.addTrack(self.track2)
self.track_object1 = SourceTrackObject(self.factory, self.stream)
self.track_object2 = SourceTrackObject(self.factory, self.stream)
self.track_effect1 = TrackEffect(self.effect_factory, self.stream)
self.track_effect2 = TrackEffect(self.effect_factory, self.stream)
self.track1.addTrackObject(self.track_object1)
self.track2.addTrackObject(self.track_object2)
self.timeline_object1 = TimelineObject(self.factory)
self.timeline_object1.addTrackObject(self.track_object1)
self.timeline_object1.addTrackObject(self.track_object2)
self.action_log = UndoableActionLog()
self.observer = TestTimelineLogObserver(self.action_log)
self.observer.startObserving(self.timeline)
def testAddTimelineObject(self):
stacks = []
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.action_log.begin("add clip")
self.timeline.addTimelineObject(self.timeline_object1)
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TimelineObjectAdded))
self.failUnless(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.undo()
self.failIf(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.redo()
self.failUnless(self.timeline_object1 \
in self.timeline.timeline_objects)
def testRemoveTimelineObject(self):
stacks = []
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.timeline.addTimelineObject(self.timeline_object1)
self.action_log.begin("remove clip")
self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TimelineObjectRemoved))
self.failIf(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.undo()
self.failUnless(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.redo()
self.failIf(self.timeline_object1 \
in self.timeline.timeline_objects)
def testAddEffectToTimelineObject(self):
stacks = []
pipeline = Pipeline()
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.observer.pipeline = pipeline
#FIXME Should I commit it and check there are 2 elements
#in the stacks
self.timeline.addTimelineObject(self.timeline_object1)
self.track1.addTrackObject(self.track_effect1)
self.action_log.begin("add effect")
self.timeline_object1.addTrackObject(self.track_effect1)
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TrackEffectAdded))
self.failUnless(self.track_effect1 \
in self.timeline_object1.track_objects)
self.failUnless(self.track_effect1 \
in self.track1.track_objects)
self.failUnless(len([effect for effect in \
self.timeline_object1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.failUnless(len([effect for effect in self.track1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.action_log.undo()
self.failIf(self.track_effect1 \
in self.timeline_object1.track_objects)
self.failIf(self.track_effect1 \
in self.track1.track_objects)
self.action_log.redo()
self.failUnless(len([effect for effect in
self.timeline_object1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.failUnless(len([effect for effect in self.track1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
def testTimelineObjectPropertyChange(self):
stacks = []
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.timeline_object1.start = 5 * gst.SECOND
self.timeline_object1.duration = 20 * gst.SECOND
self.timeline.addTimelineObject(self.timeline_object1)
self.action_log.begin("modify clip")
self.timeline_object1.start = 10 * gst.SECOND
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TimelineObjectPropertyChanged))
self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)
self.action_log.undo()
self.failUnlessEqual(self.timeline_object1.start, 5 * gst.SECOND)
self.action_log.redo()
self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)
self.timeline_object1.priority = 10
self.action_log.begin("priority change")
self.timeline_object1.priority = 20
self.action_log.commit()
self.failUnlessEqual(self.timeline_object1.priority, 20)
self.action_log.undo()
self.failUnlessEqual(self.timeline_object1.priority, 10)
self.action_log.redo()
self.failUnlessEqual(self.timeline_object1.priority, 20)
def testUngroup(self):
self.timeline_object1.start = 5 * gst.SECOND
self.timeline_object1.duration = 20 * gst.SECOND
self.timeline.addTimelineObject(self.timeline_object1)
self.timeline.setSelectionToObj(self.track_object1, SELECT_ADD)
self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
self.failUnlessEqual(self.timeline.timeline_objects[0].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
20 * gst.SECOND)
self.action_log.begin("ungroup")
self.timeline.ungroupSelection()
self.action_log.commit()
self.failUnlessEqual(len(self.timeline.timeline_objects), 2)
self.failUnlessEqual(self.timeline.timeline_objects[0].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
20 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[1].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[1].duration,
20 * gst.SECOND)
self.action_log.undo()
self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
self.failUnlessEqual(self.timeline.timeline_objects[0].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
20 * gst.SECOND)
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 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 TestTimelineUndo(TestCase):
def setUp(self):
self.stream = new_stream()
self.factory = new_source_factory()
self.effect_factory = TestEffectFactory(self.stream)
self.track1 = Track(self.stream)
self.track2 = Track(self.stream)
self.timeline = Timeline()
self.timeline.addTrack(self.track1)
self.timeline.addTrack(self.track2)
self.track_object1 = SourceTrackObject(self.factory, self.stream)
self.track_object2 = SourceTrackObject(self.factory, self.stream)
self.track_effect1 = TrackEffect(self.effect_factory, self.stream)
self.track_effect2 = TrackEffect(self.effect_factory, self.stream)
self.track1.addTrackObject(self.track_object1)
self.track2.addTrackObject(self.track_object2)
self.timeline_object1 = TimelineObject(self.factory)
self.timeline_object1.addTrackObject(self.track_object1)
self.timeline_object1.addTrackObject(self.track_object2)
self.action_log = UndoableActionLog()
self.observer = TestTimelineLogObserver(self.action_log)
self.observer.startObserving(self.timeline)
def testAddTimelineObject(self):
stacks = []
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.action_log.begin("add clip")
self.timeline.addTimelineObject(self.timeline_object1)
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TimelineObjectAdded))
self.failUnless(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.undo()
self.failIf(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.redo()
self.failUnless(self.timeline_object1 \
in self.timeline.timeline_objects)
def testRemoveTimelineObject(self):
stacks = []
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.timeline.addTimelineObject(self.timeline_object1)
self.action_log.begin("remove clip")
self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TimelineObjectRemoved))
self.failIf(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.undo()
self.failUnless(self.timeline_object1 \
in self.timeline.timeline_objects)
self.action_log.redo()
self.failIf(self.timeline_object1 \
in self.timeline.timeline_objects)
def testAddEffectToTimelineObject(self):
stacks = []
pipeline = Pipeline()
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.observer.pipeline = pipeline
#FIXME Should I commit it and check there are 2 elements
#in the stacks
self.timeline.addTimelineObject(self.timeline_object1)
self.track1.addTrackObject(self.track_effect1)
self.action_log.begin("add effect")
self.timeline_object1.addTrackObject(self.track_effect1)
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TrackEffectAdded))
self.failUnless(self.track_effect1 \
in self.timeline_object1.track_objects)
self.failUnless(self.track_effect1 \
in self.track1.track_objects)
self.failUnless(len([effect for effect in \
self.timeline_object1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.failUnless(len([effect for effect in self.track1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.action_log.undo()
self.failIf(self.track_effect1 \
in self.timeline_object1.track_objects)
self.failIf(self.track_effect1 \
in self.track1.track_objects)
self.action_log.redo()
self.failUnless(len([effect for effect in
self.timeline_object1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.failUnless(len([effect for effect in self.track1.track_objects
if isinstance(effect, TrackEffect)]) == 1)
self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
def testTimelineObjectPropertyChange(self):
stacks = []
def commitCb(action_log, stack, nested):
stacks.append(stack)
self.action_log.connect("commit", commitCb)
self.timeline_object1.start = 5 * gst.SECOND
self.timeline_object1.duration = 20 * gst.SECOND
self.timeline.addTimelineObject(self.timeline_object1)
self.action_log.begin("modify clip")
self.timeline_object1.start = 10 * gst.SECOND
self.action_log.commit()
self.failUnlessEqual(len(stacks), 1)
stack = stacks[0]
self.failUnlessEqual(len(stack.done_actions), 1)
action = stack.done_actions[0]
self.failUnless(isinstance(action, TimelineObjectPropertyChanged))
self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)
self.action_log.undo()
self.failUnlessEqual(self.timeline_object1.start, 5 * gst.SECOND)
self.action_log.redo()
self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)
self.timeline_object1.priority = 10
self.action_log.begin("priority change")
self.timeline_object1.priority = 20
self.action_log.commit()
self.failUnlessEqual(self.timeline_object1.priority, 20)
self.action_log.undo()
self.failUnlessEqual(self.timeline_object1.priority, 10)
self.action_log.redo()
self.failUnlessEqual(self.timeline_object1.priority, 20)
def testUngroup(self):
self.timeline_object1.start = 5 * gst.SECOND
self.timeline_object1.duration = 20 * gst.SECOND
self.timeline.addTimelineObject(self.timeline_object1)
self.timeline.setSelectionToObj(self.track_object1, SELECT_ADD)
self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
self.failUnlessEqual(self.timeline.timeline_objects[0].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
20 * gst.SECOND)
self.action_log.begin("ungroup")
self.timeline.ungroupSelection()
self.action_log.commit()
self.failUnlessEqual(len(self.timeline.timeline_objects), 2)
self.failUnlessEqual(self.timeline.timeline_objects[0].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
20 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[1].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[1].duration,
20 * gst.SECOND)
self.action_log.undo()
self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
self.failUnlessEqual(self.timeline.timeline_objects[0].start,
5 * gst.SECOND)
self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
20 * gst.SECOND)
