def test_asset_metadata_on_reload(self): mainloop = GLib.MainLoop() unused, xges_path = tempfile.mkstemp(suffix=".xges") project_uri = Gst.filename_to_uri(os.path.abspath(xges_path)) asset_uri = Gst.filename_to_uri( os.path.join(__file__, "../../assets/audio_video.ogg")) xges = """<ges version='0.3'> <project properties='properties;' metadatas='metadatas;'> <ressources> <asset id='%(uri)s' extractable-type-name='GESUriClip' properties='properties, supported-formats=(int)6, duration=(guint64)2003000000;' metadatas='metadatas, container-format=(string)Matroska, language-code=(string)und, application-name=(string)Lavc56.60.100, encoder-version=(uint)0, audio-codec=(string)Vorbis, nominal-bitrate=(uint)80000, bitrate=(uint)80000, video-codec=(string)"On2\ VP8", file-size=(guint64)223340, foo=(string)bar;' > </asset> </ressources> </project> </ges>""" % { "uri": asset_uri } with open(xges_path, "w") as xges_file: xges_file.write(xges) def loaded_cb(project, timeline): asset = project.list_assets(GES.Extractable)[0] self.assertEqual(asset.get_meta("foo"), "bar") mainloop.quit() loaded_project = GES.Project(uri=project_uri, extractable_type=GES.Timeline) loaded_project.connect("loaded", loaded_cb) timeline = loaded_project.extract() mainloop.run()
def render(self, dialog): """Renders pipeline from @dialog.""" from pitivi.render import RenderingProgressDialog with tempfile.TemporaryDirectory() as temp_dir: # Start rendering with mock.patch.object(dialog.filebutton, "get_uri", return_value=Gst.filename_to_uri(temp_dir)): with mock.patch.object(dialog.fileentry, "get_text", return_value="outfile"): with mock.patch.object(RenderingProgressDialog, "__new__"): dialog._renderButtonClickedCb(None) message = dialog._pipeline.get_bus().timed_pop_filtered( Gst.CLOCK_TIME_NONE, Gst.MessageType.EOS | Gst.MessageType.ERROR) self.assertIsNotNone(message) Gst.debug_bin_to_dot_file_with_ts( dialog._pipeline, Gst.DebugGraphDetails.ALL, "test_rendering_with_profile.dot") result_file = Gst.filename_to_uri(os.path.join( temp_dir, "outfile")) struct = message.get_structure() self.assertEqual(message.type, Gst.MessageType.EOS, struct.to_string() if struct else message) asset = GES.UriClipAsset.request_sync(result_file) self.assertIsNotNone(asset) if message: dialog._pipeline.get_bus().post(message)
def render(self, dialog): """Renders pipeline from @dialog.""" from pitivi.render import RenderingProgressDialog with tempfile.TemporaryDirectory() as temp_dir: # Start rendering with mock.patch.object(dialog.filebutton, "get_uri", return_value=Gst.filename_to_uri(temp_dir)): with mock.patch.object(dialog.fileentry, "get_text", return_value="outfile"): with mock.patch.object(RenderingProgressDialog, "__new__"): dialog._renderButtonClickedCb(None) message = dialog._pipeline.get_bus().timed_pop_filtered( 10 * Gst.SECOND, Gst.MessageType.EOS | Gst.MessageType.ERROR) Gst.debug_bin_to_dot_file_with_ts( dialog._pipeline, Gst.DebugGraphDetails.ALL, "test_rendering_with_profile.dot") result_file = Gst.filename_to_uri(os.path.join(temp_dir, "outfile")) struct = message.get_structure() if message else None self.assertEqual(message.type, Gst.MessageType.EOS, struct.to_string() if struct else message) asset = GES.UriClipAsset.request_sync(result_file) # FIXME Check more things? self.assertIsNotNone(asset)
def test_request_relocated_assets_sync(self): path = os.path.join(__file__, "../../../", "png.png") with self.assertRaises(GLib.Error): GES.UriClipAsset.request_sync(Gst.filename_to_uri(path)) GES.add_missing_uri_relocation_uri( Gst.filename_to_uri(os.path.join(__file__, "../../assets")), False) path = os.path.join(__file__, "../../", "png.png") self.assertEqual( GES.UriClipAsset.request_sync(Gst.filename_to_uri(path)).props.id, Gst.filename_to_uri(os.path.join(__file__, "../../assets/png.png")))
def testSaveProjectWithRemovedProxy(self): sample_name = "30fps_numeroted_frames_red.mkv" with common.cloned_sample(sample_name): self.check_import([sample_name]) project = self.app.project_manager.current_project asset = GES.UriClipAsset.request_sync(common.get_sample_uri(sample_name)) target = asset.get_proxy_target() self.assertEqual(set(project.list_assets(GES.Extractable)), set([target, asset])) # Remove the asset self.medialibrary.remove_assets_action.emit("activate", None) # Make sure that the project has not assets anymore self.assertEqual(project.list_assets(GES.Extractable), []) # Save the project and reload it, making sure there is no asset # in that new project project_uri = Gst.filename_to_uri(tempfile.NamedTemporaryFile().name) project.save(project.ges_timeline, project_uri, None, True) self._customSetUp(project_uri) self.assertNotEqual(project, self.app.project_manager.current_project) project = self.app.project_manager.current_project self.assertEqual(project.list_assets(GES.Extractable), [])
def add_music_file(self, filepath): contents = open(filepath, "r") disc = GstPbutils.Discoverer.new(50000000000) file_uri = Gst.filename_to_uri(filepath) info = disc.discover_uri(file_uri) tags = info.get_tags() artist = album = title = "Unknown" track_num = 0 tagged, tag = tags.get_string('artist') if tagged: artist = unicode(tag, "UTF-8") tagged, tag = tags.get_string('album') if tagged: album = unicode(tag, "UTF-8") tagged, tag = tags.get_string('title') if tagged: title = unicode(tag, "UTF-8") tagged, tag = tags.get_uint('track-number') if tagged: track_num = tag headers = [] headers.append(["X-Object-Meta-Artist", artist]) headers.append(["X-Object-Meta-Album", album]) headers.append(["X-Object-Meta-Title", title]) headers.append(["X-Object-Meta-Track-Num", str(track_num)]) obj_name = "%s/%s" % (album, title) if not self.container_exists(artist): self.conn.put_container(artist) self.conn.put_object(artist, obj_name, contents, headers=headers) contents.close() return artist, album, title, track_num
def run(self): self.playbin = Gst.ElementFactory.make("playbin", None) if self.playbin: if Gst.uri_is_valid(self.uri): uri = self.uri else: uri = Gst.filename_to_uri(self.uri) self.playbin.set_property('uri', uri) self.playbin.set_property('volume', self.volume_level) bus = self.playbin.get_bus() bus.add_signal_watch() bus.connect("message", self.bus_call, self.loop) bus.connect("message::tag", self.on_tag) self.playbin.set_state(Gst.State.PLAYING) self.loop = GLib.MainLoop() try: self.stats.update(dict(status='playing')) self.notify() self.loop.run() except OSError as e: pass finally: self.loop.quit() self.playbin.set_state(Gst.State.NULL) self.stats.update(dict(status='stopped')) self.notify()
def start(self): Media.start(self) if not Gst.uri_is_valid(self.uri): self.uri = Gst.filename_to_uri(self.uri) source = Gst.ElementFactory.make("uridecodebin", None) source.set_property("uri", self.uri) queue = Gst.ElementFactory.make("queue2", None) queue.set_property("max-size-buffers", 5) convert = Gst.ElementFactory.make("videoconvert", None) sink = Gst.ElementFactory.make("appsink", None) sink.set_property("emit-signals", True) sink.set_property("max-buffers", 1) caps = Gst.caps_from_string("video/x-raw, format=(string){RGBA}") sink.set_property("caps", caps) self.pipeline.add(source) self.pipeline.add(queue) self.pipeline.add(convert) self.pipeline.add(sink) source.connect("pad-added", self.on_pad_added, queue) queue.link(convert) convert.link(sink) sink.connect("new-sample", self.on_frame_cpu) # Creates a bus and set callbacks to receive errors bus = self.pipeline.get_bus() bus.add_signal_watch() bus.connect("message::eos", self.on_eos) bus.connect("message::error", self.on_error) self.pipeline.set_state(Gst.State.PLAYING)
def __init__(self, uri, archivo, tipo): GObject.GObject.__init__(self) self.tipo = tipo if not archivo.endswith(".ogg"): archivo = "%s%s" % (archivo, ".ogg") #archivo = "%s%s" % (archivo, ".mp3") self.patharchivo = archivo self.actualizador = False self.control = 0 self.tamanio = 0 self.uri = "" self.pipeline = None self.player = None self.archivo = None self.bus = None self.__reset() if os.path.exists(uri): # FIXME: Analizar uri = Gst.filename_to_uri(uri) if Gst.uri_is_valid(uri): self.archivo.set_property("location", self.patharchivo) self.player.set_property("uri", uri) self.__play() self.__new_handle(True) else: self.emit("endfile")
def onSelectionActivated(self, listbox, row): selected_song = getattr(row, "path") name = getattr(row, "name") selected_song = Gst.filename_to_uri(selected_song) self.player.setUri(selected_song) self.headerBar.set_title(name) self.onPlay()
def test_serialize_invert(self): timeline = GES.Timeline.new() timeline.add_track(GES.VideoTrack.new()) layer = timeline.append_layer() clip1 = GES.TransitionClip.new_for_nick("crossfade") clip1.props.duration = Gst.SECOND self.assertTrue(layer.add_clip(clip1)) vtransition, = clip1.children vtransition.set_inverted(True) self.assertEqual(vtransition.props.invert, True) with tempfile.NamedTemporaryFile() as tmpxges: uri = Gst.filename_to_uri(tmpxges.name) timeline.save_to_uri(uri, None, True) timeline = GES.Timeline.new_from_uri(uri) project = timeline.get_asset() mainloop = common.create_main_loop() project.connect("loaded", lambda _, __: mainloop.quit()) mainloop.run() self.assertIsNotNone(timeline) layer, = timeline.get_layers() clip, = layer.get_clips() vtransition, = clip.children self.assertEqual(vtransition.props.invert, True)
def test_load_project_clip_speed(self): sources_count = 2 clip, = self.layer.get_clips() clip.props.duration = Gst.SECOND self.timeline_container.timeline.selection.select([clip]) self.speed_box._speed_adjustment.props.value = 0.5 self.assert_applied_rate(sources_count, 0.5, 2 * Gst.SECOND) with tempfile.NamedTemporaryFile() as temp_file: uri = Gst.filename_to_uri(temp_file.name) project_manager = self.app.project_manager self.assertTrue(project_manager.save_project(uri=uri, backup=False)) mainloop = common.create_main_loop() project_manager.connect("new-project-loaded", lambda *args: mainloop.quit()) project_manager.connect("closing-project", lambda *args: True) self.assertTrue(project_manager.close_running_project()) project_manager.load_project(uri) mainloop.run() new_clip, = self.layer.get_clips() self.assertNotEqual(new_clip, clip) self.timeline_container.timeline.selection.select([new_clip]) self.assert_applied_rate(sources_count, 0.5, 2 * Gst.SECOND)
def process_next(bus, message): print ('got EOS') if 'datetime' in latest_tag: del latest_tag['datetime'] tags.append(latest_tag) global latest_tags latest_tags = {} try: fname = fnames.pop(0) except IndexError: print ('No more files to process, exit') with open('metadata.pickle', 'wb') as f: pickle.dump(tags, f) loop.quit() return False print ('fname:', fname) uri = Gst.filename_to_uri(fname) latest_tag['uri'] = uri pipe.set_state(Gst.State.NULL) pipe.get_by_name('decoder').set_property('uri', uri) pipe.set_state(Gst.State.PLAYING)
def created_project_file(asset_uri): """Creates a project file. Yields: str: The URI of the new project """ unused_fd, xges_path = tempfile.mkstemp() with open(xges_path, "w") as xges: xges.write(""" <ges version='0.1'> <project> <ressources> <asset id='%(asset_uri)s' extractable-type-name='GESUriClip' /> </ressources> <timeline> <track caps='video/x-raw' track-type='4' track-id='0' /> <layer priority='0'> <clip id='0' asset-id='%(asset_uri)s' type-name='GESUriClip' layer-priority='0' track-types='4' start='0' duration='2590000000' inpoint='0' rate='0' /> </layer> </timeline> </project> </ges>""" % {'asset_uri': asset_uri}) yield Gst.filename_to_uri(xges_path) os.remove(xges_path)
def createTempProject(self): """ Created a temporary project Always generate projects with missing assets for now Returns: str: The path of the new project str: The URI of the new project """ unused_fd, xges_path = tempfile.mkstemp() with open(xges_path, "w") as xges: xges.write(""" <ges version='0.1'> <project> <ressources> <asset id='file:///icantpossiblyexist.png' extractable-type-name='GESUriClip' /> </ressources> <timeline> <track caps='video/x-raw' track-type='4' track-id='0' /> <layer priority='0'> <clip id='0' asset-id='file:///icantpossiblyexist.png' type-name='GESUriClip' layer-priority='0' track-types='4' start='0' duration='2590000000' inpoint='0' rate='0' /> </layer> </timeline> </project> </ges>""") return xges_path, Gst.filename_to_uri(xges_path)
def load(self, path): self.pause() uri = path if Gst.uri_is_valid(path) else Gst.filename_to_uri(path) self.pipeline.set_state(Gst.State.READY) self.playbin.set_property('uri', uri) self.play() self.pause()
def check_reload_timeline(self): tmpf = tempfile.NamedTemporaryFile(suffix='.xges') uri = Gst.filename_to_uri(tmpf.name) self.assertTrue(self.timeline.save_to_uri(uri, None, True)) project = GES.Project.new(uri) mainloop = create_main_loop() def loaded_cb(unused_project, unused_timeline): mainloop.quit() project.connect("loaded", loaded_cb) reloaded_timeline = project.extract() mainloop.run() self.assertIsNotNone(reloaded_timeline) layers = self.timeline.get_layers() reloaded_layers = reloaded_timeline.get_layers() self.assertEqual(len(layers), len(reloaded_layers)) for layer, reloaded_layer in zip(layers, reloaded_layers): clips = layer.get_clips() reloaded_clips = reloaded_layer.get_clips() self.assertEqual(len(clips), len(reloaded_clips)) for clip, reloaded_clip in zip(clips, reloaded_clips): self.assertElementAreEqual(clip, reloaded_clip) return reloaded_timeline
def transcode(input_file, output_file, profile=None): Gst.init() if not Gst.uri_is_valid (input_file): input_file = Gst.filename_to_uri (input_file) ensure_directory(os.path.dirname(output_file)) if profile is None: profile=create_encoding_profile() loop = GObject.MainLoop() pipeline = Gst.Pipeline() uridecodebin = Gst.ElementFactory.make('uridecodebin') encodebin = Gst.ElementFactory.make('encodebin') sink = Gst.ElementFactory.make('filesink') pipeline.add(uridecodebin) pipeline.add(encodebin) pipeline.add(sink) encodebin.link(sink) uridecodebin.set_property('uri', input_file) sink.set_property('location', output_file) encodebin.set_property('profile', profile) uridecodebin.connect('pad-added', on_pad_added, (pipeline, encodebin)) bus = pipeline.get_bus() bus.add_watch(0, on_message, (pipeline, loop)) pipeline.set_state(Gst.State.PLAYING) loop.run()
def created_project_file(asset_uri="file:///icantpossiblyexist.png"): """ Create a project file. Yields: str: The URI of the new project """ unused_fd, xges_path = tempfile.mkstemp() with open(xges_path, "w") as xges: xges.write(""" <ges version='0.1'> <project> <ressources> <asset id='%(asset_uri)s' extractable-type-name='GESUriClip' /> </ressources> <timeline> <track caps='video/x-raw' track-type='4' track-id='0' /> <layer priority='0'> <clip id='0' asset-id='%(asset_uri)s' type-name='GESUriClip' layer-priority='0' track-types='4' start='0' duration='2590000000' inpoint='0' rate='0' /> </layer> </timeline> </project> </ges>""" % {'asset_uri': asset_uri}) yield Gst.filename_to_uri(xges_path) os.remove(xges_path)
def test_scaled_proxy_size(self): app = common.create_pitivi_mock(default_scaled_proxy_width=123, default_scaled_proxy_height=456) manager = ProjectManager(app) project = manager.new_blank_project() self.assertFalse(project.has_scaled_proxy_size()) self.assertEqual(project.scaled_proxy_width, 123) self.assertEqual(project.scaled_proxy_height, 456) with tempfile.NamedTemporaryFile() as temp_file: uri = Gst.filename_to_uri(temp_file.name) manager.save_project(uri=uri, backup=False) app2 = common.create_pitivi_mock(default_scaled_proxy_width=12, default_scaled_proxy_height=45) project2 = ProjectManager(app2).load_project(uri) self.assertFalse(project2.has_scaled_proxy_size()) self.assertEqual(project2.scaled_proxy_width, 12) self.assertEqual(project2.scaled_proxy_height, 45) project.scaled_proxy_width = 123 project.scaled_proxy_height = 456 self.assertTrue(project.has_scaled_proxy_size()) self.assertEqual(project.scaled_proxy_width, 123) self.assertEqual(project.scaled_proxy_height, 456) with tempfile.NamedTemporaryFile() as temp_file: manager.save_project(uri=uri, backup=False) app2 = common.create_pitivi_mock(default_scaled_proxy_width=1, default_scaled_proxy_height=4) project2 = ProjectManager(app2).load_project(uri) self.assertTrue(project2.has_scaled_proxy_size()) self.assertEqual(project2.scaled_proxy_width, 123) self.assertEqual(project2.scaled_proxy_height, 456)
def test_save_project_with_removed_proxy(self): sample_name = "30fps_numeroted_frames_red.mkv" with common.cloned_sample(sample_name): self.check_import([sample_name]) project = self.app.project_manager.current_project asset = GES.UriClipAsset.request_sync( common.get_sample_uri(sample_name)) target = asset.get_proxy_target() self.assertEqual(set(project.list_assets(GES.Extractable)), set([target, asset])) # Remove the asset self.medialibrary.remove_assets_action.emit("activate", None) # Make sure that the project has not assets anymore self.assertEqual(project.list_assets(GES.Extractable), []) # Save the project and reload it, making sure there is no asset # in that new project project_uri = Gst.filename_to_uri( tempfile.NamedTemporaryFile().name) project.save(project.ges_timeline, project_uri, None, True) self._custom_set_up(project_uri) self.assertNotEqual(project, self.app.project_manager.current_project) project = self.app.project_manager.current_project self.assertEqual(project.list_assets(GES.Extractable), [])
def __init__(self, args): super().__init__() self.ignore_tracker = False self.file_index = 0 app = QApplication(sys.argv) self.create_window(args) self.player = Player(args) self.player.state_changed.connect(self.update_state) self.player.duration_changed.connect(self.update_tracker_duration) self.player.position_updated.connect(self.update_tracker_position) self.tracker.valueChanged.connect(self.tracker_value_changed) #self.play_button.clicked.connect(functools.partial(self.button_clicked, "play")) self.play_button.clicked.connect(self.play) self.pause_button.clicked.connect(self.pause) self.stop_button.clicked.connect(self.stop) self.seek_backward_button.clicked.connect(self.player.step_backward) self.seek_forward_button.clicked.connect(self.player.step_forward) self.media_next_button.clicked.connect(self.next_media) self.media_previous_button.clicked.connect(self.previous_media) self.window.show() self.video_widget.set_overlay(self.player.playbin) self.update_state(PlayerState.STOPPED) self.files = [x.replace("\n", " ") for x in args.files] files = [] for index, file in enumerate(self.files): print((index, file)) if os.path.isdir(file): pattern = "*.wmv" files.extend( glob.iglob(file + "/**/" + pattern, recursive=True)) elif os.path.isfile(file): files.append(file) self.files = files if self.file_index >= 0 and self.file_index < len(self.files): uri = Gst.filename_to_uri(self.files[self.file_index]) self.player.set_uri(uri) #self.player.set_property("prop_gint", 12) self.state = None self.player.pause() ret = app.exec_() self.player.dispose() self.player = None
def test_marker_load_project(self): """Checks marker addition.""" # TODO: When there is nothing connected to closing-project, # the default reply is "False", which means "abort saving". It should mean # "OK" to get rid off the handler. The meaning of the default (False) # must be changed def closing(unused_manager, unused_project): return True def loaded_cb(project, timeline): mainloop.quit() markers = self.timeline.get_marker_list("markers") markers.add(10) markers.add(20) self.assert_markers(markers, [(10, None), (20, None)]) project_uri = Gst.filename_to_uri(tempfile.NamedTemporaryFile().name) self.app.project_manager.save_project(project_uri) self.app.project_manager.connect("closing-project", closing) self.app.project_manager.close_running_project() project = self.app.project_manager.new_blank_project() markers = project.ges_timeline.get_marker_list("markers") self.assert_markers(markers, []) self.app.project_manager.close_running_project() project = self.app.project_manager.load_project(project_uri) project.connect("loaded", loaded_cb) mainloop = common.create_main_loop() mainloop.run() self.action_log = self.app.action_log markers = project.ges_timeline.get_marker_list("markers") self.assert_markers(markers, [(10, None), (20, None)]) ges_markers = markers.get_markers() marker1, marker2 = ges_markers with self.action_log.started("new comment"): marker1.set_string("comment", "comment 1") self.assert_markers(markers, [(10, "comment 1"), (20, None)]) with self.action_log.started("new comment"): marker2.set_string("comment", "comment 2") self.assert_markers(markers, [(10, "comment 1"), (20, "comment 2")]) for _ in range(4): self.action_log.undo() self.assert_markers(markers, [(10, "comment 1"), (20, None)]) self.action_log.undo() self.assert_markers(markers, [(10, None), (20, None)]) self.action_log.redo() self.assert_markers(markers, [(10, "comment 1"), (20, None)]) self.action_log.redo() self.assert_markers(markers, [(10, "comment 1"), (20, "comment 2")])
def play(self, pos=0): fname = self.playlist.jump(pos) uri = Gst.filename_to_uri(fname) playbin = Gst.ElementFactory.make('playbin', 'playbin') #bus = playbin.get_bus() #bus.add_signal_watch() playbin.set_property('uri', uri) playbin.set_state(Gst.State.PLAYING)
def created_project_file(xges): _, xges_path = tempfile.mkstemp(suffix=".xges") with open(xges_path, "w") as f: f.write(xges) yield Gst.filename_to_uri(os.path.abspath(xges_path)) os.remove(xges_path)
def _scan_dir(self, folder): """Scans the folder recursively and yields the URIs of the files.""" self.log("Scanning folder %s", folder) for path, dirs, files in os.walk(folder): if self.stopme.is_set(): return for afile in files: yield Gst.filename_to_uri(os.path.join(path, afile))
def create_project_file_from_xges(self, xges): unused, xges_path = tempfile.mkstemp(suffix=".xges") proj_uri = Gst.filename_to_uri(os.path.abspath(xges_path)) with open(xges_path, "w") as xges_file: xges_file.write(xges) return proj_uri
def _scan_dir(self, folder): """Scans the folder recursively and yields the URIs of the files.""" self.log("Scanning folder %s", folder) for path, unused_dirs, files in os.walk(folder): if self.stopme.is_set(): return for afile in files: yield Gst.filename_to_uri(os.path.join(path, afile))
def create_project_file_from_xges(self, app, xges): unused, xges_path = tempfile.mkstemp(suffix=".xges") proj_uri = Gst.filename_to_uri(os.path.abspath(xges_path)) app.project_manager.saveProject(uri=proj_uri) with open(xges_path, "w") as f: f.write(xges) return proj_uri
def test_scanning_dir(self): """Checks the scanning of the directory URIs.""" assets_dir = os.path.dirname(os.path.abspath(__file__)) valid_dir_uri = Gst.filename_to_uri(os.path.join(assets_dir, "samples")) uris = [valid_dir_uri] received_uris = self._scan(uris) self.assertGreater(len(received_uris), 1, received_uris) valid_uri = common.get_sample_uri("tears_of_steel.webm") self.assertIn(valid_uri, received_uris)
def test_request_relocated_twice(self): GES.add_missing_uri_relocation_uri( Gst.filename_to_uri(os.path.join(__file__, "../../")), True) proj = GES.Project.new() asset = proj.create_asset_sync("file:///png.png", GES.UriClip) self.assertIsNotNone(asset) asset = proj.create_asset_sync("file:///png.png", GES.UriClip) self.assertIsNotNone(asset)
def __load(self, uri): if os.path.exists(uri): direccion = Gst.filename_to_uri(uri) self.player.set_property("uri", direccion) else: if Gst.uri_is_valid(uri): self.player.set_property("uri", uri)
def start(self): assert len(self.queue) > 0 fname = self.queue.pop(0) self.files.append(fname) self.metadata.append({'fname': {fname}}) uri = Gst.filename_to_uri(fname) self.pipe.set_state(Gst.State.NULL) self.pipe.get_by_name('decoder').set_property('uri', uri) self.pipe.set_state(Gst.State.PLAYING)
def created_video_asset(uri=None, num_bufs=30): with tempfile.NamedTemporaryFile(suffix=".ogg") as f: if not uri: uri = Gst.filename_to_uri(f.name) transcoder = GstTranscoder.Transcoder.new( "testbin://video,num-buffers=%s" % num_bufs, uri, "application/ogg:video/x-theora:audio/x-vorbis") transcoder.run() yield uri
def __init__(self, parent=0, path=None, rect=sf.Rectangle()): self._texture = sf.Texture.create(1,1) self._sprite = sf.Sprite(self._texture) self.path = path #The player self.player = Gst.ElementFactory.make("playbin", "player") #Config the video output binVideo = Gst.Bin() videoScale = Gst.ElementFactory.make("videoscale", "videoScale") videoScale.set_property("method", 0) self.videoFilter = Gst.ElementFactory.make("capsfilter", "videoFiltered") videoConvert = Gst.ElementFactory.make("videoconvert", "videoConvert") self.videoSink=Gst.ElementFactory.make("appsink", "videoSink") self.videoSink.set_property("max_buffers", 8) self.videoSink.set_property("drop", True) self.videoSink.set_property("sync", True) self.videoSink.set_property("async", False) self.videoSink.set_property("emit-signals", True) self.videoSink.connect("new-preroll", self.initTexture) videoCaps = Gst.Caps("video/x-raw, format=(string)RGBx") self.videoFilter.set_property("caps", videoCaps) self.videoCaps = Gst.Caps(videoCaps.to_string()) #Add and link the elements to the bin video binVideo.add(videoScale) binVideo.add(self.videoFilter) binVideo.add(videoConvert) binVideo.add(self.videoSink) videoScale.link(self.videoFilter) self.videoFilter.link(videoConvert) videoConvert.link(self.videoSink) pad = videoScale.get_static_pad("sink") ghostPad = Gst.GhostPad.new("sink", pad) binVideo.add_pad(ghostPad) self.player.set_property("video-sink", binVideo) if path: self.player.set_property("uri", Gst.filename_to_uri(path)) self.player.set_state(Gst.State.PLAYING) Widget.__init__(self, parent, rect) self.pos = rect.position self.size = rect.size self._speed = 1 self.requestTime = 10**9*60 self._canSetSpeed = False self.bus = self.player.get_bus() self.streamStart = False
def quote_uri(uri): """ Encode a URI/path according to RFC 2396, without touching the file:/// part. """ # Split off the "file:///" part, if present. parts = urlsplit(uri, allow_fragments=False) # Make absolutely sure the string is unquoted before quoting again! raw_path = unquote(parts.path) # For computing thumbnail md5 hashes in the media library, we must adhere to # RFC 2396. It is quite tricky to handle all corner cases, leave it to Gst: return Gst.filename_to_uri(raw_path)
def _play_next(self): for filepath in self.playlist: if not os.path.isfile(filepath): print("is not a file:", filepath) continue filepath = os.path.realpath(filepath) self.player.set_property("uri", Gst.filename_to_uri(filepath)) self.player.set_state(Gst.State.PLAYING) print("now playing:", filepath) return True return False
def __load(self, uri): if os.path.exists(uri): # Archivo direccion = Gst.filename_to_uri(uri) self.player.set_property("uri", direccion) self.__play() else: # Streaming if Gst.uri_is_valid(uri): self.player.set_property("uri", uri) self.__play()
def __init__(self): Gst.Pipeline.__init__(self) self.music_file = os.path.join("resources", "usmtheme.wav") self.music_uri = Gst.filename_to_uri(self.music_file) self.playbin = Gst.ElementFactory.make("playbin") self.playbin.set_property("uri", self.music_uri) self.playbin.set_state(Gst.State.NULL) self.playbin.connect("about-to-finish", self.on_about_to_finish) self.add(self.playbin)
def add_file(self, filepath): '''Method that adds the file to the GtkStore and GESTimeline''' idf = len(self.clips) # id field is a counter uri = Gst.filename_to_uri (filepath) # conver the filepath into a valid URI duration, tlobj = self.engine.add_file(uri) # add the uri to the GESTimeline # add to the GtkStore and internal list self.timeline_store.append([idf, os.path.basename(filepath), 0, duration, 0]) # clips[id] = uri, start, duration, in_point, max_duration, timelineobj self.clips[idf] = [uri, 0, duration, 0, duration, tlobj]
def play_next(self): try: fname = self.queue.pop(0) except: self.finished.emit() return uri = Gst.filename_to_uri(fname) if not hasattr(self, 'pipe'): self.make_pipe() self.pipe.set_state(Gst.State.NULL) self.pipe.set_property('uri', uri) self.pipe.set_state(Gst.State.PLAYING)
def process_next(self): try: fname = self.queue.pop(0) self.files.append(fname) self.metadata.append({'fname': fname}) except IndexError: self.pipe.set_state(Gst.State.NULL) print('No more files on queue') self.finished.emit() return print('fname:', fname) uri = Gst.filename_to_uri(fname) self.pipe.set_state(Gst.State.NULL) self.pipe.get_by_name('decoder').set_property('uri', uri) self.pipe.set_state(Gst.State.PLAYING)
def load(self, uri): """ Carga un archivo o stream en el pipe de Gst. """ self.stop() self.__reset() if os.path.exists(uri): direccion = Gst.filename_to_uri(uri) self.player.set_property("uri", direccion) self.__play() else: # FIXME: Funciona con la radio pero no con la Tv if Gst.uri_is_valid(uri): self.player.set_property("uri", uri) self.__play()
def get_video_info(self): """Return information about the current video. """ uri = self.get_uri() if not Gst.uri_is_valid(uri): # Let's try to interpret it as a filename uri = Gst.filename_to_uri(uri) d = GstPbutils.Discoverer() try: info = d.discover_uri(uri) except Exception as e: logger.error("Cannot find video info: %s", e.message) info = None default = { 'uri': uri, 'framerate_denom': 1, 'framerate_num': config.data.preferences['default-fps'], 'width': 640, 'height': 480, 'duration': 0, } if info is None: # Return default data. logger.warn("Could not find information about video, using absurd defaults.") return default if not info.get_video_streams(): # Could be an audio file. default['duration'] = info.get_duration() / Gst.MSECOND return default stream = info.get_video_streams()[0] return { 'uri': uri, 'framerate_denom': stream.get_framerate_denom(), 'framerate_num': stream.get_framerate_num(), 'width': stream.get_width(), 'height': stream.get_height(), 'duration': info.get_duration() / Gst.MSECOND, }
def _populate_library(self, uri, artist, album, title, track): """ for track in LIBRARY: if artist not already there: add it if album not already there: add it as a child of the artist add the track title and URI """ # Avoid adding tracks when searching, # unless they would be a search result anyway search_text = \ self.builder.get_object("search_entry").get_text().lower() if not search_text == "": if search_text not in artist.lower() and \ search_text not in album.lower() and \ search_text not in title.lower(): return # A list of tracks (and URIs) in a dic of albums in a dic of artists: if not Gst.uri_is_valid(uri): uri = Gst.filename_to_uri(uri) if artist not in self.library: self.library[artist] = {} artist_iter = self.library_store.append(None, [artist]) if album not in self.library[artist]: self.library[artist][album] = [] self.library_store.append(artist_iter, [album]) else: if album not in self.library[artist]: column = 0 artist_iter = self.library_store.get_iter_first() while (artist != \ self.library_store.get_value (artist_iter, column)) and \ (artist != None): artist_iter = self.library_store.iter_next (artist_iter) self.library[artist][album] = [] self.library_store.append(artist_iter, [album]) self.library[artist][album].append([title, uri, track])
def _playRenderedFileButtonClickedCb(self, unused_button): uri = Gst.filename_to_uri(self.main_render_dialog.outfile) Gio.AppInfo.launch_default_for_uri(uri, None)
def get_sample_uri(sample): tests_dir = os.path.dirname(os.path.abspath(__file__)) return Gst.filename_to_uri(os.path.join(tests_dir, "samples", sample))
loggy.log('Tagger got ' + str(self.tags)) #self.player.set_state(Gst.State.NULL) #TODO: replace mime types with Gstreamer alternative from Gst.extend self.callback() elif (message.type == Gst.MessageType.DURATION_CHANGED): #Gst.MESSAGE_DURATION: ?does this ever happen self.tags['duration'] = int ((int(self.playbin.query_duration(Gst.Format.TIME)[1]) / Gst.SECOND)) loggy.warn('got duration huzzah!') #TODO not working at present elif (message.type == Gst.MessageType.ERROR): #Gst.MESSAGE_ERROR: err, debug = message.parse_error() loggy.warn( "Player GST_MESSAGE_ERROR: " + str(err) + str(debug)) #TODO: sort out unicode self.error = str(debug) if self.error: self.player.set_state(Gst.State.NULL) self.__init__() self.callback() else: loggy.warn( "Player GST message unhandled:" + str(message.type)) if __name__ == "__main__": # Setting GST_DEBUG_DUMP_DOT_DIR environment variable enables us to have a dotfile generated import os os.environ["GST_DEBUG_DUMP_DOT_DIR"] = "tmp" os.putenv('GST_DEBUG_DUMP_DIR_DIR', 'tmp') tagger1 = tagger() tagger1.load_uri(Gst.filename_to_uri('/home/sam/Music/Darwin Deez/Songs for Imaginative People/04. No Love.mp3'), tagger1.test) global testmainloop testmainloop = GObject.MainLoop() testmainloop.run()
def discover_metadata(self, location): file_uri = Gst.filename_to_uri(location) info = self.disc.discover_uri_async(file_uri)
decoder.connect('pad-removed', lambda d, p: print('pad removed!')) return pipe Gst.init() fnames = argv[1:] pipe = make_pipe() pipe.set_state(Gst.State.NULL) tags = [] latest_tag = {} bus = pipe.get_bus() bus.connect('message::tag', add_tag) bus.connect('message::eos', process_next) bus.connect('message::error', raise_error) fname = fnames.pop(0) uri = Gst.filename_to_uri(fname) latest_tag['uri'] = uri pipe.get_by_name('decoder').set_property('uri', uri) pipe.set_state(Gst.State.PLAYING) loop = GLib.MainLoop() loop.run()
def display_position(self, scale, value): secs = int(value) min = secs // 60 secs %= 60 return '{0}:{1}'.format(min, secs) if __name__ == '__main__': from sys import argv Gtk.init(argv) Gst.init(argv) w = Gtk.Window() pb = Gst.ElementFactory.make('playbin', 'playbin') w.add(PositionWidget(pb)) w.connect('destroy', lambda w: Gtk.main_quit()) pb.set_state(Gst.State.NULL) pb.set_property('uri', Gst.filename_to_uri(argv[1])) pb.set_state(Gst.State.PLAYING) w.show_all() w.resize(400, 400) Gtk.main()
def set_uri(self, uri): self.player.set_state(Gst.State.READY) uri = Gst.filename_to_uri(uri) logging.debug('URI: %s', uri) self.player.set_property('uri', uri)