Updating rescale_keyframes() method to not modify the current project. This allows the Export dialog to make a copy of the rescaled keyframes, and not modify the active project when exporting to a different FPS. Now Export feels much safer, because it doesn't modify project data.

Author: jonoomph

src/classes/project_data.py

@@ -399,12 +399,17 @@ def scale_keyframe_value(self, original_value, scale_factor):
             return round(original_value * scale_factor)
 
     def rescale_keyframes(self, scale_factor):
-        """Adjust all keyframe coordinates from previous FPS to new FPS (using a scale factor)"""
+        """Adjust all keyframe coordinates from previous FPS to new FPS (using a scale factor)
+           and return scaled project data without modifing the current project."""
         log.info('Scale all keyframes by a factor of %s' % scale_factor)
 
+        # Create copy of active project data
+        data = copy.deepcopy(self._data)
+
+        # Rescale the the copied project data
         # Loop through all clips (and look for Keyframe objects)
         # Scale the X coordinate by factor (which represents the frame #)
-        for clip in self._data.get('clips', []):
+        for clip in data.get('clips', []):
             for attribute in clip:
                 if type(clip.get(attribute)) == dict and "Points" in clip.get(attribute):
                     for point in clip.get(attribute).get("Points"):
@@ -429,7 +434,7 @@ def rescale_keyframes(self, scale_factor):
 
         # Loop through all effects/transitions (and look for Keyframe objects)
         # Scale the X coordinate by factor (which represents the frame #)
-        for effect in self._data.get('effects', []):
+        for effect in data.get('effects', []):
             for attribute in effect:
                 if type(effect.get(attribute)) == dict and "Points" in effect.get(attribute):
                     for point in effect.get(attribute).get("Points"):
@@ -441,9 +446,8 @@ def rescale_keyframes(self, scale_factor):
                             if "co" in point:
                                 point["co"]["X"] = self.scale_keyframe_value(point["co"].get("X", 0.0), scale_factor)
 
-        # Get app, and distribute all project data through update manager
-        from classes.app import get_app
-        get_app().updates.load(self._data)
+        # return the copied and scaled project data
+        return data
 
     def read_legacy_project_file(self, file_path):
         """Attempt to read a legacy version 1.x openshot project file"""

src/windows/export.py

@@ -61,8 +61,7 @@ def __init__(self):
         ui_util.init_ui(self)
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # Get settings
         self.s = settings.get_settings()
@@ -92,10 +91,10 @@ def __init__(self):
         self.delayed_fps_timer.stop()
 
         # Pause playback (to prevent crash since we are fixing to change the timeline's max size)
-        app.window.actionPlay_trigger(None, force="pause")
+        get_app().window.actionPlay_trigger(None, force="pause")
 
         # Clear timeline preview cache (to get more available memory)
-        app.window.timeline_sync.timeline.ClearAllCache()
+        get_app().window.timeline_sync.timeline.ClearAllCache()
 
         # Hide audio channels
         self.lblChannels.setVisible(False)
@@ -106,41 +105,38 @@ def __init__(self):
         openshot.Settings.Instance().HIGH_QUALITY_SCALING = True
 
         # Get the original timeline settings
-        width = app.window.timeline_sync.timeline.info.width
-        height = app.window.timeline_sync.timeline.info.height
-        fps = app.window.timeline_sync.timeline.info.fps
-        sample_rate = app.window.timeline_sync.timeline.info.sample_rate
-        channels = app.window.timeline_sync.timeline.info.channels
-        channel_layout = app.window.timeline_sync.timeline.info.channel_layout
-
-        # No keyframe rescaling has happened yet (due to differences in FPS)
-        self.keyframes_rescaled = False
+        width = get_app().window.timeline_sync.timeline.info.width
+        height = get_app().window.timeline_sync.timeline.info.height
+        fps = get_app().window.timeline_sync.timeline.info.fps
+        sample_rate = get_app().window.timeline_sync.timeline.info.sample_rate
+        channels = get_app().window.timeline_sync.timeline.info.channels
+        channel_layout = get_app().window.timeline_sync.timeline.info.channel_layout
 
         # Create new "export" openshot.Timeline object
         self.timeline = openshot.Timeline(width, height, openshot.Fraction(fps.num, fps.den),
                                           sample_rate, channels, channel_layout)
         # Init various properties
