def initialize_modules():
"""
Initialize the modules.
This has to be done in a specific order otherwise the app
crashes on some systems.
"""
from gi.repository import Gdk
Gdk.init([])
from gi.repository import GtkClutter
GtkClutter.init([])
from gi.repository import ClutterGst
ClutterGst.init([])
import gi
if not gi.version_info >= (3, 11):
from gi.repository import GObject
GObject.threads_init()
from gi.repository import Gst
Gst.init(None)
from gi.repository import GES
GES.init()
# This is required because of:
# https://bugzilla.gnome.org/show_bug.cgi?id=656314
from gi.repository import GdkX11
GdkX11 # noop
def __init__(self, sounds_list):
from gi.repository import GObject, ClutterGst, Clutter
ClutterGst.init()
self.sounds = {}
CHANNELS_PER_FILE = 1
DEFAULT_CONFIG = {
'file_name': '',
'volume': 1.0,
'loop_count': 1
}
for sound_name, value in sounds_list.items():
config = DEFAULT_CONFIG.copy()
if isinstance(value, dict):
config.update(value)
else:
config['file_name'] = value
volume = float(config['volume'])
#volumes[sound_name] = volume
vec = []
for i in range(CHANNELS_PER_FILE):
s = ClutterGst.VideoTexture()
s.set_filename(config['file_name'])
s.set_buffering_mode(ClutterGst.BufferingMode.DOWNLOAD) # DOWNLOAD
vec.append(s)
self.sounds[sound_name] = tuple(vec)
def __init__(self, config):
BLACK = Clutter.Color.new(0x00, 0x00, 0x00, 0x00)
WHITE = Clutter.Color.new(0xff, 0xff, 0xff, 0xff)
TITLE = "Europlayer"
FONT = "Sans Bold 14"
HELP_TEXT = "Letters: choose clip.\n"
HELP_TEXT += "F1: Help."
HELP_TEXT += "Escape: Toggle fullscreen."
HELP_TEXT += "Space: Fade to black."
HELP_TEXT += "Ctrl-Q: Quit."
#TODO: HELP_TEXT += "There is not config file for now."
self._config = config
self._is_fullscreen = False
self._current_clip_number = self._config.initial_clip_number
ClutterGst.init(sys.argv)
self._stage = Clutter.Stage.get_default()
self._stage.set_title(TITLE)
self._stage.set_color(BLACK)
self._stage.set_size(self._config.window_width,
self._config.window_height)
self._stage.set_minimum_size(640, 480)
if self._config.start_fullscreen:
self._stage.set_fullscreen(True)
self._is_fullscreen = True
if not self._config.show_cursor:
self._stage.hide_cursor()
#self._stage.connect("event", self._stage_event_cb)
self._stage.connect("key-press-event", self._stage_key_press_event_cb)
# Create the video texture
self._video_texture = ClutterGst.VideoTexture()
self._stage.connect("allocation-changed",
self._stage_allocation_changed_cb)
self._stage.connect("destroy", lambda x: self.quit)
self._video_texture.connect_after("size-change",
self._video_texture_size_change_cb)
# Text labels
self._info_label = Clutter.Text().new_full(FONT, "TODO", WHITE)
self._info_label.hide()
self._help_label = Clutter.Text().new_full(
FONT, HELP_TEXT, WHITE)
self._help_label.hide()
self._stage.add_actor(self._video_texture)
self._stage.add_actor(self._help_label)
self._stage.add_actor(self._info_label)
self._eos_handler_id = None
self.play_clip_number(self._current_clip_number)
self._stage.show()
def play_video(sFile, ui):
global gPlayer, gPlayType
stop()
print("INFO:CM:PlayV", sFile)
gPlayer = ClutterGst.Playback()
gPlayer.set_filename(sFile)
gPlayer.set_audio_volume(0.6)
cgstContent = ClutterGst.Aspectratio()
cgstContent.set_player(gPlayer)
ui.set_content(cgstContent)
gVideoContentUI = cgstContent
#ui.show()
# default content gravity is resize fill, so things should be fine.
# need to check, if I require to set the scaling filters explicitly or default is good enough.
gPlayer.set_playing(True)
gPlayType = 'V'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.embed = GtkClutter.Embed()
self.mainActor = self.embed.get_stage()
self.videoPlayback = ClutterGst.Playback()
self.videoContent = ClutterGst.Content()
self.videoPlayback.set_seek_flags(ClutterGst.SeekFlags.ACCURATE)
self.videoContent.set_player(self.videoPlayback)
self.videoPlayback.connect("notify::progress", rewind_progress)
self.set_startup_id('Oboi')
self.set_type_hint(Gdk.WindowTypeHint.DESKTOP)
self.set_skip_pager_hint(True)
self.set_skip_taskbar_hint(True)
self.set_accept_focus(True)
self.stick()
self.set_resizable(False)
self.set_keep_below(True)
self.set_decorated(False)
self.drag_dest_set(Gtk.DestDefaults.MOTION | Gtk.DestDefaults.DROP,
None, Gdk.DragAction.MOVE)
self.add_events(Gdk.EventMask.ENTER_NOTIFY_MASK
| Gdk.EventMask.POINTER_MOTION_MASK
| Gdk.EventMask.SMOOTH_SCROLL_MASK)
self.mainActor.set_background_color(
Clutter.color_from_string("#000")[1])
self.wallpaperActor = Clutter.Actor()
self.videoPath = "file:///home/qwerty/Downloads/videoplayback.mp4"
self.videoPlayback.set_uri(self.videoPath)
print("Video path:", self.videoPlayback.get_uri())
self.videoPlayback.set_playing(True)
print("Is paying:", self.videoPlayback.get_playing())
self.wallpaperActor.set_content(self.videoContent)
# size = get_desktop_size()
self.wallpaperActor.set_pivot_point(0.5, 0.5)
self.wallpaperActor.scale_y = 1
self.wallpaperActor.scale_x = 1
self.mainActor.add_child(self.wallpaperActor)
self.add(self.embed)
def play_audio(sFile):
global gPlayer, gPlayType
stop()
print("INFO:CM:PlayA", sFile)
gPlayer = ClutterGst.Playback()
gPlayer.set_filename(sFile)
gPlayer.set_audio_volume(0.6)
gPlayer.set_playing(True)
gPlayType = 'A'
def init():
#Gst.init()
ClutterGst.init()
from gi.repository import Clutter, ClutterGst, Gst
import sys
ClutterGst.init(sys.argv)
stage = Clutter.Stage()
stage.set_size(800, 600)
stage.connect('destroy', lambda x: Clutter.main_quit())
texture = Clutter.Texture()
pipeline = Gst.parse_launch("playbin2 uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm")
sink = Gst.ElementFactory.make("autocluttersink", None)
sink.set_property("texture", texture)
pipeline.set_property("video-sink", sink)
Gst.Element.set_state(pipeline, Gst.State.PLAYING)
stage.add_actor(texture)
#texture.set_opacity(0)
timeline = Clutter.Timeline()
timeline.set_duration(2500)
#timeline.set_delay(50)
timeline.set_loop(False)
alpha = Clutter.Alpha()
alpha.set_timeline(timeline)
alpha.set_func(lambda a, d: a.get_timeline().get_progress(), None)
behaviour = Clutter.BehaviourRotate(alpha=alpha, angle_start=180, angle_end=0, axis=Clutter.RotateAxis.Y_AXIS, direction = "ccw")
behaviour.apply(texture)
timeline.start()
stage.show_all()
#find which actor was clicked
clicked = stage.get_actor_at_pos(Clutter.PickMode.ALL, event.x, event.y);
#ignore clicks on the stage
if (clicked == stage):
return
#hide the actor that was clicked
clicked.hide()
Gdk.init([])
Gtk.init([])
GtkClutter.init([])
Gst.init([])
Clutter.init([])
ClutterGst.init([])
window = Gtk.Window()
texture = Clutter.Texture.new()
sink = Gst.ElementFactory.make("cluttersink", None)
sink.props.texture = texture
src = Gst.ElementFactory.make ("videotestsrc", None)
pipeline = Gst.Pipeline()
pipeline.add(src, sink)
src.link(sink)
embed = GtkClutter.Embed()
embed.set_size_request(320, 240)
stage = embed.get_stage()
gi.require_version('Clutter', '1.0')
from gi.repository import Gtk, Gdk, GtkClutter, ClutterGst, Clutter, Gst, Gio
from utils import get_desktop_size
from video_wallpaper import VideoWallpaper
from shader_wallpaper import ShaderWallpaper
from OpenGL.GLUT import glutInit, glutMainLoop
if __name__ == '__main__':
# app = App()
# app.run(sys.argv)
# chkDesktop()
GtkClutter.init()
ClutterGst.init()
Gtk.init()
Gst.init()
# glutInit()
size = get_desktop_size(0)
window = VideoWallpaper(title="Test")
# window = ShaderWallpaper(title="Test")
window.move(1920, 0)
window.set_actors_size(size)
window.set_default_size(size[0], size[1])
window.connect('destroy', Gtk.main_quit)
window.show_all()
# Clutter.main()
Gtk.main()
from pisak.libs.audio import data_loader
import pisak.libs.audio.handlers #@UnusedImport
from pisak.libs.audio import widgets #@UnusedImport
def prepare_folders_view(stage, script, data):
def _folder_tile_handler(tile, playlist_id):
stage.load_view("audio/playlist", {"playlist_id": playlist_id})
data_source = script.get_object("data_source")
data_source.item_handler = _folder_tile_handler
handlers.button_to_view(stage, script, "button_exit")
def prepare_playlist_view(stage, script, data):
script.get_object("data_source").data_set_id = data["playlist_id"]
handlers.button_to_view(stage, script, "button_exit")
handlers.button_to_view(stage, script, "button_return", "audio/main")
if __name__ == "__main__":
ClutterGst.init()
_audio_app = {
"app": "audio",
"type": "clutter",
"views": [("playlist", prepare_playlist_view),
("main", prepare_folders_view)]
}
data_loader.load_all()
launcher.run(_audio_app)
def on_key_press_event(self, stage, event):
print('on_key_press_event', event)
if event.unicode_value:
c = event.unicode_value
if c in 'qx':
self.on_destroy(stage, event)
print('quit')
elif c in 'pP':
self.player.set_state(Gst.State.PAUSED)
print('pause')
elif c in 'gG':
self.player.set_state(Gst.State.PLAYING)
print('play')
elif c in 'sS':
self.player.seek_simple(
Gst.Format.TIME,
Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNIT, 0)
self.player.set_state(Gst.State.PAUSED)
print('stop')
if __name__ == '__main__':
from sys import argv
GObject.threads_init()
Gst.init(argv)
ClutterGst.init(argv)
Clutter.init(argv)
video = Video(*argv[1:])
Clutter.main()
def __init__(self):
signal.signal(signal.SIGINT, self._quit)
signal.signal(signal.SIGTERM, self._quit)
# SIGSEGV as a fail-safe
signal.signal(signal.SIGSEGV, self._quit)
# Initialize
GtkClutter.init()
ClutterGst.init()
create_dir(VIDEO_WALLPAPER_PATH)
self.config_handler = ConfigHandler(self._on_config_modified)
self.config = self.config_handler.config
self.current_video_path = self.config.video_path
self.user_pause_playback = False
self.is_any_maximized, self.is_any_fullscreen = False, False
# Monitor Detect
self.width, self.height = self.monitor_detect()
# Actors initialize
self.embed = GtkClutter.Embed()
self.main_actor = self.embed.get_stage()
self.main_actor.set_background_color(Clutter.Color.get_static(Clutter.StaticColor.BLACK))
# Video initialize
self.video_playback = ClutterGst.Playback()
self.video_content = ClutterGst.Content()
self.video_content.set_player(self.video_playback)
# Playback settings
self.video_playback.set_filename(self.config.video_path)
self.video_playback.set_audio_volume(0.0 if self.config.mute_audio else self.config.audio_volume)
self.video_playback.set_playing(True)
self.video_playback.connect('eos', self._on_eos)
self.main_actor.set_content(self.video_content)
# Window settings
self.window = Gtk.Window()
self.window.add(self.embed)
self.window.set_type_hint(Gdk.WindowTypeHint.DESKTOP)
self.window.set_size_request(self.width, self.height)
# button event
self._build_context_menu()
self.window.connect('button-press-event', self._on_button_press_event)
self.window.show_all()
self.active_handler = ActiveHandler(self._on_active_changed)
self.window_handler = WindowHandler(self._on_window_state_changed)
self.static_wallpaper_handler = StaticWallpaperHandler()
self.static_wallpaper_handler.set_static_wallpaper()
if self.config.video_path == '':
# First time
ControlPanel().run()
elif not os.path.isfile(self.config.video_path):
self._on_file_not_found(self.config.video_path)
self.file_list = scan_dir()
random.shuffle(self.file_list)
self.current = 0
if self.config.video_path in self.file_list:
self.current = self.file_list.index(self.config.video_path)
Gtk.main()
#!/usr/bin/python
from gi.repository import Gdk
from gi.repository import ClutterGst
from gi.repository import Clutter
from gi.repository import GtkClutter
from gi.repository import Gst
from gi.repository import Gtk
Gdk.init([])
Gtk.init([])
GtkClutter.init([])
Gst.init([])
Clutter.init([])
ClutterGst.init([])
window = Gtk.Window()
texture = Clutter.Texture.new()
sink = Gst.ElementFactory.make("cluttersink", None)
sink.props.texture = texture
src = Gst.ElementFactory.make("videotestsrc", None)
pipeline = Gst.Pipeline()
pipeline.add(src, sink)
src.link(sink)
embed = GtkClutter.Embed()
embed.set_size_request(320, 240)
stage = embed.get_stage()
stage.add_child(texture)
def __init__(self, filename, logo=None, fullscreen=False, loop=False):
"""
Build the user interface.
"""
stage_color = Clutter.Color.new( 0, 0, 0, 0)
control_color1 = Clutter.Color.new( 73, 74, 77, 0xee)
control_color2 = Clutter.Color.new(0xcc, 0xcc, 0xcc, 0xff)
self.SEEK_W = 440
self.SEEK_H = 14
self.fullscreen = fullscreen
self.logo = logo
self.loop = loop
self.controls_showing = True
self.paused = True
self.controls_timeout = 0
ClutterGst.init(sys.argv)
self.stage = Clutter.Stage.get_default()
self.stage.set_title("A simple video player ported to Python")
self.stage.set_color(stage_color)
self.stage.set_size(768, 576)
self.stage.set_minimum_size(640, 480)
if self.fullscreen:
self.stage.set_fullscreen(True)
self.vtexture = ClutterGst.VideoTexture()
"""
By default ClutterGst seeks to the nearest key frame (faster). However
it has the weird effect that when you click on the progress bar, the fil
goes to the key frame position that can be quite far from where you
clicked. Using the ACCURATE flag tells playbin2 to seek to the actual
frame
"""
self.vtexture.set_seek_flags(ClutterGst.SeekFlags(1))
self.vtexture.connect("eos", self._on_video_texture_eos)
self.stage.connect("allocation-changed", self._on_stage_allocation_changed)
# Handle it ourselves so can scale up for fullscreen better
self.vtexture.connect_after("size-change", self._size_change)
# Load up out video texture
self.vtexture.set_filename(filename)
# Create the control UI
self.control = Clutter.Group.new()
self.control_bg = Clutter.Texture().new_from_file("vid-panel.png")
self.control_play = Clutter.Texture().new_from_file("media-actions-start.png")
self.control_pause = Clutter.Texture().new_from_file("media-actions-pause.png")
self.control_seek1 = Clutter.Rectangle().new_with_color(control_color1)
self.control_seek2 = Clutter.Rectangle().new_with_color(control_color2)
self.control_seekbar = Clutter.Rectangle().new_with_color(control_color1)
self.control_seekbar.set_opacity(0x99)
self.control_label = Clutter.Text().new_full("Sans Bold 14",
basename(filename),
control_color1)
self.control_play.hide()
self.control.add_actor(self.control_bg)
self.control.add_actor(self.control_play)
self.control.add_actor(self.control_pause)
self.control.add_actor(self.control_seek1)
self.control.add_actor(self.control_seek2)
self.control.add_actor(self.control_seekbar)
self.control.add_actor(self.control_label)
self.control.set_opacity(0x99)
self.control_play.set_position(22, 31)
self.control_pause.set_position(18, 31)
self.control_seek1.set_size(self.SEEK_W+4, self.SEEK_H+4)
self.control_seek1.set_position(80, 57)
self.control_seek2.set_size(self.SEEK_W, self.SEEK_H)
self.control_seek2.set_position(82, 59)
self.control_seekbar.set_size(0, self.SEEK_H)
self.control_seekbar.set_position(82, 59)
self.control_label.set_position(82, 29)
# Add control UI to stage
self.stage.add_actor(self.vtexture)
self.stage.add_actor(self.control)
self._position_controls()
self.stage.hide_cursor()
# TODO: Waiting for G-I bugfix
# self.control.animatev(Clutter.AnimationMode.EASE_OUT_QUINT, 1000, ["opacity"], [0])
# Hook up other events
self.stage.connect("event", self._input_cb)
self.vtexture.connect("notify::progress", self._tick)
# Insert a broadcast logo, if provided
if self.logo is not None:
self.logo = Clutter.Texture().new_from_file(logo)
self.stage.add_actor(self.logo)
self.vtexture.set_playing(True)
self.stage.show();
item2.setFromAttrib(element.attrib)
items.append(item2)
item.setItems(items)
region_ids = {}
region_names = {}
xml = ET.parse(sys.argv[1])
root = xml.find('./head/layout/root-layout')
smil_rootlayout = layout_rootlayout()
smil_rootlayout.setFromAttrib(root.attrib)
Clutter.init(sys.argv)
ClutterGst.init(sys.argv)
stage = Clutter.Stage.get_default()
stage.set_title("SMIL")
smil_rootlayout.clutter(stage)
for region in xml.findall('./head/layout/region'):
smil_region = layout_region()
smil_region.setFromAttrib(region.attrib)
if '{http://www.w3.org/XML/1998/namespace}id' in region.attrib:
region_ids[region.attrib['{http://www.w3.org/XML/1998/namespace}id']] = smil_region
if 'regionName' in region.attrib:
if region.attrib['regionName'] in region_names:
def __init__(self):
super().__init__()
self.engine = ClutterGst.VideoTexture()
