def __init__(self, timeline, parent=None):
QWidget.__init__(self, parent)
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Setup video preview QWidget
self.videoPreview = VideoWidget(self)
self.layout.addWidget(self.videoPreview)
# Set max size of video preview (for speed)
viewport_rect = self.videoPreview.centeredViewport(self.videoPreview.width(), self.videoPreview.height())
timeline.SetMaxSize(viewport_rect.width(), viewport_rect.height())
self.setLayout(self.layout)
self.initialized = False
# Start the preview thread
self.preview_parent = PreviewParent()
self.preview_parent.Init(self, timeline, self.videoPreview)
self.preview_thread = self.preview_parent.worker
# Set pause callback
self.PauseSignal.connect(self.handlePausedVideo)
self.hover = YYPlayerHover(self, self)
def __init__(self):
QWidget.__init__(self)
# Setup video preview QWidget
self.videoPreview = VideoWidget()
#self.layout().insertWidget(0, self.videoPreview)
wlayout = QHBoxLayout()
wlayout.addWidget(self.videoPreview)
self.setLayout(wlayout)
# Start the preview thread
self.preview_parent = PreviewParent(self)
self.preview_parent.MInit(self, self.videoPreview)
self.preview_thread = self.preview_parent.worker
self.setFixedSize(600, 800)
self.initialized = True
def __init__(self, cuts_json, clips_json, preview=False):
_ = get_app()._tr
# Create dialog class
QDialog.__init__(self)
# Load UI from designer
ui_util.load_ui(self, self.ui_path)
# Init UI
ui_util.init_ui(self)
# Track metrics
track_metric_screen("cutting-screen")
# If preview, hide cutting controls
if preview:
self.lblInstructions.setVisible(False)
self.widgetControls.setVisible(False)
self.setWindowTitle(_("Preview"))
self.start_frame = 1
self.start_image = None
self.end_frame = 1
self.end_image = None
project = get_app().project
# Keep track of file object
#self.file = file
self.file_path = file.absolute_path()
self.video_length = int(file.data['video_length'])
self.fps_num = int(file.data['fps']['num'])
self.fps_den = int(file.data['fps']['den'])
self.fps = float(self.fps_num) / float(self.fps_den)
self.width = int(file.data['width'])
self.height = int(file.data['height'])
self.sample_rate = int(file.data['sample_rate'])
self.channels = int(file.data['channels'])
self.channel_layout = int(file.data['channel_layout'])
# Open video file with Reader
log.info(self.file_path)
# Create an instance of a libopenshot Timeline object
self.r = openshot.Timeline(
self.width, self.height,
openshot.Fraction(self.fps_num, self.fps_den), self.sample_rate,
self.channels, self.channel_layout)
self.r.info.channel_layout = self.channel_layout
try:
# Add clip for current preview file
self.clip = openshot.Clip(self.file_path)
# Show waveform for audio files
if not self.clip.Reader().info.has_video and self.clip.Reader(
).info.has_audio:
self.clip.Waveform(True)
# Set has_audio property
self.r.info.has_audio = self.clip.Reader().info.has_audio
if preview:
# Display frame #'s during preview
self.clip.display = openshot.FRAME_DISPLAY_CLIP
self.r.AddClip(self.clip)
except:
log.error('Failed to load media file into preview player: %s' %
self.file_path)
return
# Add Video Widget
self.videoPreview = VideoWidget()
self.videoPreview.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
self.verticalLayout.insertWidget(0, self.videoPreview)
# Set max size of video preview (for speed)
viewport_rect = self.videoPreview.centeredViewport(
self.videoPreview.width(), self.videoPreview.height())
self.r.SetMaxSize(viewport_rect.width(), viewport_rect.height())
# Open reader
self.r.Open()
# Start the preview thread
self.initialized = False
self.transforming_clip = False
self.preview_parent = PreviewParent()
self.preview_parent.Init(self, self.r, self.videoPreview)
self.preview_thread = self.preview_parent.worker
# Set slider constraints
self.sliderIgnoreSignal = False
self.sliderVideo.setMinimum(1)
self.sliderVideo.setMaximum(self.video_length)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setPageStep(24)
# Determine if a start or end attribute is in this file
start_frame = 1
if 'start' in self.file.data.keys():
start_frame = (float(self.file.data['start']) * self.fps) + 1
# Display start frame (and then the previous frame)
QTimer.singleShot(
500, functools.partial(self.sliderVideo.setValue, start_frame + 1))
QTimer.singleShot(
600, functools.partial(self.sliderVideo.setValue, start_frame))
# Connect signals
self.actionPlay.triggered.connect(self.actionPlay_Triggered)
self.btnPlay.clicked.connect(self.btnPlay_clicked)
self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged)
self.btnStart.clicked.connect(self.btnStart_clicked)
self.btnEnd.clicked.connect(self.btnEnd_clicked)
self.btnClear.clicked.connect(self.btnClear_clicked)
self.btnAddClip.clicked.connect(self.btnAddClip_clicked)
self.initialized = True
def __init__(self, file=None):
# Create dialog class
QDialog.__init__(self)
# Load UI from designer
ui_util.load_ui(self, self.ui_path)
# Init UI
ui_util.init_ui(self)
# Track metrics
track_metric_screen("cutting-screen")
self.start_frame = 1
self.start_image = None
self.end_frame = 1
self.end_image = None
# Keep track of file object
self.file = file
self.file_path = file.absolute_path()
self.video_length = int(file.data['video_length'])
self.fps_num = int(file.data['fps']['num'])
self.fps_den = int(file.data['fps']['den'])
self.fps = float(self.fps_num) / float(self.fps_den)
# Open video file with Reader
log.info(self.file_path)
self.r = openshot.FFmpegReader(self.file_path)
self.r.Open()
# Add Video Widget
self.videoPreview = VideoWidget()
self.videoPreview.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
self.verticalLayout.insertWidget(0, self.videoPreview)
# Start the preview thread
self.preview_parent = PreviewParent()
self.preview_parent.Init(self, self.r, self.videoPreview)
self.preview_thread = self.preview_parent.worker
# Set slider constraints
self.sliderIgnoreSignal = False
self.sliderVideo.setMinimum(1)
self.sliderVideo.setMaximum(self.video_length)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setPageStep(24)
# Determine if a start or end attribute is in this file
start_frame = 1
if 'start' in self.file.data.keys():
start_frame = (float(self.file.data['start']) * self.fps) + 1
# Display start frame (and then the previous frame)
QTimer.singleShot(
500, functools.partial(self.sliderVideo.setValue, start_frame + 1))
QTimer.singleShot(
600, functools.partial(self.sliderVideo.setValue, start_frame))
# Connect signals
self.btnPlay.clicked.connect(self.btnPlay_clicked)
self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged)
self.btnStart.clicked.connect(self.btnStart_clicked)
self.btnEnd.clicked.connect(self.btnEnd_clicked)
self.btnClear.clicked.connect(self.btnClear_clicked)
self.btnAddClip.clicked.connect(self.btnAddClip_clicked)
def __init__(self, cuts=[], preview=False):
_ = get_app()._tr
# Create dialog class
QDialog.__init__(self)
# Load UI from designer
ui_util.load_ui(self, self.ui_path)
# Init UI
ui_util.init_ui(self)
# Track metrics
track_metric_screen("cutting-screen")
# If preview, hide cutting controls
if preview:
self.lblInstructions.setVisible(False)
self.widgetControls.setVisible(False)
self.setWindowTitle(_("Preview"))
self.start_frame = 1
self.start_image = None
self.end_frame = 1
self.end_image = None
#timeline = get_app().window.timeline_sync.timeline
#app = get_app()
#project = app.project
# Get some settings from the project
'''
self.fps = project.get(["fps"])
self.width = project.get(["width"])
self.height = project.get(["height"])
self.sample_rate = project.get(["sample_rate"])
self.channels = project.get(["channels"])
self.channel_layout = project.get(["channel_layout"])
self.fps_num = int(self.fps['num'])
self.fps_den = int(self.fps['den'])
self.fps = float(self.fps_num) / float(self.fps_den)
'''
# Get the original timeline settings
self.width = get_app().window.timeline_sync.timeline.info.width
self.height = get_app().window.timeline_sync.timeline.info.height
self.fps = get_app().window.timeline_sync.timeline.info.fps
self.sample_rate = get_app(
).window.timeline_sync.timeline.info.sample_rate
self.channels = get_app().window.timeline_sync.timeline.info.channels
self.channel_layout = get_app(
).window.timeline_sync.timeline.info.channel_layout
self.fps_num = int(self.fps.num)
self.fps_den = int(self.fps.den)
#self.fps = float(self.fps_num) / float(self.fps_den)
'''
# Keep track of file object
self.file = file
self.file_path = file.absolute_path()
self.video_length = 0
self.fps_num = int(file.data['fps']['num'])
self.fps_den = int(file.data['fps']['den'])
self.fps = float(self.fps_num) / float(self.fps_den)
self.width = int(file.data['width'])
self.height = int(file.data['height'])
self.sample_rate = int(file.data['sample_rate'])
self.channels = int(file.data['channels'])
self.channel_layout = int(file.data['channel_layout'])
# Open video file with Reader
log.info(self.file_path)
'''
self.video_length = 0
# Create an instance of a libopenshot Timeline object
self.r = openshot.Timeline(
self.width, self.height,
openshot.Fraction(self.fps_num, self.fps_den), self.sample_rate,
self.channels, self.channel_layout)
self.r.info.channel_layout = self.channel_layout
'''
#cuts = [{"start_seconds":8.466666666666667, "end_seconds":15.3}, {"start_seconds":18.9, "end_seconds":22.133333333333333}]
position = 0
print(cuts)
cs = app.window.timeline_sync.timeline.Clips()
for c in cs:
print("-----id=", c.Id())
clip_json = Clip.filter(id=c.Id())
path = clip_json[0].data["reader"]["path"]
print("==============", path, c.Position())
offset = c.Position()
for cut in cuts:
try:
# Add clip for current preview file
clip = openshot.Clip(path)
self.clips.append(clip)
# Show waveform for audio files
if not clip.Reader().info.has_video and clip.Reader().info.has_audio:
clip.Waveform(True)
# Set has_audio property
self.r.info.has_audio = clip.Reader().info.has_audio
if preview:
# Display frame #'s during preview
clip.display = openshot.FRAME_DISPLAY_CLIP
start = float(cut["start_seconds"] - offset)
end = float(cut["end_seconds"] - offset)
print("=======================-------start:", start, "end:", end)
clip.Start(start)
clip.End(end)
#clip.Position(0)
clip.Position(position)
position = position + (end - start) - offset
#clip.Duration(end-start)
self.r.AddClip(clip)
self.video_length = self.video_length + (end - start)
except:
log.error('Failed to load media file into preview player: %s' % self.file_path)
return
'''
self.clips, self.video_length = CutsToClips(cuts)
for clip in self.clips:
# Show waveform for audio files
if not clip.Reader().info.has_video and clip.Reader(
).info.has_audio:
clip.Waveform(True)
if preview:
# Display frame #'s during preview
clip.display = openshot.FRAME_DISPLAY_CLIP
self.r.AddClip(clip)
#self.video_length = self.video_length * self.fps_num / self.fps_den
# Add Video Widget
self.videoPreview = VideoWidget()
self.videoPreview.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
self.verticalLayout.insertWidget(0, self.videoPreview)
# Set max size of video preview (for speed)
viewport_rect = self.videoPreview.centeredViewport(
self.videoPreview.width(), self.videoPreview.height())
self.r.SetMaxSize(viewport_rect.width(), viewport_rect.height())
# Open reader
self.r.Open()
# Start the preview thread
self.initialized = False
self.transforming_clip = False
self.preview_parent = PreviewParent()
self.preview_parent.Init(self, self.r, self.videoPreview)
self.preview_thread = self.preview_parent.worker
# Set slider constraints
self.sliderIgnoreSignal = False
self.sliderVideo.setMinimum(1)
self.sliderVideo.setMaximum(self.video_length)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setPageStep(24)
# Determine if a start or end attribute is in this file
start_frame = 1
#if 'start' in self.file.data.keys():
# start_frame = (float(self.file.data['start']) * self.fps) + 1
# Display start frame (and then the previous frame)
QTimer.singleShot(
500, functools.partial(self.sliderVideo.setValue, start_frame + 1))
QTimer.singleShot(
600, functools.partial(self.sliderVideo.setValue, start_frame))
# Connect signals
self.actionPlay.triggered.connect(self.actionPlay_Triggered)
self.btnPlay.clicked.connect(self.btnPlay_clicked)
self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged)
self.btnStart.clicked.connect(self.btnStart_clicked)
self.btnEnd.clicked.connect(self.btnEnd_clicked)
self.btnClear.clicked.connect(self.btnClear_clicked)
self.btnAddClip.clicked.connect(self.btnAddClip_clicked)
self.initialized = True
def __init__(self, file=None, clip=None):
_ = get_app()._tr
# Create dialog class
QDialog.__init__(self)
# Load UI from designer
ui_util.load_ui(self, self.ui_path)
# Init UI
ui_util.init_ui(self)
# Track metrics
track_metric_screen("cutting-screen")
self.start_frame = 1
self.start_image = None
self.end_frame = 1
self.end_image = None
self.current_frame = 1
# Create region clip with Reader
self.clip = openshot.Clip(clip.Reader())
self.clip.Open()
# Set region clip start and end
self.clip.Start(clip.Start())
self.clip.End(clip.End())
self.clip.Id(get_app().project.generate_id())
print("IDS {} {}".format(clip.Id(), self.clip.Id()))
# Keep track of file object
self.file = file
self.file_path = file.absolute_path()
c_info = clip.Reader().info
self.fps = c_info.fps.ToInt(
) #float(self.fps_num) / float(self.fps_den)
self.fps_num = self.fps #int(file.data['fps']['num'])
self.fps_den = 1 #int(file.data['fps']['den'])
self.width = c_info.width #int(file.data['width'])
self.height = c_info.height #int(file.data['height'])
self.sample_rate = c_info.sample_rate #int(file.data['sample_rate'])
self.channels = c_info.channels #int(file.data['channels'])
self.channel_layout = c_info.channel_layout #int(file.data['channel_layout'])
self.video_length = int(self.clip.Duration() *
self.fps) + 1 #int(file.data['video_length'])
# Apply effects to region frames
for effect in clip.Effects():
self.clip.AddEffect(effect)
# Open video file with Reader
log.info(self.clip.Reader())
# Add Video Widget
self.videoPreview = VideoWidget()
self.videoPreview.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Expanding)
self.verticalLayout.insertWidget(0, self.videoPreview)
# Set aspect ratio to match source content
aspect_ratio = openshot.Fraction(self.width, self.height)
aspect_ratio.Reduce()
self.videoPreview.aspect_ratio = aspect_ratio
# Set max size of video preview (for speed)
self.viewport_rect = self.videoPreview.centeredViewport(
self.width, self.height)
# Create an instance of a libopenshot Timeline object
self.r = openshot.Timeline(
self.viewport_rect.width(), self.viewport_rect.height(),
openshot.Fraction(self.fps_num, self.fps_den), self.sample_rate,
self.channels, self.channel_layout)
self.r.info.channel_layout = self.channel_layout
self.r.SetMaxSize(self.viewport_rect.width(),
self.viewport_rect.height())
try:
# Add clip for current preview file
self.clip = openshot.Clip(self.file_path)
# Show waveform for audio files
if not self.clip.Reader().info.has_video and self.clip.Reader(
).info.has_audio:
self.clip.Waveform(True)
# Set has_audio property
self.r.info.has_audio = self.clip.Reader().info.has_audio
# Update video_length property of the Timeline object
self.r.info.video_length = self.video_length
self.r.AddClip(self.clip)
except:
log.error(
'Failed to load media file into region select player: %s' %
self.file_path)
return
# Open reader
self.r.Open()
# Start the preview thread
self.initialized = False
self.transforming_clip = False
self.preview_parent = PreviewParent()
self.preview_parent.Init(self, self.r, self.videoPreview)
self.preview_thread = self.preview_parent.worker
# Set slider constraints
self.sliderIgnoreSignal = False
self.sliderVideo.setMinimum(1)
self.sliderVideo.setMaximum(self.video_length)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setSingleStep(1)
self.sliderVideo.setPageStep(24)
# Determine if a start or end attribute is in this file
start_frame = 1
# if 'start' in self.file.data.keys():
# start_frame = (float(self.file.data['start']) * self.fps) + 1
# Display start frame (and then the previous frame)
QTimer.singleShot(
500, functools.partial(self.sliderVideo.setValue, start_frame + 1))
QTimer.singleShot(
600, functools.partial(self.sliderVideo.setValue, start_frame))
# Add buttons
self.cancel_button = QPushButton(_('Cancel'))
self.process_button = QPushButton(_('Select Region'))
self.buttonBox.addButton(self.process_button,
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(self.cancel_button,
QDialogButtonBox.RejectRole)
# Connect signals
self.actionPlay.triggered.connect(self.actionPlay_Triggered)
self.btnPlay.clicked.connect(self.btnPlay_clicked)
self.sliderVideo.valueChanged.connect(self.sliderVideo_valueChanged)
self.initialized = True
get_app().window.SelectRegionSignal.emit(clip.Id())
def __init__(self, mode=None):
# Create main window base class
QMainWindow.__init__(self)
self.initialized = False
# set window on app for reference during initialization of children
get_app().window = self
_ = get_app()._tr
# Track metrics
track_metric_session() # start session
# Load user settings for window
s = settings.get_settings()
# Load UI from designer
ui_util.load_ui(self, self.ui_path)
# Set all keyboard shortcuts from the settings file
#self.InitKeyboardShortcuts()
# Init UI
ui_util.init_ui(self)
# Setup toolbars that aren't on main window, set initial state of items, etc
self.setup_toolbars()
# Add window as watcher to receive undo/redo status updates
get_app().updates.add_watcher(self)
# Create the timeline sync object (used for previewing timeline)
self.timeline_sync = TimelineSync(self)
# Setup timeline
self.timeline = TimelineWebView(self)
self.frameWeb.layout().addWidget(self.timeline)
# Configure the side docks to full-height
self.setCorner(Qt.TopLeftCorner, Qt.LeftDockWidgetArea)
self.setCorner(Qt.BottomLeftCorner, Qt.LeftDockWidgetArea)
self.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
self.setCorner(Qt.BottomRightCorner, Qt.RightDockWidgetArea)
# Process events before continuing
# TODO: Figure out why this is needed for a backup recovery to correctly show up on the timeline
get_app().processEvents()
# Setup video preview QWidget
self.videoPreview = VideoWidget()
self.tabVideo.layout().insertWidget(0, self.videoPreview)
# Load window state and geometry
#self.load_settings()
# Start the preview thread
self.preview_parent = PreviewParent()
self.preview_parent.Init(self, self.timeline_sync.timeline,
self.videoPreview)
self.preview_thread = self.preview_parent.worker
# Set pause callback
self.PauseSignal.connect(self.handlePausedVideo)
# QTimer for Autosave
self.auto_save_timer = QTimer(self)
self.auto_save_timer.setInterval(
s.get("autosave-interval") * 1000 * 60)
self.auto_save_timer.timeout.connect(self.auto_save_project)
if s.get("enable-auto-save"):
self.auto_save_timer.start()
# Set hardware decode
if s.get("hardware_decode"):
openshot.Settings.Instance().HARDWARE_DECODE = True
else:
openshot.Settings.Instance().HARDWARE_DECODE = False
# Set hardware encode
if s.get("hardware_encode"):
openshot.Settings.Instance().HARDWARE_ENCODE = True
else:
openshot.Settings.Instance().HARDWARE_ENCODE = False
# Set OMP thread enabled flag (for stability)
if s.get("omp_threads_enabled"):
openshot.Settings.Instance().WAIT_FOR_VIDEO_PROCESSING_TASK = False
else:
openshot.Settings.Instance().WAIT_FOR_VIDEO_PROCESSING_TASK = True
# Set scaling mode to lower quality scaling (for faster previews)
openshot.Settings.Instance().HIGH_QUALITY_SCALING = False
# Create lock file
self.create_lock_file()
# Connect OpenProject Signal
self.OpenProjectSignal.connect(self.open_project)
# Show window
self.show()
# Save settings
s.save()
# Refresh frame
QTimer.singleShot(100, self.refreshFrameSignal.emit)
# Main window is initialized
self.initialized = True