-        self.timeline.info.channel_layout = app.window.timeline_sync.timeline.info.channel_layout
-        self.timeline.info.has_audio = app.window.timeline_sync.timeline.info.has_audio
-        self.timeline.info.has_video = app.window.timeline_sync.timeline.info.has_video
-        self.timeline.info.video_length = app.window.timeline_sync.timeline.info.video_length
-        self.timeline.info.duration = app.window.timeline_sync.timeline.info.duration
-        self.timeline.info.sample_rate = app.window.timeline_sync.timeline.info.sample_rate
-        self.timeline.info.channels = app.window.timeline_sync.timeline.info.channels
+        self.timeline.info.channel_layout = get_app().window.timeline_sync.timeline.info.channel_layout
+        self.timeline.info.has_audio = get_app().window.timeline_sync.timeline.info.has_audio
+        self.timeline.info.has_video = get_app().window.timeline_sync.timeline.info.has_video
+        self.timeline.info.video_length = get_app().window.timeline_sync.timeline.info.video_length
+        self.timeline.info.duration = get_app().window.timeline_sync.timeline.info.duration
+        self.timeline.info.sample_rate = get_app().window.timeline_sync.timeline.info.sample_rate
+        self.timeline.info.channels = get_app().window.timeline_sync.timeline.info.channels
 
         # Load the "export" Timeline reader with the JSON from the real timeline
-        json_timeline = json.dumps(app.project._data)
+        json_timeline = json.dumps(get_app().project._data)
         self.timeline.SetJson(json_timeline)
 
         # Open the "export" Timeline reader
         self.timeline.Open()
 
         # Default export path
         recommended_path = os.path.join(info.HOME_PATH)
-        if app.project.current_filepath:
-            recommended_path = os.path.dirname(app.project.current_filepath)
+        if get_app().project.current_filepath:
+            recommended_path = os.path.dirname(get_app().project.current_filepath)
 
-        export_path = app.project.get("export_path")
+        export_path = get_app().project.get("export_path")
         if export_path and os.path.exists(export_path):
             # Use last selected export path
             self.txtExportFolder.setText(export_path)
@@ -149,13 +145,13 @@ def __init__(self):
             self.txtExportFolder.setText(recommended_path)
 
         # Is this a saved project?
-        if not app.project.current_filepath:
+        if not get_app().project.current_filepath:
             # Not saved yet
             self.txtFileName.setText(_("Untitled Project"))
         else:
             # Yes, project is saved
             # Get just the filename
-            filename = os.path.basename(app.project.current_filepath)
+            filename = os.path.basename(get_app().project.current_filepath)
             filename = os.path.splitext(filename)[0]
             self.txtFileName.setText(filename)
 
@@ -191,7 +187,7 @@ def __init__(self):
         self.cboSimpleQuality.currentIndexChanged.connect(
             functools.partial(self.cboSimpleQuality_index_changed, self.cboSimpleQuality))
         self.cboChannelLayout.currentIndexChanged.connect(self.updateChannels)
-        app.window.ExportFrame.connect(self.updateProgressBar)
+        get_app().window.ExportFrame.connect(self.updateProgressBar)
 
         # ********* Advanced Profile List **********
         # Loop through profiles
@@ -220,7 +216,7 @@ def __init__(self):
             self.cboProfile.addItem(self.getProfileName(self.getProfilePath(profile_name)), self.getProfilePath(profile_name))
 
             # Set default (if it matches the project)
-            if app.project.get(['profile']) in profile_name:
+            if get_app().project.get(['profile']) in profile_name:
                 self.selected_profile_index = box_index
 
             # increment item counter
@@ -251,7 +247,7 @@ def __init__(self):
 
 
         # Populate all profiles
-        self.populateAllProfiles(app.project.get(['profile']))
+        self.populateAllProfiles(get_app().project.get(['profile']))
 
         # Connect framerate signals
         self.txtFrameRateNum.valueChanged.connect(self.updateFrameRate)
@@ -368,8 +364,7 @@ def cboSimpleProjectType_index_changed(self, widget, index):
         self.cboSimpleTarget.clear()
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # parse the xml files and get targets that match the project type
         project_types = []
@@ -424,8 +419,7 @@ def cboProfile_index_changed(self, widget, index):
         log.info(selected_profile_path)
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # Load profile
         profile = openshot.Profile(selected_profile_path)
@@ -454,8 +448,7 @@ def cboSimpleTarget_index_changed(self, widget, index):
         log.info(selected_target)
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # don't do anything if the combo has been cleared
         if selected_target:
@@ -594,8 +587,7 @@ def cboSimpleQuality_index_changed(self, widget, index):
         log.info(selected_quality)
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # Set the video and audio bitrates
         if selected_quality:
@@ -606,8 +598,7 @@ def btnBrowse_clicked(self):
         log.info("btnBrowse_clicked")
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # update export folder path
         file_path = QFileDialog.getExistingDirectory(self, _("Choose a Folder..."), self.txtExportFolder.text())
@@ -677,8 +668,7 @@ def accept(self):
         """ Start exporting video """
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # Init progress bar
         self.progressExportVideo.setMinimum(self.txtStartFrame.value())
@@ -782,9 +772,9 @@ def accept(self):
                 video_settings["vcodec"] = image_ext
 
         # Store updated export folder path in project file
-        app.updates.update_untracked(["export_path"], os.path.dirname(export_file_path))
+        get_app().updates.update_untracked(["export_path"], os.path.dirname(export_file_path))
         # Mark project file as unsaved
