def _CreateGesElements(self):
self.timeline = GES.Timeline.new()
self.timeline.add_track(GES.VideoTrack.new())
self.timeline.add_track(GES.AudioTrack.new())
self.timeline.set_auto_transition(0)
self._GesUpdateRestrictionCaps()
self.pipeline = GES.Pipeline()
self.pipeline.set_timeline(self.timeline)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self._GstOnMessage)
self.layer_video = GES.Layer()
self.layer_vertical_effect = GES.Layer()
self.layer_vertical_effect.set_priority(1)
self.layer_audio = GES.Layer()
self.layer_audio.set_priority(2)
self.timeline.add_layer(self.layer_video)
self.timeline.add_layer(self.layer_vertical_effect)
self.timeline.add_layer(self.layer_audio)
self.project = self.timeline.get_asset()
self.project.connect("asset-added", self._GesOnAssetAdded)
self.project.connect("error-loading-asset", self._GesOnErrorLoadingAsset)
def _CreateGesElements(self):
self.timeline = GES.Timeline.new()
self.timeline.add_track(GES.VideoTrack.new())
self.timeline.add_track(GES.AudioTrack.new())
self.timeline.set_auto_transition(0)
self._GesUpdateRestrictionCaps()
self.pipeline = GES.Pipeline()
self.pipeline.set_timeline(self.timeline)
bus = self.pipeline.get_bus()
bus.add_signal_watch()
# Workaound: connecting to all messages results in "Python int too large to convert to C long" ???
bus.connect("message::error", self._GstOnMessage)
bus.connect("message::eos", self._GstOnMessage)
bus.connect("message::state-changed", self._GstOnMessage)
bus.connect("message::warning", self._GstOnMessage)
self.layer_video = GES.Layer()
self.layer_vertical_effect = GES.Layer()
self.layer_vertical_effect.set_priority(1)
self.layer_audio = GES.Layer()
self.layer_audio.set_priority(2)
self.timeline.add_layer(self.layer_video)
self.timeline.add_layer(self.layer_vertical_effect)
self.timeline.add_layer(self.layer_audio)
self.project = self.timeline.get_asset()
self.project.connect("asset-added", self._GesOnAssetAdded)
self.project.connect("error-loading-asset",
self._GesOnErrorLoadingAsset)
def testConnectionAndDisconnection(self):
timeline = GES.Timeline.new_audio_video()
layer = GES.Layer()
timeline.add_layer(layer)
self.observer.startObserving(timeline)
self.assertTrue(timeline.connected)
clip1 = GES.TitleClip()
layer.add_clip(clip1)
track_element1 = clip1.get_children(False)[0]
self.assertTrue(timeline.connected)
self.assertTrue(clip1.connected)
self.assertTrue(track_element1.connected)
layer.remove_clip(clip1)
self.assertTrue(timeline.connected)
self.assertFalse(clip1.connected)
self.assertFalse(track_element1.connected)
layer.add_clip(clip1)
track_element2 = clip1.get_children(False)[0]
self.assertTrue(timeline.connected)
self.assertTrue(clip1.connected)
self.assertFalse(track_element1.connected)
self.assertTrue(track_element2.connected)
self.observer.stopObserving(timeline)
self.assertFalse(timeline.connected)
self.assertFalse(clip1.connected)
self.assertFalse(track_element1.connected)
self.assertFalse(track_element2.connected)
def setUp(self):
self.timeline = GES.Timeline.new_audio_video()
self.layer = GES.Layer()
self.timeline.add_layer(self.layer)
self.action_log = UndoableActionLog()
self.observer = TimelineLogObserverSpy(self.action_log)
self.observer.startObserving(self.timeline)
def testCheckMediaTypesWhenNoUI(self):
ges_layer = GES.Layer()
png = common.get_sample_uri("flat_colour1_640x480.png")
video_clip = GES.UriClipAsset.request_sync(png).extract()
self.assertTrue(ges_layer.add_clip(video_clip))
self.assertEqual(len(ges_layer.get_clips()), 1)
timeline = Timeline(container=None, app=None)
layer = Layer(ges_layer, timeline)
def setUp(self):
app = Pitivi()
app._startupCb(app)
app.project_manager.newBlankProject()
self.timeline = app.project_manager.current_project.timeline
self.layer = GES.Layer()
self.timeline.add_layer(self.layer)
self.action_log = UndoableActionLog()
self.observer = TimelineLogObserverSpy(self.action_log)
self.observer.startObserving(self.timeline)
def test_check_media_types_when_no_control_ui(self):
ges_layer = GES.Layer()
png = common.get_sample_uri("flat_colour1_640x480.png")
video_clip = GES.UriClipAsset.request_sync(png).extract()
self.assertTrue(ges_layer.add_clip(video_clip))
self.assertEqual(len(ges_layer.get_clips()), 1)
timeline_container = common.create_timeline_container()
timeline = timeline_container.timeline
# This will add widgets for the clips in ges_layer and
# the layer will use checkMediaTypes which updates the
# height of layer.control_ui, which now it should not be set.
self.assertFalse(hasattr(ges_layer, "control_ui"))
unused_layer = Layer(ges_layer, timeline)
def __init__(self, uri):
timeline = GES.Timeline()
trackv = GES.Track.video_raw_new()
self.layer = GES.Layer()
self.pipeline = GES.TimelinePipeline()
self.pipeline.add_timeline(timeline)
timeline.add_track(trackv)
timeline.add_layer(self.layer)
GES.Asset.new_async(GES.UriClip, uri, None, self.discoveredCb, None)
self.loop = GLib.MainLoop()
self.loop.run()
def test_name(self):
timeline = mock.MagicMock()
ges_layer = GES.Layer()
layer = Layer(ges_layer, timeline)
self.assertEqual(layer.get_name(), "Layer 0", "Default name generation failed")
ges_layer.set_meta("audio::name", "a")
self.assertEqual(layer.get_name(), "a", "Cannot use old audio name")
ges_layer.set_meta("video::name", "v")
self.assertEqual(layer.get_name(), "v", "Cannot use old video name")
layer.set_name("vv")
self.assertEqual(layer.get_name(), "vv")
def _ensureLayer(self):
"""
Make sure we have a layer in our timeline
Returns: The number of layer present in self.timeline
"""
layers = self.bTimeline.get_layers()
if not layers:
layer = GES.Layer()
layer.props.auto_transition = True
self.bTimeline.add_layer(layer)
layers = [layer]
return layers
def __init__(self, uri):
timeline = GES.Timeline()
trackv = GES.Track.video_raw_new()
layer = GES.Layer()
self.pipeline = GES.TimelinePipeline()
self.pipeline.add_timeline(timeline)
timeline.add_track(trackv)
timeline.add_layer(layer)
src = GES.UriClip.new(uri=uri)
src.set_start(long(0))
src.set_duration(long(10 * Gst.SECOND))
print src
layer.add_object(src)
def testTimeline(self, timeline):
timeline.set_easing_duration(600)
Gst.init([])
GES.init()
self.project = GES.Project(uri=None, extractable_type=GES.Timeline)
bTimeline = GES.Timeline()
bTimeline.add_track(GES.Track.audio_raw_new())
bTimeline.add_track(GES.Track.video_raw_new())
self.bTimeline = bTimeline
timeline.setTimeline(bTimeline)
layer = GES.Layer()
bTimeline.add_layer(layer)
self.bTimeline = bTimeline
self.project.connect("asset-added", self._doAssetAddedCb, layer)
self.project.create_asset("file://" + sys.argv[2], GES.UriClip)
container_profile.add_profile(video_profile)
audio_profile = GstPbutils.EncodingAudioProfile.new(
Gst.Caps.from_string(audio), None, Gst.Caps.from_string("audio/x-raw"),
0)
container_profile.add_profile(audio_profile)
return container_profile
if __name__ == "__main__":
Gst.init(None)
GES.init()
timeline = GES.Timeline.new_audio_video()
layer = GES.Layer()
timeline.add_layer(layer)
asset = GES.Asset.request(GES.TestClip, None)
layer.add_asset(asset, 0 * Gst.SECOND, 0, 10 * Gst.SECOND,
GES.TrackType.UNKNOWN)
timeline.commit()
pipeline = GES.Pipeline()
pipeline.add_timeline(timeline)
format = [
"video/quicktime,variant=iso", "video/x-h264",
"audio/mpeg,mpegversion=1,layer=3", "mov"
]
def test_name_meaningful(self):
timeline = mock.MagicMock()
ges_layer = GES.Layer()
layer = Layer(ges_layer, timeline)
layer.setName("Layer 0x")
self.assertEqual(layer.getName(), "Layer 0x")
def __init__(self, world, socketIO):
# member initialization
self.world = world
self.socketIO = socketIO
self.active_dialogs = []
self.users = []
self.label_queue = Queue()
self.curr_label = None
self.fullscreen = False
self.girl = None
#GES stuff
self.timeline = GES.Timeline.new_audio_video()
self.layer = GES.Layer()
self.timeline.add_layer(self.layer)
self.open_file(self.world.video_path)
self.pipeline = GES.Pipeline()
self.pipeline.set_timeline(self.timeline)
self.pipeline.set_state(Gst.State.PAUSED)
# GES bins
sinkbin = Gst.Bin.new("sinkbin")
convert1 = Gst.ElementFactory.make("videoconvert")
sinkbin.add(convert1)
pad = convert1.get_static_pad("sink")
ghostpad = Gst.GhostPad.new("sink", pad)
sinkbin.add_pad(ghostpad)
cairooverlay = Gst.ElementFactory.make("cairooverlay")
sinkbin.add(cairooverlay)
cairooverlay.connect('draw', self.on_draw)
convert1.link(cairooverlay)
convert2 = Gst.ElementFactory.make("videoconvert")
sinkbin.add(convert2)
cairooverlay.link(convert2)
videosink = Gst.ElementFactory.make("xvimagesink")
sinkbin.add(videosink)
convert2.link(videosink)
self.pipeline.preview_set_video_sink(sinkbin)
# GTK window stuff
self.window = Gtk.Window()
self.window.set_title("Averoid Adventures")
accel = Gtk.AccelGroup()
accel.connect(Gdk.keyval_from_name('Q'), 0, 0, self.on_q_pressed)
accel.connect(Gdk.keyval_from_name('F'), 0, 0, self.on_f_pressed)
self.window.add_accel_group(accel)
self.window.connect("delete-event", self.window_closed)
self.window.show_all()
self.window.realize()
xid = self.window.get_window().get_xid()
videosink.set_window_handle(xid)
#state machine stuff
self.state = STATE_IDLE
self.state_funcs = {
STATE_IDLE: [self.enter_idle_cb, self.idle_cb, self.leave_idle_cb],
STATE_CHOICE:
[self.enter_choice_cb, self.choice_cb, self.leave_choice_cb],
STATE_JUMP: [self.enter_jump_cb, self.jump_cb, self.leave_jump_cb],
STATE_SPORTSBALL: [
self.enter_sportsball_cb, self.sportsball_cb,
self.leave_sportsball_cb
],
STATE_POEM: [self.enter_poem_cb, self.poem_cb, self.leave_poem_cb]
}
self.end_label_time = -1 #TODO: better solution
time.sleep(1)
self.jump_label(self.world.current_label)
self.pipeline.set_state(Gst.State.PLAYING)
