def test_thumb_interval(self):
"""Checks the `thumb_interval` property."""
ges_elem = mock.Mock()
ges_elem.props.uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
ges_elem.props.id = common.get_sample_uri("1sec_simpsons_trailer.mp4")
previewer = VideoPreviewer(ges_elem, 94)
previewer.thumb_width = 1 # Just so it's not None.
def run_thumb_interval(interval):
"""Runs thumb_interval."""
with mock.patch(
"pitivi.utils.timeline.Zoomable.pixelToNs") as pixel_to_ns:
pixel_to_ns.return_value = interval
return previewer.thumb_interval
self.assertEqual(run_thumb_interval(1), THUMB_PERIOD)
self.assertEqual(run_thumb_interval(THUMB_PERIOD - 1), THUMB_PERIOD)
self.assertEqual(run_thumb_interval(THUMB_PERIOD), THUMB_PERIOD)
self.assertEqual(run_thumb_interval(THUMB_PERIOD + 1),
2 * THUMB_PERIOD)
self.assertEqual(run_thumb_interval(2 * THUMB_PERIOD - 1),
2 * THUMB_PERIOD)
self.assertEqual(run_thumb_interval(2 * THUMB_PERIOD),
2 * THUMB_PERIOD)
def test_scanning(self):
"""Checks the scanning of the URIs."""
valid_uri = common.get_sample_uri("tears_of_steel.webm")
uris = self._scan([valid_uri,
common.get_sample_uri("missing.webm"),
"http://pitivi.org/very_real.webm"])
self.assertEqual(len(uris), 1, uris)
self.assertIn(valid_uri, uris)
def test_scanning(self):
"""Checks the scanning of the URIs."""
valid_uri = common.get_sample_uri("tears_of_steel.webm")
uris = self._scan([valid_uri,
common.get_sample_uri("missing.webm"),
"http://pitivi.org/very_real.webm"])
self.assertEqual(len(uris), 1, uris)
self.assertIn(valid_uri, uris)
def test_containment(self):
"""Checks the __contains/getitem/setitem__ methods."""
with tempfile.TemporaryDirectory() as tmpdirname:
with mock.patch("pitivi.timeline.previewers.xdg_cache_home"
) as xdg_cache_home:
xdg_cache_home.return_value = tmpdirname
sample_uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
thumb_cache = ThumbnailCache(sample_uri)
self.assertFalse(Gst.SECOND in thumb_cache)
with self.assertRaises(KeyError):
# pylint: disable=pointless-statement
thumb_cache[Gst.SECOND]
pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB,
False, 8,
int(THUMB_HEIGHT * 1280 / 544),
THUMB_HEIGHT)
thumb_cache[Gst.SECOND] = pixbuf
self.assertTrue(Gst.SECOND in thumb_cache)
self.assertIsNotNone(thumb_cache[Gst.SECOND])
thumb_cache.commit()
thumb_cache = ThumbnailCache(sample_uri)
self.assertTrue(Gst.SECOND in thumb_cache)
self.assertIsNotNone(thumb_cache[Gst.SECOND])
def test_async_done_not_received(self):
"""Checks the recovery when the ASYNC_DONE message timed out."""
ges_timeline = GES.Timeline.new()
self.assertTrue(ges_timeline.add_track(GES.VideoTrack.new()))
ges_layer = ges_timeline.append_layer()
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
ges_clip = asset.extract()
self.assertTrue(ges_layer.add_clip(ges_clip))
self.assertFalse(ges_timeline.is_empty())
pipe = Pipeline(app=common.create_pitivi_mock())
pipe.set_timeline(ges_timeline)
self.assertFalse(pipe._busy_async)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.NOT_RECOVERING)
# Pretend waiting for async-done timed out.
# We mock set_state because we don't actually care about the state,
# and setting the state to PAUSED could show a video window.
with mock.patch.object(pipe, "set_state"):
pipe._async_done_not_received_cb()
# Make sure the pipeline started a watchdog timer waiting for async-done
# as part of setting the state from NULL to PAUSED.
self.assertTrue(pipe._busy_async)
self.assertEqual(pipe._attempted_recoveries, 1)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.STARTED_RECOVERING)
# Pretend the state changed to READY.
message = mock.Mock()
message.type = Gst.MessageType.STATE_CHANGED
message.src = pipe._pipeline
message.parse_state_changed.return_value = (Gst.State.NULL, Gst.State.READY, Gst.State.PAUSED)
pipe._busMessageCb(None, message)
# Pretend the state changed to PAUSED.
message.parse_state_changed.return_value = (Gst.State.READY, Gst.State.PAUSED, Gst.State.VOID_PENDING)
self.assertEqual(pipe._next_seek, None)
pipe._busMessageCb(None, message)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.SEEKED_AFTER_RECOVERING)
self.assertTrue(pipe._busy_async)
# The pipeline should have tried to seek back to the last position.
self.assertEqual(pipe._next_seek, 0)
# Pretend the state change (to PAUSED) async operation succeeded.
message.type = Gst.MessageType.ASYNC_DONE
with mock.patch.object(pipe, "get_state") as get_state:
get_state.return_value = (0, Gst.State.PAUSED, 0)
pipe._busMessageCb(None, message)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.NOT_RECOVERING)
# Should still be busy because of seeking to _next_seek.
self.assertTrue(pipe._busy_async)
self.assertIsNone(pipe._next_seek)
# Pretend the seek async operation finished.
message.type = Gst.MessageType.ASYNC_DONE
pipe._busMessageCb(None, message)
self.assertEqual(pipe._recovery_state, SimplePipeline.RecoveryState.NOT_RECOVERING)
self.assertFalse(pipe._busy_async)
self.assertIsNone(pipe._next_seek)
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 testSetAudioProp(self):
timeline = common.create_timeline_container()
project = timeline.app.project_manager.current_project
project.addUris([common.get_sample_uri("mp3_sample.mp3")])
audio_track = [
t for t in project.ges_timeline.tracks
if isinstance(t, GES.AudioTrack)
][0]
mainloop = common.create_main_loop()
def progress_cb(project, progress, estimated_time):
if progress == 100:
mainloop.quit()
project.connect_after("asset-loading-progress", progress_cb)
mainloop.run()
expected = Gst.Caps("audio/x-raw,channels=(int)2,rate=(int)44100")
ccaps = audio_track.props.restriction_caps
self.assertTrue(ccaps.is_equal_fixed(expected),
"%s != %s" % (ccaps, expected))
project.audiochannels = 6
expected = Gst.Caps("audio/x-raw,channels=(int)6,rate=(int)44100")
ccaps = audio_track.props.restriction_caps
self.assertTrue(ccaps.is_equal_fixed(expected),
"%s != %s" % (ccaps, expected))
def __check_simple(self, left_click_also_seeks):
timeline_container = create_timeline_container()
timeline = timeline_container.timeline
timeline.app.settings.leftClickAlsoSeeks = left_click_also_seeks
ges_layer = timeline.ges_timeline.append_layer()
asset = GES.UriClipAsset.request_sync(
common.get_sample_uri("1sec_simpsons_trailer.mp4"))
ges_clip1 = ges_layer.add_asset(asset, 0 * Gst.SECOND, 0,
1 * Gst.SECOND, GES.TrackType.UNKNOWN)
ges_clip2 = ges_layer.add_asset(asset, 1 * Gst.SECOND, 0,
1 * Gst.SECOND, GES.TrackType.UNKNOWN)
event = mock.Mock()
event.get_button.return_value = (True, 1)
timeline._seek = mock.Mock()
timeline._seek.return_value = True
timeline.get_clicked_layer_and_pos = mock.Mock()
with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
get_event_widget.return_value = timeline
# Simulate click on first and shift+click on second clip.
timeline.get_clicked_layer_and_pos.return_value = (ges_layer, 0.5 * Gst.SECOND)
timeline._button_release_event_cb(None, event)
timeline.get_parent()._shiftMask = True
timeline.get_clicked_layer_and_pos.return_value = (ges_layer, 1.5 * Gst.SECOND)
timeline._button_release_event_cb(None, event)
self.__check_selected([ges_clip1, ges_clip2], [])
def test_missing_uri_displayed(self):
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
self._customSetUp(project_uri=uri)
self.assertTrue(
self.medialibrary._import_warning_infobar.props.visible)
def load_project_with_missing_proxy(self):
"""Loads a project with missing proxies."""
uris = [common.get_sample_uri("1sec_simpsons_trailer.mp4")]
proxy_uri = uris[0] + ".232417.proxy.mkv"
PROJECT_STR = """<ges version='0.3'>
<project properties='properties;' metadatas='metadatas, name=(string)"New\ Project", author=(string)Unknown, render-scale=(double)100;'>
<encoding-profiles>
</encoding-profiles>
<ressources>
<asset id='%(uri)s' extractable-type-name='GESUriClip' properties='properties, supported-formats=(int)6, duration=(guint64)1228000000;' metadatas='metadatas, audio-codec=(string)"MPEG-4\ AAC\ audio", maximum-bitrate=(uint)130625, bitrate=(uint)130625, datetime=(datetime)2007-02-19T05:03:04Z, encoder=(string)Lavf54.6.100, container-format=(string)"ISO\ MP4/M4A", video-codec=(string)"H.264\ /\ AVC", file-size=(guint64)232417;' proxy-id='file:///home/thiblahute/devel/pitivi/flatpak/pitivi/tests/samples/1sec_simpsons_trailer.mp4.232417.proxy.mkv' />
<asset id='%(proxy_uri)s' extractable-type-name='GESUriClip' properties='properties, supported-formats=(int)6, duration=(guint64)1228020833;' metadatas='metadatas, container-format=(string)Matroska, audio-codec=(string)Opus, language-code=(string)en, encoder=(string)Lavf54.6.100, bitrate=(uint)64000, video-codec=(string)"Motion\ JPEG", file-size=(guint64)4695434;' />
</ressources>
<timeline properties='properties, auto-transition=(boolean)true, snapping-distance=(guint64)0;' metadatas='metadatas, duration=(guint64)0;'>
<track caps='video/x-raw(ANY)' track-type='4' track-id='0' properties='properties, async-handling=(boolean)false, message-forward=(boolean)true, caps=(string)"video/x-raw\(ANY\)", restriction-caps=(string)"video/x-raw\,\ width\=\(int\)720\,\ height\=\(int\)576\,\ framerate\=\(fraction\)25/1", mixing=(boolean)true;' metadatas='metadatas;'/>
<track caps='audio/x-raw(ANY)' track-type='2' track-id='1' properties='properties, async-handling=(boolean)false, message-forward=(boolean)true, caps=(string)"audio/x-raw\(ANY\)", restriction-caps=(string)"audio/x-raw\,\ format\=\(string\)S32LE\,\ channels\=\(int\)2\,\ rate\=\(int\)44100\,\ layout\=\(string\)interleaved", mixing=(boolean)true;' metadatas='metadatas;'/>
<layer priority='0' properties='properties, auto-transition=(boolean)true;' metadatas='metadatas, volume=(float)1;'>
<clip id='0' asset-id='%(proxy_uri)s' type-name='GESUriClip' layer-priority='0' track-types='6' start='0' duration='1228000000' inpoint='0' rate='0' properties='properties, name=(string)uriclip0, mute=(boolean)false, is-image=(boolean)false;' >
<source track-id='1' children-properties='properties, GstVolume::mute=(boolean)false, GstVolume::volume=(double)1;'>
<binding type='direct' source_type='interpolation' property='volume' mode='1' track_id='1' values =' 0:0.10000000000000001 1228000000:0.10000000000000001 '/>
</source>
<source track-id='0' children-properties='properties, GstFramePositioner::alpha=(double)1, GstDeinterlace::fields=(int)0, GstFramePositioner::height=(int)720, GstDeinterlace::mode=(int)0, GstFramePositioner::posx=(int)0, GstFramePositioner::posy=(int)0, GstDeinterlace::tff=(int)0, GstFramePositioner::width=(int)1280;'>
<binding type='direct' source_type='interpolation' property='alpha' mode='1' track_id='0' values =' 0:1 1228000000:1 '/>
</source>
</clip>
</layer>
<groups>
</groups>
</timeline>
</project>
</ges>""" % {"uri": uris[0], "proxy_uri": proxy_uri}
app = common.create_pitivi(proxyingStrategy=ProxyingStrategy.ALL)
proxy_manager = app.proxy_manager
project_manager = app.project_manager
mainloop = common.create_main_loop()
unused, xges_path = tempfile.mkstemp(suffix=".xges")
proj_uri = "file://" + os.path.abspath(xges_path)
app.project_manager.saveProject(uri=proj_uri)
medialib = medialibrary.MediaLibraryWidget(app)
with open(proj_uri[len("file://"):], "w") as f:
f.write(PROJECT_STR)
# Remove proxy
common.clean_proxy_samples()
def closing_project_cb(*args, **kwargs):
# Do not ask whether to save project on closing.
return True
def proxy_ready_cb(proxy_manager, asset, proxy):
self.assertEqual(proxy.props.id, proxy_uri)
mainloop.quit()
project_manager.connect("closing-project", closing_project_cb)
proxy_manager.connect_after("proxy-ready", proxy_ready_cb)
app.project_manager.loadProject(proj_uri)
return mainloop, app, medialib, proxy_uri
def test_prop_keyframe(self):
"""Checks the keyframe button effect."""
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
ges_clip = asset.extract()
# Add the clip to a timeline so it gets tracks.
timeline = common.create_timeline_container()
self.app = timeline.app
ges_timeline = timeline.ges_timeline
ges_timeline.append_layer()
ges_layer, = ges_timeline.get_layers()
ges_layer.add_clip(ges_clip)
self._register_alpha_widget(
("black_sens_adjustment", "GstAlpha::black-sensitivity", "GstAlpha::black-sensitivity::keyframe"))
ges_clip.add(self.alpha_effect)
track_element = self.element_settings_widget._GstElementSettingsWidget__get_track_element_of_same_type(
self.alpha_effect)
prop_keyframe_button = \
list(self.element_settings_widget._GstElementSettingsWidget__widgets_by_keyframe_button.keys())[0]
# Control the self.prop property on the timeline
prop_keyframe_button.set_active(True)
self.assertEqual(track_element.ui_element._TimelineElement__controlledProperty, self.prop)
# Revert to controlling the default property
prop_keyframe_button.set_active(False)
self.assertNotEqual(track_element.ui_element._TimelineElement__controlledProperty, self.prop)
def test_prop_keyframe(self):
"""Checks the keyframe button effect."""
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
ges_clip = asset.extract()
# Add the clip to a timeline so it gets tracks.
timeline = common.create_timeline_container()
self.app = timeline.app
ges_timeline = timeline.ges_timeline
ges_timeline.append_layer()
ges_layer, = ges_timeline.get_layers()
ges_layer.add_clip(ges_clip)
self._register_alpha_widget(
("black_sens_adjustment", "GstAlpha::black-sensitivity",
"GstAlpha::black-sensitivity::keyframe"))
ges_clip.add(self.alpha_effect)
track_element = self.element_settings_widget._GstElementSettingsWidget__get_track_element_of_same_type(
self.alpha_effect)
prop_keyframe_button = \
list(self.element_settings_widget._GstElementSettingsWidget__widgets_by_keyframe_button.keys())[0]
# Control the self.prop property on the timeline
prop_keyframe_button.set_active(True)
self.assertEqual(
track_element.ui_element._TimelineElement__controlledProperty,
self.prop)
# Revert to controlling the default property
prop_keyframe_button.set_active(False)
self.assertNotEqual(
track_element.ui_element._TimelineElement__controlledProperty,
self.prop)
def test_control_source_value_changed(self):
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
clip = asset.extract()
self.layer.add_clip(clip)
source = clip.get_children(False)[1]
self.assertTrue(isinstance(source, GES.VideoUriSource))
control_source = GstController.InterpolationControlSource()
control_source.props.mode = GstController.InterpolationMode.LINEAR
self.assert_control_source_values(control_source, [], [])
source.set_control_source(control_source, "alpha", "direct")
self.assert_control_source_values(control_source, [1, 1],
[0, 2003000000])
self.assertTrue(control_source.set(Gst.SECOND * 0.5, 0.2))
self.assert_control_source_values(control_source, [1, 0.2, 1],
[0, Gst.SECOND * 0.5, 2003000000])
with self.action_log.started("keyframe changed"):
self.assertTrue(control_source.set(Gst.SECOND * 0.5, 0.9))
self.assert_control_source_values(control_source, [1, 0.9, 1],
[0, Gst.SECOND * 0.5, 2003000000])
self.action_log.undo()
self.assert_control_source_values(control_source, [1, 0.2, 1],
[0, Gst.SECOND * 0.5, 2003000000])
self.action_log.redo()
self.assert_control_source_values(control_source, [1, 0.9, 1],
[0, Gst.SECOND * 0.5, 2003000000])
def test_asset_added_signal(self):
app = common.create_pitivi()
self.assertTrue(app.project_manager.newBlankProject())
project = app.project_manager.current_project
proxy_manager = app.proxy_manager
mainloop = common.create_main_loop()
def asset_added_cb(project, asset, assets):
assets.append(asset)
assets = []
project.connect("asset-added", asset_added_cb, assets)
def proxy_ready_cb(unused_proxy_manager, asset, proxy):
mainloop.quit()
proxy_manager.connect("proxy-ready", proxy_ready_cb)
uris = [common.get_sample_uri("tears_of_steel.webm")]
project.addUris(uris)
mainloop.run()
self.assertEqual(len(assets), 1, assets)
def test_launching_rendering(self):
"""Checks no exception is raised when clicking the render button."""
timeline_container = common.create_timeline_container()
app = timeline_container.app
project = app.project_manager.current_project
mainloop = common.create_main_loop()
def asset_added_cb(project, asset): # pylint: disable=missing-docstring
mainloop.quit()
project.connect("asset-added", asset_added_cb)
uris = [common.get_sample_uri("tears_of_steel.webm")]
project.addUris(uris)
mainloop.run()
layer, = project.ges_timeline.get_layers()
layer.add_asset(project.list_assets(GES.UriClip)[0],
0, 0, Gst.CLOCK_TIME_NONE, GES.TrackType.UNKNOWN)
from pitivi.render import RenderDialog, RenderingProgressDialog
with mock.patch.object(Gtk.Builder, "__new__"):
dialog = RenderDialog(app, project)
with mock.patch.object(dialog, "startAction"):
with mock.patch.object(RenderingProgressDialog, "__new__"):
with mock.patch.object(dialog, "_pipeline"):
dialog._renderButtonClickedCb(None)
def __check_simple(self, left_click_also_seeks):
timeline_container = create_timeline_container()
timeline = timeline_container.timeline
timeline.app.settings.leftClickAlsoSeeks = left_click_also_seeks
ges_layer = timeline.ges_timeline.append_layer()
asset = GES.UriClipAsset.request_sync(
common.get_sample_uri("1sec_simpsons_trailer.mp4"))
ges_clip1 = ges_layer.add_asset(asset, 0 * Gst.SECOND, 0,
1 * Gst.SECOND, GES.TrackType.UNKNOWN)
ges_clip2 = ges_layer.add_asset(asset, 1 * Gst.SECOND, 0,
1 * Gst.SECOND, GES.TrackType.UNKNOWN)
event = mock.Mock()
event.get_button.return_value = (True, 1)
timeline._seek = mock.Mock()
timeline._seek.return_value = True
timeline.get_clicked_layer_and_pos = mock.Mock()
with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
get_event_widget.return_value = timeline
# Simulate click on first and shift+click on second clip.
timeline.get_clicked_layer_and_pos.return_value = (ges_layer, 0.5 *
Gst.SECOND)
timeline._button_release_event_cb(None, event)
timeline.get_parent()._shiftMask = True
timeline.get_clicked_layer_and_pos.return_value = (ges_layer, 1.5 *
Gst.SECOND)
timeline._button_release_event_cb(None, event)
self.__check_selected([ges_clip1, ges_clip2], [])
def test_regenerate_scaled_proxy(self):
sample_name = "30fps_numeroted_frames_red.mkv"
with common.cloned_sample(sample_name):
self.check_import([sample_name],
proxying_strategy=ProxyingStrategy.NOTHING)
asset = self.medialibrary.store[0].asset
asset_uri = common.get_sample_uri(sample_name)
# Create scaled proxy
proxy = self.check_add_proxy(asset, scaled=True)
proxy_uri = self.app.proxy_manager.get_proxy_uri(asset,
scaled=True)
# Change target resolution and trigger regeneration (1/4 Asset width)
self.app.project_manager.current_project.scaled_proxy_width = 80
self.app.project_manager.current_project.scaled_proxy_height = 60
self.app.project_manager.current_project.regenerate_scaled_proxies(
)
self.assertTrue("Proxy creation progress:" in
self.medialibrary.store[0].infotext)
self.mainloop.run()
proxy = self.medialibrary.store[0].asset
self.assertNotEqual(proxy.props.id, proxy_uri)
stream = proxy.get_info().get_video_streams()[0]
resolution = [stream.get_width(), stream.get_height()]
self.assertEqual(resolution, [80, 60])
self.assertEqual(proxy.props.proxy_target.props.id, asset_uri)
# Delete proxy
self.check_disable_proxy(proxy, asset, delete=True)
self.assertFalse(os.path.exists(Gst.uri_get_location(proxy_uri)))
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 test_good_for_track_element(self):
"""Tests the good_for_track_element method."""
uri = get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
ges_clip = asset.extract()
# Add the clip to a timeline so it gets tracks.
ges_timeline = create_timeline_container().timeline.ges_timeline
ges_timeline.append_layer()
ges_layer, = ges_timeline.get_layers()
ges_layer.add_clip(ges_clip)
track_elements = dict([
(track_element.get_track_type(), track_element)
for track_element in ges_clip.get_children(recursive=True)
])
audio_track_element = track_elements[GES.TrackType.AUDIO]
video_track_element = track_elements[GES.TrackType.VIDEO]
effect_info = EffectInfo(None, AUDIO_EFFECT, None, None, None)
self.assertTrue(
effect_info.good_for_track_element(audio_track_element))
self.assertFalse(
effect_info.good_for_track_element(video_track_element))
effect_info = EffectInfo(None, VIDEO_EFFECT, None, None, None)
self.assertFalse(
effect_info.good_for_track_element(audio_track_element))
self.assertTrue(
effect_info.good_for_track_element(video_track_element))
def test_asset_added(self):
uris = [common.get_sample_uri("tears_of_steel.webm")]
mainloop = common.create_main_loop()
def loaded_cb(unused_project, unused_timeline):
self.project.addUris(uris)
self.project.connect_after("loaded", loaded_cb)
def progress_cb(unused_project, progress, unused_estimated_time):
if progress == 100:
mainloop.quit()
self.project.connect_after("asset-loading-progress", progress_cb)
mainloop.run()
self.assertTrue(self.action_log.has_assets_operations())
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
self.action_log.undo()
self.assertFalse(self.action_log.has_assets_operations())
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 0)
self.action_log.redo()
self.assertTrue(self.action_log.has_assets_operations())
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
def test_asset_added_signal(self):
app = common.create_pitivi()
self.assertTrue(app.project_manager.newBlankProject())
project = app.project_manager.current_project
proxy_manager = app.proxy_manager
mainloop = common.create_main_loop()
def asset_added_cb(project, asset, assets):
assets.append(asset)
assets = []
project.connect("asset-added", asset_added_cb, assets)
def proxy_ready_cb(unused_proxy_manager, asset, proxy):
mainloop.quit()
proxy_manager.connect("proxy-ready", proxy_ready_cb)
uris = [common.get_sample_uri("tears_of_steel.webm")]
project.addUris(uris)
mainloop.run()
self.assertEqual(len(assets), 1, assets)
def test_select_missing_asset(self):
"""Exercise the MissingAssetDialog when loading a project."""
app = common.create_pitivi(proxyingStrategy=ProxyingStrategy.NOTHING,
FCpreviewWidth=640,
FCpreviewHeight=480)
proj_uri = self.create_project_file_from_xges(
app, """<ges version='0.3'>
<project properties='properties;' metadatas='metadatas;'>
<ressources>
<asset id='file://this/is/a/moved/asset.mp4' extractable-type-name='GESUriClip'
properties='properties, supported-formats=(int)6, duration=(guint64)1228000000;' metadatas='metadatas' />
</ressources>
</project>
</ges>""")
project_manager = app.project_manager
# Use a cloned sample so the asset is not in GES's asset cache.
# This combination of calls can lead to a mainloop freeze:
# - MissingAssetDialog.get_new_uri() through the "missing-uri" signal handler,
# - MissingAssetDialog.run() through MissingAssetDialog.get_new_uri(),
# - GES.UriClipAsset.request_sync() through PreviewWidget.preview_uri,
with common.cloned_sample("1sec_simpsons_trailer.mp4"):
asset_uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
mainloop = common.create_main_loop()
def missing_uri_cb(project_manager, project, unused_error, asset):
with mock.patch.object(MissingAssetDialog,
"set_transient_for"):
mad = MissingAssetDialog(app, asset, asset.get_id())
mad._chooser.select_uri(asset_uri)
# Close the dialog when idle so get_new_uri does not get stuck.
GLib.idle_add(mad.close)
uri = mad.get_new_uri()
return uri
project_manager.connect("missing-uri", missing_uri_cb)
preview_loaded_for_uri = ""
def preview_uri(preview_widget, uri):
nonlocal preview_loaded_for_uri
original_preview_uri(preview_widget, uri)
# If it gets past the original_preview_uri call, it's all fine!
preview_loaded_for_uri = uri
mainloop.quit()
original_preview_uri = PreviewWidget.preview_uri
PreviewWidget.preview_uri = preview_uri
try:
# Our mainloop timeout mechanism cannot be used,
# because the mainloop gets blocked.
with common.checked_operation_duration(seconds=2):
project_manager.load_project(proj_uri)
mainloop.run()
self.assertEqual(preview_loaded_for_uri, asset_uri)
finally:
PreviewWidget.preview_uri = original_preview_uri
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 addClipsSimple(self, timeline, num_clips):
layer = timeline.ges_timeline.append_layer()
asset = GES.UriClipAsset.request_sync(
common.get_sample_uri("tears_of_steel.webm"))
clips = [layer.add_asset(asset, i * 10, 0, 10, GES.TrackType.UNKNOWN)
for i in range(num_clips)]
self.assertEqual(len(clips), num_clips)
return clips
def add_clip(self, layer, start, inpoint=0, duration=10, clip_type=GES.TrackType.UNKNOWN):
"""Creates a clip on the specified layer."""
asset = GES.UriClipAsset.request_sync(
common.get_sample_uri("tears_of_steel.webm"))
clip = layer.add_asset(asset, start, inpoint, duration, clip_type)
self.assertIsNotNone(clip)
return clip
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_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_ungroup_group_clip(self):
self.setup_timeline_container()
timeline = self.timeline_container.timeline
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
clip = asset.extract()
self.layer.add_clip(clip)
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
timeline.selection.select([clip])
timeline.resetSelectionGroup()
timeline.current_group.add(clip)
self.timeline_container.ungroup_action.activate(None)
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 2, clips)
self.assertEqual(len(clips[0].get_children(False)), 1)
self.assertEqual(len(clips[1].get_children(False)), 1)
timeline.selection.select(clips)
timeline.resetSelectionGroup()
for clip in clips:
timeline.current_group.add(clip)
self.timeline_container.group_action.activate(None)
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
for i in range(2):
# Undo grouping.
self.action_log.undo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 2, clips)
self.assertEqual(len(clips[0].get_children(False)), 1)
self.assertEqual(len(clips[1].get_children(False)), 1)
# Undo ungrouping.
self.action_log.undo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
# Redo ungrouping.
self.action_log.redo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 2, clips)
self.assertEqual(len(clips[0].get_children(False)), 1)
self.assertEqual(len(clips[1].get_children(False)), 1)
# Redo grouping.
self.action_log.redo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
def test_ungroup_group_clip(self):
self.setup_timeline_container()
timeline = self.timeline_container.timeline
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
clip = asset.extract()
self.layer.add_clip(clip)
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
timeline.selection.select([clip])
timeline.resetSelectionGroup()
timeline.current_group.add(clip)
self.timeline_container.ungroup_action.activate(None)
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 2, clips)
self.assertEqual(len(clips[0].get_children(False)), 1)
self.assertEqual(len(clips[1].get_children(False)), 1)
timeline.selection.select(clips)
timeline.resetSelectionGroup()
for clip in clips:
timeline.current_group.add(clip)
self.timeline_container.group_action.activate(None)
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
for i in range(2):
# Undo grouping.
self.action_log.undo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 2, clips)
self.assertEqual(len(clips[0].get_children(False)), 1)
self.assertEqual(len(clips[1].get_children(False)), 1)
# Undo ungrouping.
self.action_log.undo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
# Redo ungrouping.
self.action_log.redo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 2, clips)
self.assertEqual(len(clips[0].get_children(False)), 1)
self.assertEqual(len(clips[1].get_children(False)), 1)
# Redo grouping.
self.action_log.redo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
self.assertEqual(len(clips[0].get_children(False)), 2)
def addClipsSimple(self, timeline, num_clips):
layer = timeline.ges_timeline.append_layer()
asset = GES.UriClipAsset.request_sync(
common.get_sample_uri("tears_of_steel.webm"))
clips = [
layer.add_asset(asset, i * 10, 0, 10, GES.TrackType.UNKNOWN)
for i in range(num_clips)
]
self.assertEqual(len(clips), num_clips)
return clips
def testInitialization(self):
mainloop = common.create_main_loop()
uris = collections.deque([
common.get_sample_uri("flat_colour1_640x480.png"),
common.get_sample_uri("tears_of_steel.webm"),
common.get_sample_uri("1sec_simpsons_trailer.mp4")
])
def loaded_cb(project, timeline):
project.addUris([uris.popleft()])
def progress_cb(project, progress, estimated_time):
if progress == 100:
if uris:
project.addUris([uris.popleft()])
else:
mainloop.quit()
# Create a blank project and add some assets.
project = common.create_project()
self.assertTrue(project._has_default_video_settings)
self.assertTrue(project._has_default_audio_settings)
project.connect_after("loaded", loaded_cb)
project.connect_after("asset-loading-progress", progress_cb)
mainloop.run()
assets = project.list_assets(GES.UriClip)
self.assertEqual(3, len(assets), assets)
self.assertFalse(project._has_default_video_settings)
self.assertFalse(project._has_default_audio_settings)
# The audio settings should match tears_of_steel.webm
self.assertEqual(1, project.audiochannels)
self.assertEqual(44100, project.audiorate)
# The video settings should match tears_of_steel.webm
self.assertEqual(960, project.videowidth)
self.assertEqual(400, project.videoheight)
self.assertEqual(Gst.Fraction(24, 1), project.videorate)
self.assertEqual(Gst.Fraction(1, 1), project.videopar)
def __loading_failure(self, has_proxy):
mainloop = common.create_main_loop()
app = common.create_pitivi_mock(lastProjectFolder="/tmp",
edgeSnapDeadband=32)
app.project_manager = ProjectManager(app)
editorperspective = EditorPerspective(app)
editorperspective.setup_ui()
editorperspective.viewer = mock.MagicMock()
editorperspective.medialibrary._import_warning_infobar = mock.MagicMock(
)
editorperspective.clipconfig.effect_expander._infobar = mock.MagicMock(
)
def __pm_missing_uri_cb(project_manager, project, error, asset):
nonlocal mainloop
nonlocal editorperspective
nonlocal self
nonlocal app
nonlocal has_proxy
with mock.patch.object(MissingAssetDialog,
"__new__") as constructor:
failed_cb = mock.MagicMock()
app.project_manager.connect("new-project-failed", failed_cb)
dialog = constructor.return_value
dialog.get_new_uri.return_value = None
# Call the actual callback
app.proxy_manager.checkProxyLoadingSucceeded = \
mock.MagicMock(return_value=has_proxy)
editorperspective._projectManagerMissingUriCb(
project_manager, project, error, asset)
self.assertTrue(constructor.called)
self.assertTrue(dialog.get_new_uri.called)
self.assertEqual(failed_cb.called, not has_proxy)
app.project_manager.connect(
"missing-uri", editorperspective._projectManagerMissingUriCb)
mainloop.quit()
disconnectAllByFunc(app.project_manager,
editorperspective._projectManagerMissingUriCb)
app.project_manager.connect("missing-uri", __pm_missing_uri_cb)
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
app.project_manager.load_project(uri)
mainloop.run()
def testInitialization(self):
mainloop = common.create_main_loop()
uris = collections.deque([
common.get_sample_uri("flat_colour1_640x480.png"),
common.get_sample_uri("tears_of_steel.webm"),
common.get_sample_uri("1sec_simpsons_trailer.mp4")])
def loaded_cb(project, timeline):
project.addUris([uris.popleft()])
def progress_cb(project, progress, estimated_time):
if progress == 100:
if uris:
project.addUris([uris.popleft()])
else:
mainloop.quit()
# Create a blank project and add some assets.
project = common.create_project()
self.assertTrue(project._has_default_video_settings)
self.assertTrue(project._has_default_audio_settings)
project.connect_after("loaded", loaded_cb)
project.connect_after("asset-loading-progress", progress_cb)
mainloop.run()
assets = project.list_assets(GES.UriClip)
self.assertEqual(3, len(assets), assets)
self.assertFalse(project._has_default_video_settings)
self.assertFalse(project._has_default_audio_settings)
# The audio settings should match tears_of_steel.webm
self.assertEqual(1, project.audiochannels)
self.assertEqual(44100, project.audiorate)
# The video settings should match tears_of_steel.webm
self.assertEqual(960, project.videowidth)
self.assertEqual(400, project.videoheight)
self.assertEqual(Gst.Fraction(24, 1), project.videorate)
self.assertEqual(Gst.Fraction(1, 1), project.videopar)
def test_adding_overlap_clip(self):
"""Checks asset drag&drop on top of an existing clip."""
asset = GES.UriClipAsset.request_sync(
common.get_sample_uri("tears_of_steel.webm"))
layer, = self.ges_timeline.get_layers()
layer.add_asset(asset, 0, 0, 10, GES.TrackType.UNKNOWN)
clips = layer.get_clips()
self.check_drag_assets_to_timeline(self.ges_timeline.ui, [asset])
self.assertEqual(layer.get_clips(), clips)
def test_use_proxy(self):
# Import an asset.
uris = [common.get_sample_uri("tears_of_steel.webm")]
mainloop = common.create_main_loop()
def loaded_cb(unused_project, unused_timeline):
# The new project has been loaded, add some assets.
self.project.addUris(uris)
self.project.connect_after("loaded", loaded_cb)
def progress_cb(unused_project, progress, unused_estimated_time):
if progress == 100:
# The assets have been loaded.
mainloop.quit()
self.project.connect_after("asset-loading-progress", progress_cb)
mainloop.run()
self.project.disconnect_by_func(progress_cb)
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
# Make sure the asset is not a proxy.
assets = [GES.UriClipAsset.request_sync(uri) for uri in uris]
for asset in assets:
self.assertIsNone(asset.get_proxy_target(), "Asset is proxy")
# Use proxy instead of the asset.
mainloop = common.create_main_loop()
def error_cb(proxy_manager, asset, proxy, error):
self.fail("Failed to create proxy: %s" % error)
self.app.proxy_manager.connect("error-preparing-asset", error_cb)
def proxy_ready_cb(proxy_manager, asset, proxy):
mainloop.quit()
self.app.proxy_manager.connect("proxy-ready", proxy_ready_cb)
self.project.use_proxies_for_assets(assets)
mainloop.run()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 2)
# Undo proxying.
self.action_log.undo()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
# Redo proxying.
self.action_log.redo()
# Wait for the proxy to be signalled as ready.
mainloop.run()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 2)
def test_thumb_interval(self):
"""Checks the `thumb_interval` property."""
ges_elem = mock.Mock()
ges_elem.props.uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
ges_elem.props.id = common.get_sample_uri("1sec_simpsons_trailer.mp4")
previewer = VideoPreviewer(ges_elem, 94)
previewer.thumb_width = 1 # Just so it's not None.
def run_thumb_interval(interval):
"""Runs thumb_interval."""
with mock.patch("pitivi.utils.timeline.Zoomable.pixelToNs") as pixel_to_ns:
pixel_to_ns.return_value = interval
return previewer.thumb_interval
self.assertEqual(run_thumb_interval(1), THUMB_PERIOD)
self.assertEqual(run_thumb_interval(THUMB_PERIOD - 1), THUMB_PERIOD)
self.assertEqual(run_thumb_interval(THUMB_PERIOD), THUMB_PERIOD)
self.assertEqual(run_thumb_interval(THUMB_PERIOD + 1), 2 * THUMB_PERIOD)
self.assertEqual(run_thumb_interval(2 * THUMB_PERIOD - 1), 2 * THUMB_PERIOD)
self.assertEqual(run_thumb_interval(2 * THUMB_PERIOD), 2 * THUMB_PERIOD)
def test_get(self):
with self.assertRaises(ValueError):
ThumbnailCache.get(1)
with mock.patch("pitivi.timeline.previewers.xdg_cache_home") as xdg_config_home,\
tempfile.TemporaryDirectory() as temp_dir:
xdg_config_home.return_value = temp_dir
sample_uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
cache = ThumbnailCache.get(sample_uri)
self.assertIsNotNone(cache)
asset = GES.UriClipAsset.request_sync(sample_uri)
self.assertEqual(ThumbnailCache.get(asset), cache)
def test_get(self):
with self.assertRaises(ValueError):
ThumbnailCache.get(1)
with mock.patch("pitivi.timeline.previewers.xdg_cache_home") as xdg_config_home,\
tempfile.TemporaryDirectory() as temp_dir:
xdg_config_home.return_value = temp_dir
sample_uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
cache = ThumbnailCache.get(sample_uri)
self.assertIsNotNone(cache)
asset = GES.UriClipAsset.request_sync(sample_uri)
self.assertEqual(ThumbnailCache.get(asset), cache)
def __loading_failure(self, has_proxy):
mainloop = common.create_main_loop()
app = common.create_pitivi_mock(lastProjectFolder="/tmp",
edgeSnapDeadband=32)
app.project_manager = ProjectManager(app)
editorperspective = EditorPerspective(app)
editorperspective.setup_ui()
editorperspective.viewer = mock.MagicMock()
editorperspective.medialibrary._import_warning_infobar = mock.MagicMock()
editorperspective.clipconfig.effect_expander._infobar = mock.MagicMock()
def __pm_missing_uri_cb(project_manager, project, error, asset):
nonlocal mainloop
nonlocal editorperspective
nonlocal self
nonlocal app
nonlocal has_proxy
with mock.patch.object(MissingAssetDialog, "__new__") as constructor:
failed_cb = mock.MagicMock()
app.project_manager.connect("new-project-failed", failed_cb)
dialog = constructor.return_value
dialog.get_new_uri.return_value = None
# Call the actual callback
app.proxy_manager.checkProxyLoadingSucceeded = \
mock.MagicMock(return_value=has_proxy)
editorperspective._projectManagerMissingUriCb(
project_manager, project, error, asset)
self.assertTrue(constructor.called)
self.assertTrue(dialog.get_new_uri.called)
self.assertEqual(failed_cb.called, not has_proxy)
app.project_manager.connect("missing-uri",
editorperspective._projectManagerMissingUriCb)
mainloop.quit()
disconnectAllByFunc(app.project_manager,
editorperspective._projectManagerMissingUriCb)
app.project_manager.connect("missing-uri", __pm_missing_uri_cb)
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
app.project_manager.load_project(uri)
mainloop.run()
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 test_waveform_creation(self):
"""Checks the waveform generation."""
sample_name = "1sec_simpsons_trailer.mp4"
self.runCheckImport([sample_name])
sample_uri = common.get_sample_uri(sample_name)
wavefile = get_wavefile_location_for_uri(sample_uri)
self.assertTrue(os.path.exists(wavefile), wavefile)
with open(wavefile, "rb") as fsamples:
samples = list(numpy.load(fsamples))
self.assertEqual(samples, SIMPSON_WAVFORM_VALUES)
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 test_image_size(self):
"""Checks the `image_size` property."""
with tempfile.TemporaryDirectory() as tmpdirname:
with mock.patch("pitivi.timeline.previewers.xdg_cache_home") as xdg_cache_home:
xdg_cache_home.return_value = tmpdirname
sample_uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
thumb_cache = ThumbnailCache(sample_uri)
self.assertEqual(thumb_cache.image_size, (0, 0))
pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB,
False, 8, 20, 10)
thumb_cache[0] = pixbuf
self.assertEqual(thumb_cache.image_size, (20, 10))
def test_use_proxy(self):
# Import an asset.
uris = [common.get_sample_uri("tears_of_steel.webm")]
mainloop = common.create_main_loop()
def loaded_cb(unused_project, unused_timeline):
# The new project has been loaded, add some assets.
self.project.addUris(uris)
self.project.connect_after("loaded", loaded_cb)
def progress_cb(unused_project, progress, unused_estimated_time):
if progress == 100:
# The assets have been loaded.
mainloop.quit()
self.project.connect_after("asset-loading-progress", progress_cb)
mainloop.run()
self.project.disconnect_by_func(progress_cb)
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
# Make sure the asset is not a proxy.
assets = [GES.UriClipAsset.request_sync(uri) for uri in uris]
for asset in assets:
self.assertIsNone(asset.get_proxy_target(), "Asset is proxy")
# Use proxy instead of the asset.
mainloop = common.create_main_loop()
def error_cb(proxy_manager, asset, proxy, error):
self.fail("Failed to create proxy: %s" % error)
self.app.proxy_manager.connect("error-preparing-asset", error_cb)
def proxy_ready_cb(proxy_manager, asset, proxy):
mainloop.quit()
self.app.proxy_manager.connect("proxy-ready", proxy_ready_cb)
self.project.use_proxies_for_assets(assets)
mainloop.run()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 2)
# Undo proxying.
self.action_log.undo()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
# Redo proxying.
self.action_log.redo()
# Wait for the proxy to be signalled as ready.
mainloop.run()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 2)
def test_image_size(self):
"""Checks the `image_size` property."""
with tempfile.TemporaryDirectory() as tmpdirname:
with mock.patch("pitivi.timeline.previewers.xdg_cache_home"
) as xdg_cache_home:
xdg_cache_home.return_value = tmpdirname
sample_uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
thumb_cache = ThumbnailCache(sample_uri)
self.assertEqual(thumb_cache.image_size, (None, None))
pixbuf = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, False,
8, 20, 10)
thumb_cache[0] = pixbuf
self.assertEqual(thumb_cache.image_size, (20, 10))
def test_waveform_creation(self):
"""Checks the waveform generation."""
sample_name = "1sec_simpsons_trailer.mp4"
with common.cloned_sample(sample_name):
self.check_import([sample_name])
sample_uri = common.get_sample_uri(sample_name)
wavefile = get_wavefile_location_for_uri(sample_uri)
self.assertTrue(os.path.exists(wavefile), wavefile)
with open(wavefile, "rb") as fsamples:
samples = list(numpy.load(fsamples))
self.assertEqual(samples, SIMPSON_WAVFORM_VALUES)
def stopUsingProxies(self, delete_proxies=False):
sample_name = "30fps_numeroted_frames_red.mkv"
self.runCheckImport([sample_name])
asset_uri = common.get_sample_uri(sample_name)
proxy = self.medialibrary.storemodel[0][medialibrary.COL_ASSET]
self.assertEqual(proxy.props.proxy_target.props.id, asset_uri)
self.app.project_manager.current_project.disableProxiesForAssets(
[proxy], delete_proxies)
self.assertEqual(len(self.medialibrary.storemodel),
len(self.samples))
self.assertEqual(self.medialibrary.storemodel[0][medialibrary.COL_URI],
asset_uri)
def test_group_ungroup_clips(self):
self.setup_timeline_container()
clip1 = common.create_test_clip(GES.TitleClip)
clip1.set_start(0 * Gst.SECOND)
clip1.set_duration(1 * Gst.SECOND)
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
clip2 = asset.extract()
clip2.props.start = 1 * Gst.SECOND
self.assertTrue(self.layer.add_clip(clip1))
self.assertTrue(self.layer.add_clip(clip2))
# The selection does not care about GES.Groups, only about GES.Clips.
self.timeline_container.timeline.selection.select([clip1, clip2])
self.assertEqual(clip1.props.timeline, self.layer.get_timeline())
self.assertEqual(clip2.props.timeline, self.layer.get_timeline())
self.timeline_container.group_action.activate(None)
self.assertTrue(isinstance(clip1.get_parent(), GES.Group))
self.assertEqual(clip1.get_parent(), clip2.get_parent())
self.timeline_container.ungroup_action.activate(None)
self.assertIsNone(clip1.get_parent())
self.assertIsNone(clip2.get_parent())
for i in range(4):
# Undo ungrouping.
self.action_log.undo()
self.assertTrue(isinstance(clip1.get_parent(), GES.Group))
self.assertEqual(clip1.get_parent(), clip2.get_parent())
# Undo grouping.
self.action_log.undo()
self.assertIsNone(clip1.get_parent())
self.assertIsNone(clip2.get_parent())
# Redo grouping.
self.action_log.redo()
self.assertTrue(isinstance(clip1.get_parent(), GES.Group))
self.assertEqual(clip1.get_parent(), clip2.get_parent())
# Redo ungrouping.
self.action_log.redo()
self.assertIsNone(clip1.get_parent())
self.assertIsNone(clip2.get_parent())
def testLoaded(self):
mainloop = common.create_main_loop()
def new_project_loaded_cb(project_manager, project):
mainloop.quit()
self.manager.connect("new-project-loaded", new_project_loaded_cb)
asset_uri = common.get_sample_uri("flat_colour1_640x480.png")
with common.created_project_file(asset_uri=asset_uri) as uri:
self.assertTrue(self.manager.loadProject(uri))
mainloop.run()
project = self.manager.current_project
self.assertFalse(project.at_least_one_asset_missing)
self.assertTrue(project.loaded)
self.assertFalse(project.hasUnsavedModifications())
def testMissingUriForwarded(self):
self.setupApp(app=common.create_pitivi_mock())
mainloop = common.create_main_loop()
def missingUriCb(self, project, error, clip_asset, result):
result[0] = True
mainloop.quit()
result = [False]
self.manager.connect("missing-uri", missingUriCb, result)
with common.cloned_sample():
asset_uri = common.get_sample_uri("missing.png")
with common.created_project_file(asset_uri) as uri:
self.assertIsNotNone(self.manager.load_project(uri))
mainloop.run()
self.assertTrue(result[0], "missing-uri has not been emitted")
def stop_using_proxies(self, delete_proxies=False):
sample_name = "30fps_numeroted_frames_red.mkv"
self.check_import([sample_name])
asset_uri = common.get_sample_uri(sample_name)
proxy = self.medialibrary.storemodel[0][medialibrary.COL_ASSET]
self.assertEqual(proxy.props.proxy_target.props.id, asset_uri)
project = self.app.project_manager.current_project
self.assertIn(proxy, project.list_assets(GES.UriClip))
project.disable_proxies_for_assets([proxy], delete_proxies)
self.assertNotIn(proxy, project.list_assets(GES.UriClip))
self.assertEqual(len(self.medialibrary.storemodel),
len(self.samples))
self.assertEqual(self.medialibrary.storemodel[0][medialibrary.COL_URI],
asset_uri)
def test_use_proxy(self):
# Import an asset.
uris = [common.get_sample_uri("tears_of_steel.webm")]
mainloop = common.create_main_loop()
def commit_cb(unused_action_log, stack):
self.assertEqual(stack.action_group_name, "Adding assets")
mainloop.quit()
self.action_log.connect("commit", commit_cb)
def loaded_cb(unused_project, unused_timeline):
self.project.addUris(uris)
self.project.connect_after("loaded", loaded_cb)
mainloop.run()
self.action_log.disconnect_by_func(commit_cb)
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
# Make sure the asset is not a proxy.
assets = [GES.UriClipAsset.request_sync(uri) for uri in uris]
for asset in assets:
self.assertIsNone(asset.get_proxy_target(), "Asset is proxy")
# Use proxy instead of the asset.
mainloop = common.create_main_loop()
def error_cb(proxy_manager, asset, proxy, error):
self.fail("Failed to create proxy: %s" % error)
self.app.proxy_manager.connect("error-preparing-asset", error_cb)
def proxy_ready_cb(proxy_manager, asset, proxy):
uris.remove(asset.props.id)
if not uris:
mainloop.quit()
self.app.proxy_manager.connect("proxy-ready", proxy_ready_cb)
self.project.useProxiesForAssets(assets)
mainloop.run()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 2)
self.action_log.undo()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 1)
self.action_log.redo()
self.assertEqual(len(self.project.list_assets(GES.Extractable)), 2)
def test_load_project_with_missing_proxy_progress_tracking(self):
"""Checks progress tracking of loading project with missing proxies."""
from gi.repository import GstTranscoder
# Disable proxy generation by not making it start ever.
# This way we are sure it will not finish before we test
# the state while it is being rebuilt.
with mock.patch.object(GstTranscoder.Transcoder, "run_async"):
mainloop, app, medialib, proxy_uri = self.load_project_with_missing_proxy()
uri = common.get_sample_uri("1sec_simpsons_trailer.mp4")
app.project_manager.connect("new-project-loaded", lambda x, y: mainloop.quit())
mainloop.run()
self.assertEqual(len(medialib.storemodel), 1)
self.assertEqual(medialib.storemodel[0][medialibrary.COL_ASSET].props.id,
uri)
self.assertEqual(medialib.storemodel[0][medialibrary.COL_THUMB_DECORATOR].state,
medialibrary.AssetThumbnail.IN_PROGRESS)
def testWaveFormAndThumbnailCreated(self):
sample_name = "1sec_simpsons_trailer.mp4"
self.runCheckImport([sample_name])
sample_uri = common.get_sample_uri(sample_name)
asset = GES.UriClipAsset.request_sync(sample_uri)
thumb_cache = getThumbnailCache(asset)
width, height = thumb_cache.getImagesSize()
self.assertEqual(height, THUMB_HEIGHT)
self.assertTrue(thumb_cache[0] is not None)
self.assertTrue(thumb_cache[Gst.SECOND / 2] is not None)
wavefile = get_wavefile_location_for_uri(sample_uri)
self.assertTrue(os.path.exists(wavefile), wavefile)
with open(wavefile, "rb") as fsamples:
samples = pickle.load(fsamples)
self.assertTrue(bool(samples))
def test_insert_on_first_layer(self):
self.setup_timeline_container()
uri = common.get_sample_uri("tears_of_steel.webm")
asset = GES.UriClipAsset.request_sync(uri)
clip1 = asset.extract()
self.timeline_container.insert_clips_on_first_layer(clips=[clip1], position=0)
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
# Undo insert on first layer
self.action_log.undo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 0, clips)
# Redo insert on first layer
self.action_log.redo()
clips = list(self.getTimelineClips())
self.assertEqual(len(clips), 1, clips)
# Insert new clip to create a layer
clip2 = common.create_test_clip(GES.TitleClip)
clip2.set_start(0 * Gst.SECOND)
clip2.set_duration(1 * Gst.SECOND)
self.timeline_container.insert_clips_on_first_layer(clips=[clip2], position=0)
layers = self.timeline.get_layers()
self.check_layers([layers[0], self.layer])
self.assertEqual(layers[0].get_clips(), [clip2])
self.assertEqual(layers[1].get_clips(), [clip1])
# Undo insert to create a layer
self.action_log.undo()
layers = self.timeline.get_layers()
self.check_layers([self.layer])
self.assertEqual(layers[0].get_clips(), [clip1])
# Redo insert to create a layer
self.action_log.redo()
layers = self.timeline.get_layers()
self.check_layers([layers[0], self.layer])
self.assertEqual(layers[0].get_clips(), [clip2])
self.assertEqual(layers[1].get_clips(), [clip1])