-        app.project.has_unsaved_changes = True
+        get_app().project.has_unsaved_changes = True
 
         # Set MaxSize (so we don't have any downsampling)
         self.timeline.SetMaxSize(video_settings.get("width"), video_settings.get("height"))
@@ -793,14 +783,13 @@ def accept(self):
         export_cache_object = openshot.CacheMemory(500)
         self.timeline.SetCache(export_cache_object)
 
-        # Rescale all keyframes and reload project
+        # Rescale all keyframes (if needed)
         if self.export_fps_factor != 1.0:
-            self.keyframes_rescaled = True
-            app.project.rescale_keyframes(self.export_fps_factor)
+            # Get a copy of rescaled project data (this does not modify the active project)
+            rescaled_app_data = get_app().project.rescale_keyframes(self.export_fps_factor)
 
             # Load the "export" Timeline reader with the JSON from the real timeline
-            json_timeline = json.dumps(app.project._data)
-            self.timeline.SetJson(json_timeline)
+            self.timeline.SetJson(json.dumps(rescaled_app_data))
 
             # Re-update the timeline FPS again (since the timeline just got clobbered)
             self.updateFrameRate()
@@ -853,7 +842,7 @@ def accept(self):
 
             # Notify window of export started
             title_message = ""
-            app.window.ExportStarted.emit(export_file_path, video_settings.get("start_frame"), video_settings.get("end_frame"))
+            get_app().window.ExportStarted.emit(export_file_path, video_settings.get("start_frame"), video_settings.get("end_frame"))
 
             progressstep = max(1 , round(( video_settings.get("end_frame") - video_settings.get("start_frame") ) / 1000))
             start_time_export = time.time()
@@ -874,7 +863,7 @@ def accept(self):
                             'fps': fps_encode}
 
                     # Emit frame exported
-                    app.window.ExportFrame.emit(title_message, video_settings.get("start_frame"), video_settings.get("end_frame"), frame)
+                    get_app().window.ExportFrame.emit(title_message, video_settings.get("start_frame"), video_settings.get("end_frame"), frame)
 
                     # Process events (to show the progress bar moving)
                     QCoreApplication.processEvents()
@@ -897,7 +886,7 @@ def accept(self):
                 'seconds': seconds_run % 60,
                 'fps': fps_encode}
 
-            app.window.ExportFrame.emit(title_message, video_settings.get("start_frame"),
+            get_app().window.ExportFrame.emit(title_message, video_settings.get("start_frame"),
                                               video_settings.get("end_frame"), frame)
 
         except Exception as e:
@@ -936,7 +925,7 @@ def accept(self):
             msg.exec_()
 
         # Notify window of export started
-        app.window.ExportEnded.emit(export_file_path)
+        get_app().window.ExportEnded.emit(export_file_path)
 
         # Close timeline object
         self.timeline.Close()
@@ -986,10 +975,6 @@ def reject(self):
         # Return scale mode to lower quality scaling (for faster previews)
         openshot.Settings.Instance().HIGH_QUALITY_SCALING = False
 
-        # Return keyframes to preview scaling
-        if self.keyframes_rescaled:
-            get_app().project.rescale_keyframes(self.original_fps_factor)
-
         # Cancel dialog
         self.exporting = False
         super(Export, self).reject()

src/windows/profile.py

@@ -56,11 +56,10 @@ def __init__(self):
         ui_util.init_ui(self)
 
         # get translations
-        app = get_app()
-        _ = app._tr
+        _ = get_app()._tr
 
         # Pause playback (to prevent crash since we are fixing to change the timeline's max size)
-        app.window.actionPlay_trigger(None, force="pause")
+        get_app().window.actionPlay_trigger(None, force="pause")
 
         # Track metrics
         track_metric_screen("profile-screen")
@@ -93,7 +92,7 @@ def __init__(self):
             self.cboProfile.addItem(profile_name, self.profile_paths[profile_name])
 
             # Set default (if it matches the project)
-            if app.project.get(['profile']) in profile_name:
+            if get_app().project.get(['profile']) in profile_name:
                 self.initial_index = box_index
 
             # increment item counter
@@ -145,7 +144,14 @@ def dropdown_activated(self, index):
 
         # Rescale all keyframes and reload project
         if fps_factor != 1.0:
-            get_app().project.rescale_keyframes(fps_factor)
+            # Get a copy of rescaled project data (this does not modify the active project... yet)
+            rescaled_app_data = get_app().project.rescale_keyframes(fps_factor)
+
+            # Apply rescaled data to active project
+            get_app().project._data = rescaled_app_data
+
+            # Distribute all project data through update manager
+            get_app().updates.load(rescaled_app_data)
 
         # Force ApplyMapperToClips to apply these changes
         get_app().window.timeline_sync.timeline.ApplyMapperToClips()