392 lines
13 KiB
C++
392 lines
13 KiB
C++
/***
|
|
|
|
Olive - Non-Linear Video Editor
|
|
Copyright (C) 2021 Olive Team
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
#include "videoparamedit.h"
|
|
|
|
#include <QGridLayout>
|
|
|
|
namespace olive {
|
|
|
|
VideoParamEdit::VideoParamEdit(QWidget* parent) :
|
|
QWidget(parent),
|
|
color_manager_(nullptr),
|
|
mask_(0)
|
|
{
|
|
QGridLayout* layout = new QGridLayout(this);
|
|
|
|
layout->setMargin(0);
|
|
|
|
int row = 0;
|
|
|
|
// Enabled
|
|
enabled_lbl_ = new QLabel(tr("Enabled:"));
|
|
layout->addWidget(enabled_lbl_, row, 0);
|
|
enabled_box_ = new QCheckBox();
|
|
connect(enabled_box_, &QCheckBox::clicked, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(enabled_box_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Width
|
|
width_lbl_ = new QLabel(tr("Width:"));
|
|
layout->addWidget(width_lbl_, row, 0);
|
|
|
|
width_slider_ = new IntegerSlider();
|
|
width_slider_->SetMinimum(1);
|
|
width_slider_->SetMaximum(32768);
|
|
connect(width_slider_, &IntegerSlider::ValueChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(width_slider_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Height
|
|
height_lbl_ = new QLabel(tr("Height:"));
|
|
layout->addWidget(height_lbl_, row, 0);
|
|
|
|
height_slider_ = new IntegerSlider();
|
|
height_slider_->SetMinimum(1);
|
|
height_slider_->SetMaximum(32768);
|
|
connect(height_slider_, &IntegerSlider::ValueChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(height_slider_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Depth
|
|
depth_lbl_ = new QLabel(tr("Depth:"));
|
|
layout->addWidget(depth_lbl_, row, 0);
|
|
|
|
depth_slider_ = new IntegerSlider();
|
|
depth_slider_->SetMinimum(1);
|
|
depth_slider_->SetMaximum(32768);
|
|
connect(depth_slider_, &IntegerSlider::ValueChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(depth_slider_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Pixel Format
|
|
format_lbl_ = new QLabel(tr("Format:"));
|
|
layout->addWidget(format_lbl_, row, 0);
|
|
format_combobox_ = new PixelFormatComboBox(true);
|
|
connect(format_combobox_, static_cast<void (PixelFormatComboBox::*)(int)>(&PixelFormatComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
|
|
layout->addWidget(format_combobox_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Frame Rate
|
|
frame_rate_lbl_ = new QLabel(tr("Frame Rate:"));
|
|
layout->addWidget(frame_rate_lbl_, row, 0);
|
|
|
|
frame_rate_combobox_ = new FrameRateComboBox();
|
|
connect(frame_rate_combobox_, &FrameRateComboBox::FrameRateChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(frame_rate_combobox_, row, 1);
|
|
|
|
frame_rate_slider_ = new RationalSlider();
|
|
frame_rate_slider_->SetMinimum(0);
|
|
frame_rate_slider_->SetDecimalPlaces(3);
|
|
frame_rate_slider_->SetAutoTrimDecimalPlaces(true);
|
|
frame_rate_slider_->SetTimebase(rational(1, 1000)); // Drag interval
|
|
frame_rate_slider_->DisableDisplayType(RationalSlider::kTime);
|
|
connect(frame_rate_slider_, &RationalSlider::ValueChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(frame_rate_slider_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Pixel Aspect Ratio
|
|
pixel_aspect_lbl_ = new QLabel(tr("Pixel Aspect Ratio:"));
|
|
layout->addWidget(pixel_aspect_lbl_, row, 0);
|
|
|
|
pixel_aspect_combobox_ = new PixelAspectRatioComboBox();
|
|
connect(pixel_aspect_combobox_, static_cast<void (PixelAspectRatioComboBox::*)(int)>(&PixelAspectRatioComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
|
|
layout->addWidget(pixel_aspect_combobox_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Interlacing
|
|
interlaced_lbl_ = new QLabel(tr("Interlacing:"));
|
|
layout->addWidget(interlaced_lbl_, row, 0);
|
|
|
|
interlaced_combobox_ = new InterlacedComboBox();
|
|
connect(interlaced_combobox_, static_cast<void (InterlacedComboBox::*)(int)>(&InterlacedComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
|
|
layout->addWidget(interlaced_combobox_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Channel Count
|
|
channel_count_lbl_ = new QLabel(tr("Channel Count:"));
|
|
layout->addWidget(channel_count_lbl_, row, 0);
|
|
|
|
channel_count_combobox_ = new QComboBox();
|
|
channel_count_combobox_->addItem(tr("RGB"), VideoParams::kRGBChannelCount);
|
|
channel_count_combobox_->addItem(tr("RGBA"), VideoParams::kRGBAChannelCount);
|
|
connect(channel_count_combobox_, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
|
|
layout->addWidget(channel_count_combobox_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Divider
|
|
divider_lbl_ = new QLabel(tr("Divider:"));
|
|
layout->addWidget(divider_lbl_, row, 0);
|
|
|
|
divider_combobox_ = new VideoDividerComboBox();
|
|
connect(divider_combobox_, static_cast<void (VideoDividerComboBox::*)(int)>(&VideoDividerComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
|
|
layout->addWidget(divider_combobox_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Stream Index
|
|
stream_index_lbl_ = new QLabel(tr("Stream Index:"));
|
|
layout->addWidget(stream_index_lbl_, row, 0);
|
|
stream_index_slider_ = new IntegerSlider();
|
|
stream_index_slider_->SetMinimum(0);
|
|
connect(stream_index_slider_, &IntegerSlider::ValueChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(stream_index_slider_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Video type
|
|
video_type_lbl_ = new QLabel(tr("Video Type:"));
|
|
layout->addWidget(video_type_lbl_, row, 0);
|
|
video_type_combobox_ = new QComboBox();
|
|
video_type_combobox_->addItem(tr("Video"), VideoParams::kVideoTypeVideo);
|
|
video_type_combobox_->addItem(tr("Still"), VideoParams::kVideoTypeStill);
|
|
video_type_combobox_->addItem(tr("Image Sequence"), VideoParams::kVideoTypeImageSequence);
|
|
connect(video_type_combobox_, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
|
|
layout->addWidget(video_type_combobox_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Start time (for image sequences)
|
|
start_time_lbl_ = new QLabel(tr("Start Time"));
|
|
layout->addWidget(start_time_lbl_, row, 0);
|
|
|
|
start_time_slider_ = new IntegerSlider();
|
|
start_time_slider_->SetMinimum(0);
|
|
connect(start_time_slider_, &IntegerSlider::ValueChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(start_time_slider_, row, 1);
|
|
|
|
row++;
|
|
|
|
// End time (for image sequences)
|
|
end_time_lbl_ = new QLabel(tr("End Time"));
|
|
layout->addWidget(end_time_lbl_, row, 0);
|
|
|
|
end_time_slider_ = new IntegerSlider();
|
|
end_time_slider_->SetMinimum(0);
|
|
connect(end_time_slider_, &IntegerSlider::ValueChanged, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(end_time_slider_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Premultiplied alpha
|
|
premultiplied_alpha_lbl_ = new QLabel(tr("Premultiplied Alpha"));
|
|
layout->addWidget(premultiplied_alpha_lbl_, row, 0);
|
|
|
|
premultiplied_alpha_box_ = new QCheckBox();
|
|
connect(premultiplied_alpha_box_, &QCheckBox::clicked, this, &VideoParamEdit::Changed);
|
|
layout->addWidget(premultiplied_alpha_box_, row, 1);
|
|
|
|
row++;
|
|
|
|
// Colorspace
|
|
colorspace_lbl_ = new QLabel(tr("Colorspace"));
|
|
layout->addWidget(colorspace_lbl_, row, 0);
|
|
|
|
colorspace_combobox_ = new QComboBox();
|
|
connect(colorspace_combobox_, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
|
|
layout->addWidget(colorspace_combobox_, row, 1);
|
|
}
|
|
|
|
void VideoParamEdit::SetParameterMask(uint64_t mask)
|
|
{
|
|
mask_ = mask;
|
|
|
|
width_lbl_->setVisible(mask & kWidthHeight);
|
|
width_slider_->setVisible(mask & kWidthHeight);
|
|
height_lbl_->setVisible(mask & kWidthHeight);
|
|
height_slider_->setVisible(mask & kWidthHeight);
|
|
|
|
depth_lbl_->setVisible(mask & kDepth);
|
|
depth_slider_->setVisible(mask & kDepth);
|
|
|
|
frame_rate_lbl_->setVisible(mask & kFrameRate);
|
|
frame_rate_combobox_->setVisible((mask & kFrameRate) && !(mask & kFrameRateIsArbitrary));
|
|
frame_rate_slider_->setVisible((mask & kFrameRate) && (mask & kFrameRateIsArbitrary));
|
|
|
|
pixel_aspect_lbl_->setVisible(mask & kPixelAspect);
|
|
pixel_aspect_combobox_->setVisible(mask & kPixelAspect);
|
|
|
|
interlaced_lbl_->setVisible(mask & kInterlacing);
|
|
interlaced_combobox_->setVisible(mask & kInterlacing);
|
|
|
|
enabled_lbl_->setVisible(mask & kEnabled);
|
|
enabled_box_->setVisible(mask & kEnabled);
|
|
|
|
format_lbl_->setVisible(mask & kFormat);
|
|
format_combobox_->setVisible(mask & kFormat);
|
|
|
|
channel_count_lbl_->setVisible(mask & kChannelCount);
|
|
channel_count_combobox_->setVisible(mask & kChannelCount);
|
|
|
|
divider_lbl_->setVisible(mask & kDivider);
|
|
divider_combobox_->setVisible(mask & kDivider);
|
|
|
|
stream_index_lbl_->setVisible(mask & kStreamIndex);
|
|
stream_index_slider_->setVisible(mask & kStreamIndex);
|
|
|
|
video_type_lbl_->setVisible(mask & kIsImageSequence);
|
|
video_type_combobox_->setVisible(mask & kIsImageSequence);
|
|
|
|
start_time_lbl_->setVisible(mask & kStartTime);
|
|
start_time_slider_->setVisible(mask & kStartTime);
|
|
|
|
end_time_lbl_->setVisible(mask & kEndTime);
|
|
end_time_slider_->setVisible(mask & kEndTime);
|
|
|
|
premultiplied_alpha_lbl_->setVisible(mask & kPremultipliedAlpha);
|
|
premultiplied_alpha_box_->setVisible(mask & kPremultipliedAlpha);
|
|
|
|
colorspace_lbl_->setVisible(mask & kColorspace);
|
|
colorspace_combobox_->setVisible(mask & kColorspace);
|
|
}
|
|
|
|
VideoParams VideoParamEdit::GetVideoParams() const
|
|
{
|
|
VideoParams p;
|
|
|
|
p.set_enabled(enabled_box_->isChecked());
|
|
p.set_width(width_slider_->GetValue());
|
|
p.set_height(height_slider_->GetValue());
|
|
p.set_depth(depth_slider_->GetValue());
|
|
|
|
{
|
|
rational using_frame_rate;
|
|
|
|
if (mask_ & kFrameRateIsArbitrary) {
|
|
using_frame_rate = frame_rate_slider_->GetValue();
|
|
} else {
|
|
using_frame_rate = frame_rate_combobox_->GetFrameRate();
|
|
}
|
|
|
|
p.set_frame_rate(using_frame_rate);
|
|
if (mask_ & kFrameRateIsNotTimebase) {
|
|
// Frame rate editor will only edit the frame rate
|
|
p.set_time_base(timebase_temp_);
|
|
} else {
|
|
p.set_time_base(using_frame_rate.flipped());
|
|
}
|
|
}
|
|
|
|
p.set_pixel_aspect_ratio(pixel_aspect_combobox_->GetPixelAspectRatio());
|
|
p.set_interlacing(interlaced_combobox_->GetInterlaceMode());
|
|
p.set_format(format_combobox_->GetPixelFormat());
|
|
p.set_channel_count(channel_count_combobox_->currentData().toInt());
|
|
p.set_divider(divider_combobox_->GetDivider());
|
|
p.set_stream_index(stream_index_slider_->GetValue());
|
|
p.set_video_type(static_cast<VideoParams::Type>(video_type_combobox_->currentData().toInt()));
|
|
p.set_start_time(start_time_slider_->GetValue());
|
|
p.set_duration(end_time_slider_->GetValue() - start_time_slider_->GetValue() + 1);
|
|
p.set_premultiplied_alpha(premultiplied_alpha_box_->isChecked());
|
|
p.set_colorspace(colorspace_combobox_->currentData().toString());
|
|
|
|
return p;
|
|
}
|
|
|
|
void VideoParamEdit::SetVideoParams(const VideoParams &p)
|
|
{
|
|
blockSignals(true);
|
|
|
|
enabled_box_->setChecked(p.enabled());
|
|
width_slider_->SetValue(p.width());
|
|
height_slider_->SetValue(p.height());
|
|
depth_slider_->SetValue(p.depth());
|
|
|
|
frame_rate_combobox_->SetFrameRate(p.frame_rate());
|
|
frame_rate_slider_->SetValue(p.frame_rate());
|
|
timebase_temp_ = p.time_base();
|
|
|
|
pixel_aspect_combobox_->SetPixelAspectRatio(p.pixel_aspect_ratio());
|
|
interlaced_combobox_->SetInterlaceMode(p.interlacing());
|
|
format_combobox_->SetPixelFormat(p.format());
|
|
SetChannelCount(p.channel_count());
|
|
divider_combobox_->SetDivider(p.divider());
|
|
stream_index_slider_->SetValue(p.stream_index());
|
|
SetVideoTypeComboBox(p.video_type());
|
|
start_time_slider_->SetValue(p.start_time());
|
|
end_time_slider_->SetValue(p.start_time() + p.duration() - 1);
|
|
premultiplied_alpha_box_->setChecked(p.premultiplied_alpha());
|
|
|
|
if (color_manager_) {
|
|
// Assume colorspace box has been populated correctly
|
|
for (int i=0; i<colorspace_combobox_->count(); i++) {
|
|
if (colorspace_combobox_->itemData(i).toString() == p.colorspace()) {
|
|
colorspace_combobox_->setCurrentIndex(i);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
// Box is empty, fill with single option so that it gets preserved in GetVideoParams()
|
|
colorspace_combobox_->clear();
|
|
colorspace_combobox_->addItem(p.colorspace(), p.colorspace());
|
|
}
|
|
|
|
blockSignals(false);
|
|
}
|
|
|
|
void VideoParamEdit::SetColorManager(ColorManager *cm)
|
|
{
|
|
color_manager_ = cm;
|
|
|
|
// Re-populate colorspace combobox
|
|
colorspace_combobox_->clear();
|
|
|
|
if (color_manager_) {
|
|
// Add default colorspace
|
|
colorspace_combobox_->addItem(tr("Default (%1)").arg(color_manager_->GetDefaultInputColorSpace()), QString());
|
|
|
|
// Add remaining
|
|
QStringList spaces = color_manager_->ListAvailableColorspaces();
|
|
foreach (const QString& s, spaces) {
|
|
colorspace_combobox_->addItem(s, s);
|
|
}
|
|
}
|
|
}
|
|
|
|
void VideoParamEdit::SetChannelCount(int count)
|
|
{
|
|
for (int i=0; i<channel_count_combobox_->count(); i++) {
|
|
if (channel_count_combobox_->itemData(i).toInt() == count) {
|
|
channel_count_combobox_->setCurrentIndex(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void VideoParamEdit::SetVideoTypeComboBox(VideoParams::Type type)
|
|
{
|
|
for (int i=0; i<video_type_combobox_->count(); i++) {
|
|
if (video_type_combobox_->itemData(i).toInt() == type) {
|
|
video_type_combobox_->setCurrentIndex(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|