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 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)