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 testSaveTimelineObject(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._saveTimelineObject(timeline_object)
self.failUnlessEqual(element.tag, "timeline-object")
self.failIfEqual(element.find("factory-ref"), None)
track_object_refs = element.find("track-object-refs")
self.failUnlessEqual(len(track_object_refs), 1)
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 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 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 _emitResult(self):
# we got a gst error, error out ASAP
if self.error:
self._emitError()
return True
have_video, have_audio, have_image = self._getCurrentStreamTypes()
missing_plugins = bool(self.missing_plugin_details)
if not self.current_streams and not missing_plugins:
# woot, nothing decodable
self.error = _('Can not decode file.')
self.error_detail = _("The given file does not contain audio, "
"video or picture streams.")
self._emitError()
return True
# construct the factory with the streams we found
if have_image and self.current_duration == gst.CLOCK_TIME_NONE:
factory = PictureFileSourceFactory(self.current_uri)
else:
factory = FileSourceFactory(self.current_uri)
factory.duration = self.current_duration
for stream in self.current_streams:
factory.addOutputStream(stream)
if not missing_plugins:
# make sure that we could query the duration (if it's an image, we
# assume it's got infinite duration)
is_image = have_image and len(self.current_streams) == 1
if self.current_duration == gst.CLOCK_TIME_NONE and not is_image:
self.error = _("Could not establish the duration of the file.")
self.error_detail = _(
"This clip seems to be in a format "
"which cannot be accessed in a random fashion.")
self._emitError()
return True
self._emitDone(factory)
return True
def callback(result):
self._installMissingPluginsCallback(result, factory)
res = self.emit("missing-plugins", self.current_uri, factory,
self.missing_plugin_details,
self.missing_plugin_descriptions, callback)
if res is None or res != INSTALL_PLUGINS_STARTED_OK:
# no missing-plugins handlers
if factory.getOutputStreams():
self._emitDone(factory)
else:
self._emitErrorMissingPlugins()
return True
# plugins are being installed, processing will continue when
# self._installMissingPluginsCallback is called by the application
return False
def testAddUriDiscoveryError(self):
uri = "file:///ciao"
factory = FileSourceFactory(uri)
self.sourcelist.addUri(uri)
self.failUnlessEqual(len(self.sourcelist.getSources()), 0)
self.failUnlessRaises(SourceListError, self.sourcelist.addUri, uri)
# mock discovery-done
self.sourcelist.discoverer.emit("discovery-error", uri, "error",
"verbose debug")
self.failUnlessEqual(len(self.sourcelist.getSources()), 0)
# there was an error, the factory wasn't added so this shouldn't raise
self.sourcelist.addUri(uri)
def testAddUriDiscoveryOk(self):
"""
Test the simple case of adding an uri.
"""
uri = "file:///ciao"
factory = FileSourceFactory(uri)
self.sourcelist.addUri(uri)
self.failUnlessEqual(len(self.sourcelist.getSources()), 0)
self.failUnlessRaises(SourceListError, self.sourcelist.getUri, uri)
# mock discovery-done
self.sourcelist.discoverer.emit("discovery-done", uri, factory)
self.failUnlessEqual(len(self.sourcelist.getSources()), 1)
self.failUnlessEqual(self.sourcelist.getUri(uri), factory)
def testAddUriDiscoveryErrorSourceGone(self):
"""
Same as the test above, but testing the discovery-error handler.
"""
uri = "file:///ciao"
factory = FileSourceFactory(uri)
self.sourcelist.addUri(uri)
self.sourcelist.removeUri(uri)
self.sourcelist.discoverer.emit("discovery-error", uri, "error",
"verbose debug")
self.failUnlessEqual(len(self.sourcelist.getSources()), 0)
# this shouldn't fail since we removed the factory before the discovery
# was complete
self.sourcelist.addUri(uri)
def testAddUriDiscoveryOkSourceGone(self):
"""
Test that we don't explode if discoverer finishes analyzing a source
that in the meantime was removed.
"""
uri = "file:///ciao"
factory = FileSourceFactory(uri)
self.sourcelist.addUri(uri)
self.sourcelist.removeUri(uri)
self.sourcelist.discoverer.emit("discovery-done", uri, factory)
self.failUnlessEqual(len(self.sourcelist.getSources()), 0)
# this shouldn't fail since we removed the factory before the discovery
# was complete
self.sourcelist.addUri(uri)
def testSaveFactories(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)
source2 = FileSourceFactory("file2.ogg")
source2.addOutputStream(video_stream)
source2.addOutputStream(audio_stream)
source_factories = [source1, source2]
element = self.formatter._saveFactories(source_factories)
self.failUnlessEqual(element.tag, "factories")
sources = element.find("sources")
self.failUnlessEqual(len(sources), 2)
def _viewerDndDataReceivedCb(self, unused_widget, context, unused_x, unused_y,
selection, targetType, ctime):
# FIXME : This should be handled by the main application who knows how
# to switch between pipelines.
self.info("context:%s, targetType:%s", context, targetType)
if targetType == dnd.TYPE_URI_LIST:
uri = selection.data.strip().split("\n")[0].strip()
elif targetType == dnd.TYPE_PITIVI_FILESOURCE:
uri = selection.data
else:
context.finish(False, False, ctime)
return
# Use factory from our source list if we have the given uri
try:
fact = self.project.sources.getUri(uri)
except SourceListError:
from pitivi.factories.file import FileSourceFactory
fact = FileSourceFactory(uri)
self._viewFactory(fact)
context.finish(True, False, ctime)
def testSaveFactories(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)
source2 = FileSourceFactory("file2.ogg")
source2.addOutputStream(video_stream)
source2.addOutputStream(audio_stream)
factories = [source1, source2]
element = self.formatter._saveFactories(factories)
self.failUnlessEqual(element.tag, "factories")
sources = element.find("sources")
self.failUnlessEqual(len(sources), 2)
def testSaveTrackObject(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)
# create an interpolator and insert it into the track object
fakevol = gst.element_factory_make("volume")
prop = get_controllable_properties(fakevol)[1][1]
volcurve = Interpolator(track_object, fakevol, prop)
track_object.interpolators[prop.name] = (prop, volcurve)
# add some points to the interpolator
value = float(0)
volcurve.start.setObjectTime(0)
volcurve.start.value = 0
for t in xrange(3, 15, 3):
value = int(t % 2)
volcurve.newKeyframe(t * gst.SECOND, value)
volcurve.end.setObjectTime(15 * gst.SECOND)
volcurve.end.value = 15 % 2
element = self.formatter._saveTrackObject(track_object)
self.failUnlessEqual(element.tag, "track-object")
self.failUnlessEqual(element.attrib["type"],
qual(track_object.__class__))
self.failUnlessEqual(element.attrib["start"], ts(10 * gst.SECOND))
self.failUnlessEqual(element.attrib["duration"], ts(20 * gst.SECOND))
self.failUnlessEqual(element.attrib["in_point"], ts(5 * gst.SECOND))
self.failUnlessEqual(element.attrib["media_duration"],
ts(15 * gst.SECOND))
self.failUnlessEqual(element.attrib["priority"], "(int)10")
self.failIfEqual(element.find("factory-ref"), None)
self.failIfEqual(element.find("stream-ref"), None)
# find the interpolation keyframes
curves = element.find("curves")
self.failIfEqual(curves, None)
curve = curves.find("curve")
self.failIfEqual(curve, None)
self.failUnlessEqual(curve.attrib["property"], "volume")
# compute a dictionary of keyframes
saved_points = dict(((obj.attrib["time"], (obj.attrib["value"],
obj.attrib["mode"])) for obj in curve.getiterator("keyframe")))
# compare this with the expected values
expected = dict(((str(t * gst.SECOND), ("(gdouble)%s" % (t % 2), "2")) for t in
xrange(3, 15, 3)))
self.failUnlessEqual(expected, saved_points)
def testSaveTrackSource(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_source = 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_source)
# create an interpolator and insert it into the track object
fakevol = gst.element_factory_make("volume")
prop = get_controllable_properties(fakevol)[1][1]
volcurve = Interpolator(track_source, fakevol, prop)
track_source.interpolators[prop.name] = (prop, volcurve)
# add some points to the interpolator
value = float(0)
volcurve.start.setObjectTime(0)
volcurve.start.value = 0
for t in xrange(3, 15, 3):
value = int(t % 2)
volcurve.newKeyframe(t * gst.SECOND, value)
volcurve.end.setObjectTime(15 * gst.SECOND)
volcurve.end.value = 15 % 2
element = self.formatter._saveTrackObject(track_source)
self.failUnlessEqual(element.tag, "track-object")
self.failUnlessEqual(element.attrib["type"],
qual(track_source.__class__))
self.failUnlessEqual(element.attrib["start"], ts(10 * gst.SECOND))
self.failUnlessEqual(element.attrib["duration"], ts(20 * gst.SECOND))
self.failUnlessEqual(element.attrib["in_point"], ts(5 * gst.SECOND))
self.failUnlessEqual(element.attrib["media_duration"],
ts(15 * gst.SECOND))
self.failUnlessEqual(element.attrib["priority"], "(int)10")
self.failIfEqual(element.find("factory-ref"), None)
self.failIfEqual(element.find("stream-ref"), None)
# find the interpolation keyframes
curves = element.find("curves")
self.failIfEqual(curves, None)
curve = curves.find("curve")
self.failIfEqual(curve, None)
self.failUnlessEqual(curve.attrib["property"], "volume")
# compute a dictionary of keyframes
saved_points = dict(
((obj.attrib["time"], (obj.attrib["value"], obj.attrib["mode"]))
for obj in curve.getiterator("keyframe")))
# compare this with the expected values
expected = dict(((str(t * gst.SECOND), ("(gdouble)%s" % (t % 2), "2"))
for t in xrange(3, 15, 3)))
self.failUnlessEqual(expected, saved_points)
