oak-team/oak-editor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

style: unify identifier naming per updated conventions

Browse Source 
Automated with clang-tidy readability-identifier-naming (config added to
.clang-tidy) plus scripted passes, per the updated rules now documented
in CONTRIBUTING.md:

- types (class/struct/enum/alias/template params): PascalCase
- functions, variables, members: snake_case (incl. rational -> Rational)
- private/protected members: trailing underscore; static member
  variables likewise (instance_, available_themes_)
- constants and enum values: snake_case (kLinear -> k_linear,
  F32P -> f32p); ALL_CAPS reserved for macros
- macros: OAK_ prefix (OLIVE_ADD_TEST/OLIVE_ASSERT/OLIVE_CONFIG ->
  OAK_ADD_TEST/OAK_ASSERT/OAK_CONFIG, GL_PREAMBLE -> OAK_GL_PREAMBLE,
  include guards -> OAK_*)
- file names: all lowercase (Current/Plugin/OliveHost/OliveClip/
  OlivePluginInstance -> current/plugin/olivehost/oliveclip/
  oliveplugininstance)
- getters share the member name sans underscore, setters set_foo()
- Qt and third-party (OpenFX) virtual overrides and framework callbacks
  keep their original names (exempt in .clang-tidy)

Manual follow-ups required where automation could not reach:
- string-based QMetaObject/SIGNAL/SLOT references updated to renamed
  methods (AddTask, CreatedFile, DeleteSpecificFile, moveSelectionUp, ...)
- macro bodies referencing renamed methods (OLIVE_CONFIG,
  NODE_DEFAULT_DESTRUCTOR, MANAGEDDISPLAYWIDGET_*)
- self-shadowing locals renamed where signals/methods became same-named
  (size_changed, worker_count, selected_items, import param, filters)
- third_party OFX member/namespace usages restored (OFX::Host::*,
  _created, _clipPrefsDirty, createInstance, clearPersistentMessage)
- STL protocol aliases restored (const_iterator) with .clang-tidy
  ignore rules; qHash overloads restored

Full build and test suite pass: ctest 4/4, ~1960 gtest cases green.
This commit is contained in:
Mike-Solar
2026-07-19 16:10:54 +08:00
parent cb1718a103
commit bb40b4923e
1014 changed files with 44257 additions and 44220 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/dialog/export/export.cpp
+208 -208
View File
@@ -74,10 +74,10 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
QPushButton *file_browse_btn = new QPushButton();
file_browse_btn->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
file_browse_btn->setIcon(icon::Folder);
file_browse_btn->setIcon(icon::folder);
file_browse_btn->setToolTip(tr("Browse for exported file filename"));
connect(file_browse_btn, &QPushButton::clicked, this,
&ExportDialog::BrowseFilename);
&ExportDialog::browse_filename);
preferences_layout->addWidget(file_browse_btn, row, 3);
row++;
@@ -86,11 +86,11 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
preset_lbl->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
preferences_layout->addWidget(preset_lbl, row, 0);
preset_combobox_ = new QComboBox();
LoadPresets();
load_presets();
connect(
preset_combobox_,
static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &ExportDialog::PresetComboBoxChanged);
this, &ExportDialog::preset_combo_box_changed);
preferences_layout->addWidget(preset_combobox_, row, 1, 1, 2);
/*QPushButton* preset_load_btn = new QPushButton();
@@ -99,15 +99,15 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
preferences_layout->addWidget(preset_load_btn, row, 2);*/
QPushButton *preset_save_btn = new QPushButton();
preset_save_btn->setIcon(icon::Save);
preset_save_btn->setIcon(icon::save);
preset_save_btn->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
preferences_layout->addWidget(preset_save_btn, row, 3);
connect(preset_save_btn, &QPushButton::clicked, this,
&ExportDialog::SavePreset);
&ExportDialog::save_preset);
row++;
preferences_layout->addWidget(QtUtils::CreateHorizontalLine(), row, 0, 1,
preferences_layout->addWidget(QtUtils::create_horizontal_line(), row, 0, 1,
4);
row++;
@@ -117,13 +117,13 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
range_combobox_ = new QComboBox();
range_combobox_->addItem(tr("Entire Sequence"));
range_combobox_->addItem(tr("In to Out"));
range_combobox_->setEnabled(viewer_node_->GetWorkArea()->enabled());
range_combobox_->setEnabled(viewer_node_->get_work_area()->enabled());
preferences_layout->addWidget(range_combobox_, row, 1, 1, 3);
row++;
preferences_layout->addWidget(QtUtils::CreateHorizontalLine(), row, 0, 1,
preferences_layout->addWidget(QtUtils::create_horizontal_line(), row, 0, 1,
4);
row++;
@@ -153,20 +153,20 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
color_manager_ = viewer_node_->project()->color_manager();
video_tab_ = new ExportVideoTab(color_manager_);
AddPreferencesTab(video_tab_, tr("Video"));
add_preferences_tab(video_tab_, tr("Video"));
// Set video tab time and make connections
connect(viewer_node, &ViewerOutput::PlayheadChanged, video_tab_,
&ExportVideoTab::SetTime);
connect(video_tab_, &ExportVideoTab::TimeChanged, viewer_node,
&ViewerOutput::SetPlayhead);
video_tab_->SetTime(viewer_node->GetPlayhead());
connect(viewer_node, &ViewerOutput::playhead_changed, video_tab_,
&ExportVideoTab::set_time);
connect(video_tab_, &ExportVideoTab::time_changed, viewer_node,
&ViewerOutput::set_playhead);
video_tab_->set_time(viewer_node->get_playhead());
audio_tab_ = new ExportAudioTab();
AddPreferencesTab(audio_tab_, tr("Audio"));
add_preferences_tab(audio_tab_, tr("Audio"));
subtitle_tab_ = new ExportSubtitlesTab();
AddPreferencesTab(subtitle_tab_, tr("Subtitles"));
add_preferences_tab(subtitle_tab_, tr("Subtitles"));
preferences_layout->addWidget(preferences_tabs_, row, 0, 1, 4);
@@ -206,7 +206,7 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
QPushButton *export_btn = new QPushButton(tr("Export"));
btn_layout->addWidget(export_btn);
connect(export_btn, &QPushButton::clicked, this,
&ExportDialog::StartExport);
&ExportDialog::start_export);
QPushButton *cancel_btn = new QPushButton(tr("Cancel"));
btn_layout->addWidget(cancel_btn);
@@ -220,7 +220,7 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
QVBoxLayout *preview_layout = new QVBoxLayout(preview_area);
preview_layout->addWidget(new QLabel(tr("Preview")));
preview_viewer_ = new ViewerWidget();
preview_viewer_->ruler()->SetMarkerEditingEnabled(false);
preview_viewer_->ruler()->set_marker_editing_enabled(false);
preview_viewer_->setSizePolicy(QSizePolicy::Expanding,
QSizePolicy::Expanding);
preview_layout->addWidget(preview_viewer_);
@@ -230,56 +230,56 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
splitter->setSizes({ 1, 99999 });
// Set default filename
SetDefaultFilename();
set_default_filename();
// Set defaults
previously_selected_format_ = ExportFormat::kFormatMPEG4Video;
connect(format_combobox_, &ExportFormatComboBox::FormatChanged, this,
&ExportDialog::FormatChanged);
previously_selected_format_ = ExportFormat::k_format_mpe_g4_video;
connect(format_combobox_, &ExportFormatComboBox::format_changed, this,
&ExportDialog::format_changed);
VideoParams vp = viewer_node_->GetVideoParams();
VideoParams vp = viewer_node_->get_video_params();
video_aspect_ratio_ =
static_cast<double>(vp.width()) / static_cast<double>(vp.height());
connect(video_tab_->width_slider(), &IntegerSlider::ValueChanged, this,
&ExportDialog::ResolutionChanged);
connect(video_tab_->width_slider(), &IntegerSlider::value_changed, this,
&ExportDialog::resolution_changed);
connect(video_tab_->height_slider(), &IntegerSlider::ValueChanged, this,
&ExportDialog::ResolutionChanged);
connect(video_tab_->height_slider(), &IntegerSlider::value_changed, this,
&ExportDialog::resolution_changed);
connect(
video_tab_->scaling_method_combobox(),
static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &ExportDialog::UpdateViewerDimensions);
this, &ExportDialog::update_viewer_dimensions);
connect(video_tab_->maintain_aspect_checkbox(), &QCheckBox::toggled, this,
&ExportDialog::ResolutionChanged);
&ExportDialog::resolution_changed);
connect(video_tab_, &ExportVideoTab::ColorSpaceChanged, preview_viewer_,
connect(video_tab_, &ExportVideoTab::color_space_changed, preview_viewer_,
static_cast<void (ViewerWidget::*)(const ColorTransform &)>(
&ViewerWidget::SetColorTransform));
connect(video_tab_, &ExportVideoTab::ImageSequenceCheckBoxChanged, this,
&ExportDialog::ImageSequenceCheckBoxChanged);
&ViewerWidget::set_color_transform));
connect(video_tab_, &ExportVideoTab::image_sequence_check_box_changed, this,
&ExportDialog::image_sequence_check_box_changed);
// We don't check if the codec supports subtitles because we can always export to a sidecar file
bool has_subtitle_tracks = SequenceHasSubtitles();
bool has_subtitle_tracks = sequence_has_subtitles();
connect(subtitles_enabled_, &QCheckBox::toggled, subtitle_tab_,
&QWidget::setEnabled);
subtitles_enabled_->setEnabled(has_subtitle_tracks);
// If the viewer already has cached params, use them
if (!stills_only_mode_ &&
viewer_node_->GetLastUsedEncodingParams().IsValid()) {
viewer_node_->get_last_used_encoding_params().is_valid()) {
// This will automatically set the param data
QtUtils::SetComboBoxData(preset_combobox_, kPresetLastUsed);
QtUtils::set_combo_box_data(preset_combobox_, k_preset_last_used);
} else {
SetDefaults();
set_defaults();
}
// Set viewer to view the node and set its colorspace
preview_viewer_->ConnectViewerNode(viewer_node_);
preview_viewer_->SetColorMenuEnabled(false);
preview_viewer_->SetColorTransform(video_tab_->CurrentOCIOColorSpace());
preview_viewer_->connect_viewer_node(viewer_node_);
preview_viewer_->set_color_menu_enabled(false);
preview_viewer_->set_color_transform(video_tab_->current_ocio_color_space());
qApp->installEventFilter(this);
@@ -294,21 +294,21 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, bool stills_only_mode,
subtitle_tab_->setEnabled(subtitles_enabled_->isChecked());
}
rational ExportDialog::GetSelectedTimebase() const
Rational ExportDialog::get_selected_timebase() const
{
return video_tab_->GetSelectedFrameRate().flipped();
return video_tab_->get_selected_frame_rate().flipped();
}
void ExportDialog::SetSelectedTimebase(const rational &r)
void ExportDialog::set_selected_timebase(const Rational &r)
{
video_tab_->SetSelectedFrameRate(r.flipped());
video_tab_->set_selected_frame_rate(r.flipped());
}
void ExportDialog::StartExport()
void ExportDialog::start_export()
{
if (!video_enabled_->isChecked() && !audio_enabled_->isChecked() &&
!subtitles_enabled_->isChecked()) {
QtUtils::MsgBox(
QtUtils::msg_box(
this, QMessageBox::Critical, tr("Invalid parameters"),
tr("Video, audio, and subtitles are disabled. There's nothing to export."));
return;
@@ -317,12 +317,12 @@ void ExportDialog::StartExport()
// Validate if the entered filename contains the correct extension (the extension is necessary
// for both FFmpeg and OIIO to determine the output format)
QString necessary_ext = QStringLiteral(".%1").arg(
ExportFormat::GetExtension(format_combobox_->GetFormat()));
ExportFormat::get_extension(format_combobox_->get_format()));
QString proposed_filename = filename_edit_->text().trimmed();
// If it doesn't, see if the user wants to append it automatically. If not, we don't abort the export.
if (!proposed_filename.endsWith(necessary_ext, Qt::CaseInsensitive)) {
if (QtUtils::MsgBox(
if (QtUtils::msg_box(
this, QMessageBox::Warning, tr("Invalid filename"),
tr("The filename must contain the extension \"%1\". Would you like to append it "
"automatically?")
@@ -340,8 +340,8 @@ void ExportDialog::StartExport()
// If the directory does not exist, try to create it
QDir dest_dir(file_info.path());
if (!FileFunctions::DirectoryIsValid(dest_dir)) {
QtUtils::MsgBox(
if (!FileFunctions::directory_is_valid(dest_dir)) {
QtUtils::msg_box(
this, QMessageBox::Critical,
tr("Failed to create output directory"),
tr("The intended output directory doesn't exist and Oak Video Editor couldn't create it. "
@@ -350,22 +350,22 @@ void ExportDialog::StartExport()
}
// Validate if this is an image sequence and if the filename contains enough digits
if (video_tab_->IsImageSequenceSet()) {
if (video_tab_->is_image_sequence_set()) {
// Ensure filename contains digits
if (!Encoder::FilenameContainsDigitPlaceholder(proposed_filename)) {
QtUtils::MsgBox(
if (!Encoder::filename_contains_digit_placeholder(proposed_filename)) {
QtUtils::msg_box(
this, QMessageBox::Critical, tr("Invalid filename"),
tr("Export is set to an image sequence, but the filename does not have a section for digits "
"(formatted as [#####] where the amount of # is the amount of digits)."));
return;
}
int64_t frame_count = GetExportLengthInTimebaseUnits();
int64_t needed_digit_count = GetDigitCount(frame_count);
int64_t frame_count = get_export_length_in_timebase_units();
int64_t needed_digit_count = get_digit_count(frame_count);
int current_digit_count =
Encoder::GetImageSequencePlaceholderDigitCount(proposed_filename);
Encoder::get_image_sequence_placeholder_digit_count(proposed_filename);
if (current_digit_count < needed_digit_count) {
QtUtils::MsgBox(
QtUtils::msg_box(
this, QMessageBox::Critical, tr("Invalid filename"),
tr("Filename doesn't contain enough digits for the amount of frames "
"this export will need (need %1 for %n frame(s)).",
@@ -377,7 +377,7 @@ void ExportDialog::StartExport()
// Validate if the file exists and whether the user wishes to overwrite it
if (file_info.exists()) {
if (QtUtils::MsgBox(
if (QtUtils::msg_box(
this, QMessageBox::Warning, tr("Confirm Overwrite"),
tr("The file \"%1\" already exists. Do you want to overwrite it?")
.arg(proposed_filename),
@@ -388,50 +388,50 @@ void ExportDialog::StartExport()
// Validate video resolution
if (video_enabled_->isChecked() &&
(video_tab_->GetSelectedCodec() == ExportCodec::kCodecH264 ||
video_tab_->GetSelectedCodec() == ExportCodec::kCodecH265) &&
(video_tab_->width_slider()->GetValue() % 2 != 0 ||
video_tab_->height_slider()->GetValue() % 2 != 0)) {
QtUtils::MsgBox(this, QMessageBox::Critical, tr("Invalid Parameters"),
(video_tab_->get_selected_codec() == ExportCodec::k_codec_h264 ||
video_tab_->get_selected_codec() == ExportCodec::k_codec_h265) &&
(video_tab_->width_slider()->get_value() % 2 != 0 ||
video_tab_->height_slider()->get_value() % 2 != 0)) {
QtUtils::msg_box(this, QMessageBox::Critical, tr("Invalid Parameters"),
tr("Width and height must be multiples of 2."));
return;
}
ExportTask *task =
new ExportTask(viewer_node_, color_manager_, GenerateParams());
new ExportTask(viewer_node_, color_manager_, generate_params());
if (export_bkg_box_->isChecked()) {
// Send to TaskManager to export in background
TaskManager::instance()->AddTask(task);
TaskManager::instance()->add_task(task);
this->accept();
} else {
// Use modal dialog box
TaskDialog *td = new TaskDialog(task, tr("Export"), this);
connect(td, &TaskDialog::TaskSucceeded, this,
&ExportDialog::ExportFinished);
connect(td, &TaskDialog::task_succeeded, this,
&ExportDialog::export_finished);
td->open();
}
}
void ExportDialog::ExportFinished()
void ExportDialog::export_finished()
{
TaskDialog *td = static_cast<TaskDialog *>(sender());
if (td->GetTask()->IsCancelled()) {
if (td->get_task()->is_cancelled()) {
// If this task was cancelled, we stay open so the user can potentially queue another export
} else {
// Accept this dialog and close
if (import_file_after_export_->isEnabled() &&
import_file_after_export_->isChecked()) {
QString filename = filename_edit_->text().trimmed();
emit RequestImportFile(filename);
emit request_import_file(filename);
}
this->accept();
}
}
void ExportDialog::ImageSequenceCheckBoxChanged(bool e)
void ExportDialog::image_sequence_check_box_changed(bool e)
{
QFileInfo current_fileinfo(filename_edit_->text());
@@ -439,11 +439,11 @@ void ExportDialog::ImageSequenceCheckBoxChanged(bool e)
QString suffix = current_fileinfo.suffix();
if (e) {
if (!Encoder::FilenameContainsDigitPlaceholder(basename)) {
if (!Encoder::filename_contains_digit_placeholder(basename)) {
basename.append(QStringLiteral("_[#####]"));
}
} else {
basename = Encoder::FilenameRemoveDigitPlaceholder(basename);
basename = Encoder::filename_remove_digit_placeholder(basename);
}
// Set filename
@@ -454,16 +454,16 @@ void ExportDialog::ImageSequenceCheckBoxChanged(bool e)
filename_edit_->setText(current_fileinfo.dir().filePath(basename));
}
void ExportDialog::SavePreset()
void ExportDialog::save_preset()
{
ExportSavePresetDialog d(GenerateParams(), this);
ExportSavePresetDialog d(generate_params(), this);
if (d.exec() == QDialog::Accepted) {
LoadPresets();
preset_combobox_->setCurrentText(d.GetSelectedPresetName());
load_presets();
preset_combobox_->setCurrentText(d.get_selected_preset_name());
}
}
void ExportDialog::PresetComboBoxChanged()
void ExportDialog::preset_combo_box_changed()
{
if (loading_presets_) {
return;
@@ -472,16 +472,16 @@ void ExportDialog::PresetComboBoxChanged()
QComboBox *c = static_cast<QComboBox *>(sender());
int preset_number = c->currentData().toInt();
if (preset_number == kPresetDefault) {
SetDefaults();
} else if (preset_number == kPresetLastUsed) {
SetParams(viewer_node_->GetLastUsedEncodingParams());
if (preset_number == k_preset_default) {
set_defaults();
} else if (preset_number == k_preset_last_used) {
set_params(viewer_node_->get_last_used_encoding_params());
} else {
SetParams(presets_.at(preset_number));
set_params(presets_.at(preset_number));
}
}
void ExportDialog::AddPreferencesTab(QWidget *inner_widget,
void ExportDialog::add_preferences_tab(QWidget *inner_widget,
const QString &title)
{
QScrollArea *scroll_area = new QScrollArea();
@@ -490,14 +490,14 @@ void ExportDialog::AddPreferencesTab(QWidget *inner_widget,
preferences_tabs_->addTab(scroll_area, title);
}
void ExportDialog::BrowseFilename()
void ExportDialog::browse_filename()
{
ExportFormat::Format f = format_combobox_->GetFormat();
ExportFormat::Format f = format_combobox_->get_format();
QString browsed_fn = QFileDialog::getSaveFileName(
this, "", filename_edit_->text().trimmed(),
QStringLiteral("%1 (*.%2)")
.arg(ExportFormat::GetName(f), ExportFormat::GetExtension(f)),
.arg(ExportFormat::get_name(f), ExportFormat::get_extension(f)),
nullptr,
// We don't confirm overwrite here because we do it later
@@ -508,12 +508,12 @@ void ExportDialog::BrowseFilename()
}
}
void ExportDialog::FormatChanged(ExportFormat::Format current_format)
void ExportDialog::format_changed(ExportFormat::Format current_format)
{
QString current_filename = filename_edit_->text().trimmed();
QString previously_selected_ext =
ExportFormat::GetExtension(previously_selected_format_);
QString currently_selected_ext = ExportFormat::GetExtension(current_format);
ExportFormat::get_extension(previously_selected_format_);
QString currently_selected_ext = ExportFormat::get_extension(current_format);
// If the previous extension was added, remove it
if (current_filename.endsWith(previously_selected_ext,
@@ -530,72 +530,72 @@ void ExportDialog::FormatChanged(ExportFormat::Format current_format)
previously_selected_format_ = current_format;
// Update video and audio comboboxes
bool has_video_codecs = video_tab_->SetFormat(current_format);
bool has_video_codecs = video_tab_->set_format(current_format);
video_enabled_->setChecked(has_video_codecs);
video_enabled_->setEnabled(has_video_codecs);
bool has_audio_codecs = audio_tab_->SetFormat(current_format);
bool has_audio_codecs = audio_tab_->set_format(current_format);
audio_enabled_->setChecked(has_audio_codecs);
audio_enabled_->setEnabled(has_audio_codecs);
if (subtitles_enabled_->isEnabled()) {
subtitle_tab_->SetFormat(current_format);
subtitle_tab_->set_format(current_format);
}
}
void ExportDialog::ResolutionChanged()
void ExportDialog::resolution_changed()
{
if (video_tab_->maintain_aspect_checkbox()->isChecked()) {
// Keep aspect ratio maintained
if (sender() == video_tab_->height_slider()) {
// Convert height to float
double new_width = video_tab_->height_slider()->GetValue();
double new_width = video_tab_->height_slider()->get_value();
// Generate width from aspect ratio
new_width *= video_aspect_ratio_;
// Align to even number and set
video_tab_->width_slider()->SetValue(new_width);
video_tab_->width_slider()->set_value(new_width);
} else {
// Convert width to float
double new_height = video_tab_->width_slider()->GetValue();
double new_height = video_tab_->width_slider()->get_value();
// Generate height from aspect ratio
new_height /= video_aspect_ratio_;
// Align to even number and set
video_tab_->height_slider()->SetValue(new_height);
video_tab_->height_slider()->set_value(new_height);
}
}
UpdateViewerDimensions();
update_viewer_dimensions();
}
void ExportDialog::LoadPresets()
void ExportDialog::load_presets()
{
loading_presets_ = true;
preset_combobox_->clear();
presets_.clear();
preset_combobox_->addItem(tr("Default"), kPresetDefault);
preset_combobox_->addItem(tr("Default"), k_preset_default);
if (viewer_node_->GetLastUsedEncodingParams().IsValid()) {
preset_combobox_->addItem(tr("Last Used"), kPresetLastUsed);
if (viewer_node_->get_last_used_encoding_params().is_valid()) {
preset_combobox_->addItem(tr("Last Used"), k_preset_last_used);
}
preset_combobox_->insertSeparator(preset_combobox_->count());
QStringList l = EncodingParams::GetListOfPresets();
QStringList l = EncodingParams::get_list_of_presets();
presets_.reserve(l.size());
for (const QString &preset : l) {
EncodingParams p;
QFile f(EncodingParams::GetPresetPath().filePath(preset));
QFile f(EncodingParams::get_preset_path().filePath(preset));
if (f.open(QFile::ReadOnly)) {
if (p.Load(&f)) {
if (p.load(&f)) {
preset_combobox_->addItem(preset, int(presets_.size()));
presets_.push_back(p);
}
@@ -606,7 +606,7 @@ void ExportDialog::LoadPresets()
loading_presets_ = false;
}
void ExportDialog::SetDefaultFilename()
void ExportDialog::set_default_filename()
{
Project *p = viewer_node_->project();
@@ -619,16 +619,16 @@ void ExportDialog::SetDefaultFilename()
doc_location = QFileInfo(p->filename()).dir();
}
QString file_location = doc_location.filePath(viewer_node_->GetLabel());
QString file_location = doc_location.filePath(viewer_node_->get_label());
filename_edit_->setText(file_location);
}
bool ExportDialog::SequenceHasSubtitles() const
bool ExportDialog::sequence_has_subtitles() const
{
if (Sequence *s = dynamic_cast<Sequence *>(viewer_node_)) {
TrackList *tl = s->track_list(Track::kSubtitle);
for (Track *t : tl->GetTracks()) {
if (!t->IsMuted() && !t->Blocks().empty()) {
TrackList *tl = s->track_list(Track::k_subtitle);
for (Track *t : tl->get_tracks()) {
if (!t->is_muted() && !t->blocks().empty()) {
return true;
}
}
@@ -637,67 +637,67 @@ bool ExportDialog::SequenceHasSubtitles() const
return false;
}
void ExportDialog::SetDefaults()
void ExportDialog::set_defaults()
{
if (!stills_only_mode_) {
format_combobox_->SetFormat(ExportFormat::kFormatMPEG4Video);
format_combobox_->set_format(ExportFormat::k_format_mpe_g4_video);
} else {
format_combobox_->SetFormat(ExportFormat::kFormatPNG);
format_combobox_->set_format(ExportFormat::k_format_png);
}
FormatChanged(format_combobox_->GetFormat());
format_changed(format_combobox_->get_format());
VideoParams vp = viewer_node_->GetVideoParams();
AudioParams ap = viewer_node_->GetAudioParams();
VideoParams vp = viewer_node_->get_video_params();
AudioParams ap = viewer_node_->get_audio_params();
video_tab_->width_slider()->SetValue(vp.width());
video_tab_->width_slider()->set_value(vp.width());
video_tab_->width_slider()->SetDefaultValue(vp.width());
video_tab_->height_slider()->SetValue(vp.height());
video_tab_->height_slider()->set_value(vp.height());
video_tab_->height_slider()->SetDefaultValue(vp.height());
video_tab_->SetSelectedFrameRate(vp.frame_rate());
video_tab_->pixel_aspect_combobox()->SetPixelAspectRatio(
video_tab_->set_selected_frame_rate(vp.frame_rate());
video_tab_->pixel_aspect_combobox()->set_pixel_aspect_ratio(
vp.pixel_aspect_ratio());
video_tab_->pixel_format_field()->SetPixelFormat(
video_tab_->pixel_format_field()->set_pixel_format(
static_cast<PixelFormat::Format>(
OLIVE_CONFIG("OnlinePixelFormat").toInt()));
video_tab_->interlaced_combobox()->SetInterlaceMode(vp.interlacing());
audio_tab_->sample_rate_combobox()->SetSampleRate(ap.sample_rate());
audio_tab_->sample_format_combobox()->SetAttemptToRestoreFormat(false);
audio_tab_->channel_layout_combobox()->SetChannelLayout(
OAK_CONFIG("OnlinePixelFormat").toInt()));
video_tab_->interlaced_combobox()->set_interlace_mode(vp.interlacing());
audio_tab_->sample_rate_combobox()->set_sample_rate(ap.sample_rate());
audio_tab_->sample_format_combobox()->set_attempt_to_restore_format(false);
audio_tab_->channel_layout_combobox()->set_channel_layout(
ap.channel_layout());
subtitles_enabled_->setChecked(SequenceHasSubtitles());
subtitle_tab_->SetSidecarFormat(ExportFormat::kFormatSRT);
subtitles_enabled_->setChecked(sequence_has_subtitles());
subtitle_tab_->set_sidecar_format(ExportFormat::k_format_srt);
}
EncodingParams ExportDialog::GenerateParams() const
EncodingParams ExportDialog::generate_params() const
{
VideoParams video_render_params(
static_cast<int>(video_tab_->width_slider()->GetValue()),
static_cast<int>(video_tab_->height_slider()->GetValue()),
GetSelectedTimebase(),
video_tab_->pixel_format_field()->GetPixelFormat(),
VideoParams::kInternalChannelCount,
video_tab_->pixel_aspect_combobox()->GetPixelAspectRatio(),
video_tab_->interlaced_combobox()->GetInterlaceMode(), 1);
static_cast<int>(video_tab_->width_slider()->get_value()),
static_cast<int>(video_tab_->height_slider()->get_value()),
get_selected_timebase(),
video_tab_->pixel_format_field()->get_pixel_format(),
VideoParams::k_internal_channel_count,
video_tab_->pixel_aspect_combobox()->get_pixel_aspect_ratio(),
video_tab_->interlaced_combobox()->get_interlace_mode(), 1);
AudioParams audio_render_params(
audio_tab_->sample_rate_combobox()->GetSampleRate(),
audio_tab_->channel_layout_combobox()->GetChannelLayout(),
audio_tab_->sample_format_combobox()->GetSampleFormat());
audio_tab_->sample_rate_combobox()->get_sample_rate(),
audio_tab_->channel_layout_combobox()->get_channel_layout(),
audio_tab_->sample_format_combobox()->get_sample_format());
EncodingParams params;
params.set_format(format_combobox_->GetFormat());
params.SetFilename(filename_edit_->text().trimmed());
params.SetExportLength(viewer_node_->GetLength());
params.set_format(format_combobox_->get_format());
params.set_filename(filename_edit_->text().trimmed());
params.set_export_length(viewer_node_->get_length());
if (ExportCodec::IsCodecAStillImage(video_tab_->GetSelectedCodec()) &&
!video_tab_->IsImageSequenceSet()) {
if (ExportCodec::is_codec_a_still_image(video_tab_->get_selected_codec()) &&
!video_tab_->is_image_sequence_set()) {
// Exporting as image without exporting image sequence, only export one frame
rational export_time = video_tab_->GetStillImageTime();
Rational export_time = video_tab_->get_still_image_time();
params.set_custom_range(
TimeRange(export_time, export_time + GetSelectedTimebase()));
} else if (range_combobox_->currentIndex() == kRangeInToOut) {
TimeRange(export_time, export_time + get_selected_timebase()));
} else if (range_combobox_->currentIndex() == k_range_in_to_out) {
// Assume if this combobox is enabled, workarea is enabled - a check that we make in this dialog's constructor
params.set_custom_range(viewer_node_->GetWorkArea()->range());
params.set_custom_range(viewer_node_->get_work_area()->range());
}
if (video_tab_->scaling_method_combobox()->isEnabled()) {
@@ -707,109 +707,109 @@ EncodingParams ExportDialog::GenerateParams() const
}
if (video_enabled_->isChecked()) {
ExportCodec::Codec video_codec = video_tab_->GetSelectedCodec();
ExportCodec::Codec video_codec = video_tab_->get_selected_codec();
video_render_params.set_color_range(video_tab_->color_range());
params.EnableVideo(video_render_params, video_codec);
params.enable_video(video_render_params, video_codec);
params.set_video_threads(video_tab_->threads());
if (video_tab_->isVisible()) {
video_tab_->GetCodecSection()->AddOpts(&params);
video_tab_->get_codec_section()->add_opts(&params);
}
params.set_color_transform(video_tab_->CurrentOCIOColorSpace());
params.set_color_transform(video_tab_->current_ocio_color_space());
params.set_video_pix_fmt(video_tab_->pix_fmt());
params.set_video_is_image_sequence(video_tab_->IsImageSequenceSet());
params.set_video_is_image_sequence(video_tab_->is_image_sequence_set());
}
if (audio_enabled_->isChecked()) {
ExportCodec::Codec audio_codec = audio_tab_->GetCodec();
params.EnableAudio(audio_render_params, audio_codec);
ExportCodec::Codec audio_codec = audio_tab_->get_codec();
params.enable_audio(audio_render_params, audio_codec);
params.set_audio_bit_rate(audio_tab_->bit_rate_slider()->GetValue() *
params.set_audio_bit_rate(audio_tab_->bit_rate_slider()->get_value() *
1000);
}
if (subtitles_enabled_->isEnabled() && subtitles_enabled_->isChecked()) {
if (!subtitle_tab_->GetSidecarEnabled()) {
if (!subtitle_tab_->get_sidecar_enabled()) {
// Export subtitles embedded in container
params.EnableSubtitles(subtitle_tab_->GetSubtitleCodec());
params.enable_subtitles(subtitle_tab_->get_subtitle_codec());
} else {
// Export subtitles to a sidecar file
params.EnableSidecarSubtitles(subtitle_tab_->GetSidecarFormat(),
subtitle_tab_->GetSubtitleCodec());
params.enable_sidecar_subtitles(subtitle_tab_->get_sidecar_format(),
subtitle_tab_->get_subtitle_codec());
}
}
return params;
}
void ExportDialog::SetParams(const EncodingParams &e)
void ExportDialog::set_params(const EncodingParams &e)
{
format_combobox_->SetFormat(e.format());
FormatChanged(format_combobox_->GetFormat());
format_combobox_->set_format(e.format());
format_changed(format_combobox_->get_format());
if (e.has_custom_range() && viewer_node_->GetWorkArea()->enabled()) {
range_combobox_->setCurrentIndex(kRangeInToOut);
if (e.has_custom_range() && viewer_node_->get_work_area()->enabled()) {
range_combobox_->setCurrentIndex(k_range_in_to_out);
}
QtUtils::SetComboBoxData(video_tab_->scaling_method_combobox(),
QtUtils::set_combo_box_data(video_tab_->scaling_method_combobox(),
e.video_scaling_method());
video_enabled_->setChecked(e.video_enabled());
if (e.video_enabled()) {
video_tab_->width_slider()->SetValue(e.video_params().width());
video_tab_->height_slider()->SetValue(e.video_params().height());
SetSelectedTimebase(e.video_params().time_base());
video_tab_->pixel_format_field()->SetPixelFormat(
video_tab_->width_slider()->set_value(e.video_params().width());
video_tab_->height_slider()->set_value(e.video_params().height());
set_selected_timebase(e.video_params().time_base());
video_tab_->pixel_format_field()->set_pixel_format(
e.video_params().format());
video_tab_->pixel_aspect_combobox()->SetPixelAspectRatio(
video_tab_->pixel_aspect_combobox()->set_pixel_aspect_ratio(
e.video_params().pixel_aspect_ratio());
video_tab_->interlaced_combobox()->SetInterlaceMode(
video_tab_->interlaced_combobox()->set_interlace_mode(
e.video_params().interlacing());
video_tab_->SetSelectedCodec(e.video_codec());
video_tab_->set_selected_codec(e.video_codec());
video_tab_->SetColorRange(e.video_params().color_range());
video_tab_->set_color_range(e.video_params().color_range());
video_tab_->SetThreads(e.video_threads());
video_tab_->set_threads(e.video_threads());
if (video_tab_->isVisible()) {
video_tab_->GetCodecSection()->SetOpts(&e);
video_tab_->get_codec_section()->set_opts(&e);
}
video_tab_->SetOCIOColorSpace(e.color_transform().output());
video_tab_->set_ocio_color_space(e.color_transform().output());
video_tab_->SetPixFmt(e.video_pix_fmt());
video_tab_->set_pix_fmt(e.video_pix_fmt());
video_tab_->SetImageSequence(e.video_is_image_sequence());
video_tab_->set_image_sequence(e.video_is_image_sequence());
}
audio_enabled_->setChecked(e.audio_enabled());
if (e.audio_enabled()) {
audio_tab_->sample_rate_combobox()->SetSampleRate(
audio_tab_->sample_rate_combobox()->set_sample_rate(
e.audio_params().sample_rate());
audio_tab_->channel_layout_combobox()->SetChannelLayout(
audio_tab_->channel_layout_combobox()->set_channel_layout(
e.audio_params().channel_layout());
audio_tab_->sample_format_combobox()->SetSampleFormat(
audio_tab_->sample_format_combobox()->set_sample_format(
e.audio_params().format());
audio_tab_->SetCodec(e.audio_codec());
audio_tab_->set_codec(e.audio_codec());
audio_tab_->bit_rate_slider()->SetValue(e.audio_bit_rate() / 1000);
audio_tab_->bit_rate_slider()->set_value(e.audio_bit_rate() / 1000);
}
if (subtitles_enabled_->isEnabled()) {
subtitles_enabled_->setChecked(e.subtitles_enabled());
subtitle_tab_->SetSidecarEnabled(e.subtitles_are_sidecar());
subtitle_tab_->set_sidecar_enabled(e.subtitles_are_sidecar());
if (e.subtitles_enabled()) {
subtitle_tab_->SetSubtitleCodec(e.subtitles_codec());
subtitle_tab_->set_subtitle_codec(e.subtitles_codec());
if (e.subtitles_are_sidecar()) {
subtitle_tab_->SetSidecarFormat(e.subtitle_sidecar_fmt());
subtitle_tab_->set_sidecar_format(e.subtitle_sidecar_fmt());
}
}
}
@@ -833,46 +833,46 @@ bool ExportDialog::eventFilter(QObject *o, QEvent *e)
void ExportDialog::done(int r)
{
preview_viewer_->ConnectViewerNode(nullptr);
preview_viewer_->connect_viewer_node(nullptr);
if (!stills_only_mode_) {
viewer_node_->SetLastUsedEncodingParams(GenerateParams());
viewer_node_->set_last_used_encoding_params(generate_params());
}
super::done(r);
}
rational ExportDialog::GetExportLength() const
Rational ExportDialog::get_export_length() const
{
if (range_combobox_->currentIndex() == kRangeInToOut) {
return viewer_node_->GetWorkArea()->range().length();
if (range_combobox_->currentIndex() == k_range_in_to_out) {
return viewer_node_->get_work_area()->range().length();
} else {
return viewer_node_->GetLength();
return viewer_node_->get_length();
}
}
int64_t ExportDialog::GetExportLengthInTimebaseUnits() const
int64_t ExportDialog::get_export_length_in_timebase_units() const
{
return Timecode::time_to_timestamp(GetExportLength(),
GetSelectedTimebase());
return Timecode::time_to_timestamp(get_export_length(),
get_selected_timebase());
}
void ExportDialog::UpdateViewerDimensions()
void ExportDialog::update_viewer_dimensions()
{
preview_viewer_->SetViewerResolution(
static_cast<int>(video_tab_->width_slider()->GetValue()),
static_cast<int>(video_tab_->height_slider()->GetValue()));
preview_viewer_->set_viewer_resolution(
static_cast<int>(video_tab_->width_slider()->get_value()),
static_cast<int>(video_tab_->height_slider()->get_value()));
VideoParams vp = viewer_node_->GetVideoParams();
VideoParams vp = viewer_node_->get_video_params();
QMatrix4x4 transform = EncodingParams::GenerateMatrix(
QMatrix4x4 transform = EncodingParams::generate_matrix(
static_cast<EncodingParams::VideoScalingMethod>(
video_tab_->scaling_method_combobox()->currentData().toInt()),
vp.width(), vp.height(),
static_cast<int>(video_tab_->width_slider()->GetValue()),
static_cast<int>(video_tab_->height_slider()->GetValue()));
static_cast<int>(video_tab_->width_slider()->get_value()),
static_cast<int>(video_tab_->height_slider()->get_value()));
preview_viewer_->SetMatrix(transform);
preview_viewer_->set_matrix(transform);
}
}