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

Merge branch 'master' into cache-update

Browse Source
This commit is contained in:
itsmattkc
2022-08-18 08:12:46 -07:00
parent 6716a7173b b169ad923c
commit 54d0a94a20
183 changed files with 7520 additions and 1705 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/ci.yml
+7 -3
View File
@@ -24,6 +24,7 @@ on:
env:
DOWNLOAD_TOOL: curl -fLOSs --retry 2 --retry-delay 60
UPLOAD_TOOL: curl -X POST --retry 2 --retry-delay 60
CMAKE_ARGS: -DUSE_WERROR=ON -DBUILD_TESTS=ON
jobs:
linux:
@@ -73,7 +74,8 @@ jobs:
cmake .. -G "${{ matrix.cmake-gen }}" \
-DCMAKE_BUILD_TYPE="${{ matrix.build-type }}" \
-DCMAKE_C_COMPILER="${{ matrix.cc-compiler }}" \
-DCMAKE_CXX_COMPILER="${{ matrix.cxx-compiler }}"
-DCMAKE_CXX_COMPILER="${{ matrix.cxx-compiler }}" \
$CMAKE_ARGS
- name: Build
working-directory: build
@@ -204,7 +206,8 @@ jobs:
working-directory: ${{ runner.workspace }}/build
run: |
cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} -G "${{ matrix.cmake-gen }}" \
-DCMAKE_TOOLCHAIN_FILE="$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake"
-DCMAKE_TOOLCHAIN_FILE="$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake" \
$CMAKE_ARGS
- name: Build
working-directory: ${{ runner.workspace }}/build
@@ -356,7 +359,8 @@ jobs:
PATH=$DEP_LOCATION:$DEP_LOCATION/bin:$DEP_LOCATION/include:$DEP_LOCATION/lib:$DEP_LOCATION/crashpad:$PATH \
cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \
-DCMAKE_OSX_DEPLOYMENT_TARGET=${{ matrix.min-deploy }} -G "${{ matrix.cmake-gen }}" \
-DCMAKE_OSX_ARCHITECTURES="${{ matrix.os-arch }}"
-DCMAKE_OSX_ARCHITECTURES="${{ matrix.os-arch }}" \
$CMAKE_ARGS
- name: Build
working-directory: ${{ runner.workspace }}/build
CMakeLists.txt
+2 -2
View File
@@ -19,8 +19,8 @@ cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
project(olive-editor VERSION 0.2.0 LANGUAGES CXX)
option(BUILD_DOXYGEN "Build Doxygen documentation" OFF)
option(BUILD_TESTS "Build unit tests" ON)
option(USE_WERROR "Error on compile warning" ON)
option(BUILD_TESTS "Build unit tests" OFF)
option(USE_WERROR "Error on compile warning" OFF)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
app/codec/decoder.cpp
+27 -13
View File
@@ -37,11 +37,18 @@ namespace olive {
const rational Decoder::kAnyTimecode = RATIONAL_MIN;
Decoder::Decoder()
Decoder::Decoder() :
cached_texture_(nullptr)
{
UpdateLastAccessed();
}
void Decoder::IncrementAccessTime(qint64 t)
{
QMutexLocker locker(&mutex_);
last_accessed_ += t;
}
bool Decoder::Open(const CodecStream &stream)
{
QMutexLocker locker(&mutex_);
@@ -86,7 +93,7 @@ bool Decoder::Open(const CodecStream &stream)
}
}
TexturePtr Decoder::RetrieveVideo(Renderer *renderer, const rational &timecode, const RetrieveVideoParams &divider, const QAtomicInt *cancelled)
TexturePtr Decoder::RetrieveVideo(const RetrieveVideoParams &p)
{
QMutexLocker locker(&mutex_);
@@ -102,14 +109,21 @@ TexturePtr Decoder::RetrieveVideo(Renderer *renderer, const rational &timecode,
return nullptr;
}
if (cancelled && *cancelled) {
if (p.cancelled && p.cancelled->IsCancelled()) {
return nullptr;
}
return RetrieveVideoInternal(renderer, timecode, divider, cancelled);
if (cached_texture_ && cached_time_ == p.time) {
return cached_texture_;
}
cached_texture_ = RetrieveVideoInternal(p);
cached_time_ = p.time;
return cached_texture_;
}
Decoder::RetrieveAudioStatus Decoder::RetrieveAudio(SampleBuffer &dest, const TimeRange &range, const AudioParams &params, const QString& cache_path, Footage::LoopMode loop_mode, RenderMode::Mode mode)
Decoder::RetrieveAudioStatus Decoder::RetrieveAudio(SampleBuffer &dest, const TimeRange &range, const AudioParams &params, const QString& cache_path, LoopMode loop_mode, RenderMode::Mode mode)
{
QMutexLocker locker(&mutex_);
@@ -152,6 +166,8 @@ void Decoder::Close()
UpdateLastAccessed();
cached_texture_ = nullptr;
if (stream_.IsValid()) {
CloseInternal();
stream_.Reset();
@@ -160,7 +176,7 @@ void Decoder::Close()
}
}
bool Decoder::ConformAudio(const QVector<QString> &output_filenames, const AudioParams &params, const QAtomicInt *cancelled)
bool Decoder::ConformAudio(const QVector<QString> &output_filenames, const AudioParams &params, CancelAtom *cancelled)
{
return ConformAudioInternal(output_filenames, params, cancelled);
}
@@ -264,15 +280,13 @@ int64_t Decoder::GetImageSequenceIndex(const QString &filename)
return number_only.toLongLong();
}
TexturePtr Decoder::RetrieveVideoInternal(Renderer *renderer, const rational &timecode, const RetrieveVideoParams &divider, const QAtomicInt *cancelled)
TexturePtr Decoder::RetrieveVideoInternal(const RetrieveVideoParams &p)
{
Q_UNUSED(timecode)
Q_UNUSED(divider)
Q_UNUSED(cancelled)
Q_UNUSED(p)
return nullptr;
}
bool Decoder::ConformAudioInternal(const QVector<QString> &filenames, const AudioParams &params, const QAtomicInt* cancelled)
bool Decoder::ConformAudioInternal(const QVector<QString> &filenames, const AudioParams &params, CancelAtom *cancelled)
{
Q_UNUSED(filenames)
Q_UNUSED(cancelled)
@@ -280,7 +294,7 @@ bool Decoder::ConformAudioInternal(const QVector<QString> &filenames, const Audi
return false;
}
bool Decoder::RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, const TimeRange& range, Footage::LoopMode loop_mode, const AudioParams &input_params)
bool Decoder::RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, const TimeRange& range, LoopMode loop_mode, const AudioParams &input_params)
{
PlanarFileDevice input;
if (input.open(conform_filenames, QFile::ReadOnly)) {
@@ -290,7 +304,7 @@ bool Decoder::RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVecto
const qint64 buffer_length_in_bytes = sample_buffer.sample_count() * input_params.bytes_per_sample_per_channel();
while (write_index < buffer_length_in_bytes) {
if (loop_mode == Footage::kLoopModeLoop) {
if (loop_mode == kLoopModeLoop) {
while (read_index >= input.size()) {
read_index -= input.size();
}
app/codec/decoder.h
+25 -31
View File
@@ -35,7 +35,6 @@ extern "C" {
#include "codec/samplebuffer.h"
#include "common/rational.h"
#include "node/block/block.h"
#include "node/project/footage/footage.h"
#include "node/project/footage/footagedescription.h"
#include "task/task.h"
@@ -72,6 +71,12 @@ public:
kIndexUnavailable
};
enum LoopMode {
kLoopModeOff,
kLoopModeLoop,
kLoopModeClamp
};
Decoder();
/**
@@ -82,6 +87,8 @@ public:
virtual bool SupportsVideo(){return false;}
virtual bool SupportsAudio(){return false;}
void IncrementAccessTime(qint64 t);
class CodecStream
{
public:
@@ -157,29 +164,13 @@ public:
struct RetrieveVideoParams
{
RetrieveVideoParams()
{
divider = 1;
maximum_format = VideoParams::kFormatInvalid;
}
int divider;
VideoParams::Format maximum_format;
void reset()
{
*this = RetrieveVideoParams();
}
bool operator==(const RetrieveVideoParams& rhs) const
{
return divider == rhs.divider && maximum_format == rhs.maximum_format;
}
bool operator!=(const RetrieveVideoParams& rhs) const
{
return !(*this == rhs);
}
Renderer *renderer = nullptr;
rational time;
int divider = 1;
VideoParams::Format maximum_format = VideoParams::kFormatInvalid;
CancelAtom *cancelled = nullptr;
VideoParams::ColorRange force_range = VideoParams::kColorRangeDefault;
VideoParams::Interlacing src_interlacing = VideoParams::kInterlaceNone;
};
/**
@@ -192,7 +183,7 @@ public:
*
* This function is thread safe and can only run while the decoder is open. \see Open()
*/
TexturePtr RetrieveVideo(Renderer *renderer, const rational& timecode, const RetrieveVideoParams& params, const QAtomicInt *cancelled = nullptr);
TexturePtr RetrieveVideo(const RetrieveVideoParams& p);
enum RetrieveAudioStatus {
kInvalid = -1,
@@ -209,7 +200,7 @@ public:
*
* This function is thread safe and can only run while the decoder is open. \see Open()
*/
RetrieveAudioStatus RetrieveAudio(SampleBuffer &dest, const TimeRange& range, const AudioParams& params, const QString &cache_path, Footage::LoopMode loop_mode, RenderMode::Mode mode);
RetrieveAudioStatus RetrieveAudio(SampleBuffer &dest, const TimeRange& range, const AudioParams& params, const QString &cache_path, LoopMode loop_mode, RenderMode::Mode mode);
/**
* @brief Determine the last time this decoder instance was used in any way
@@ -227,7 +218,7 @@ public:
*
* This function is re-entrant.
*/
virtual FootageDescription Probe(const QString& filename, const QAtomicInt* cancelled) const = 0;
virtual FootageDescription Probe(const QString& filename, CancelAtom *cancelled) const = 0;
/**
* @brief Closes media/deallocates memory
@@ -239,7 +230,7 @@ public:
/**
* @brief Conform audio stream
*/
bool ConformAudio(const QVector<QString> &output_filenames, const AudioParams &params, const QAtomicInt *cancelled = nullptr);
bool ConformAudio(const QVector<QString> &output_filenames, const AudioParams &params, CancelAtom *cancelled = nullptr);
/**
* @brief Create a Decoder instance using a Decoder ID
@@ -287,9 +278,9 @@ protected:
* Sub-classes must override this function IF they support video. Function is already mutexed
* so sub-classes don't need to worry about thread safety.
*/
virtual TexturePtr RetrieveVideoInternal(Renderer *renderer, const rational& timecode, const RetrieveVideoParams& params, const QAtomicInt *cancelled);
virtual TexturePtr RetrieveVideoInternal(const RetrieveVideoParams& p);
virtual bool ConformAudioInternal(const QVector<QString>& filenames, const AudioParams &params, const QAtomicInt* cancelled);
virtual bool ConformAudioInternal(const QVector<QString>& filenames, const AudioParams &params, CancelAtom *cancelled);
void SignalProcessingProgress(int64_t ts, int64_t duration);
@@ -316,7 +307,7 @@ signals:
private:
void UpdateLastAccessed();
bool RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, const TimeRange &range, Footage::LoopMode loop_mode, const AudioParams &params);
bool RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, const TimeRange &range, LoopMode loop_mode, const AudioParams &params);
CodecStream stream_;
@@ -324,6 +315,9 @@ private:
qint64 last_accessed_;
TexturePtr cached_texture_;
rational cached_time_;
};
uint qHash(Decoder::CodecStream stream, uint seed = 0);
app/codec/encoder.cpp
+246 -108
View File
@@ -23,6 +23,7 @@
#include <QFile>
#include "common/timecodefunctions.h"
#include "common/xmlutils.h"
#include "ffmpeg/ffmpegencoder.h"
#include "oiio/oiioencoder.h"
@@ -92,13 +93,22 @@ EncodingParams::EncodingParams() :
video_is_image_sequence_(false),
audio_enabled_(false),
audio_bit_rate_(0),
subtitles_enabled_(false)
subtitles_enabled_(false),
subtitles_are_sidecar_(false),
video_scaling_method_(kStretch),
has_custom_range_(false)
{
}
void EncodingParams::SetFilename(const QString &filename)
QDir EncodingParams::GetPresetPath()
{
filename_ = filename;
return QDir(FileFunctions::GetConfigurationLocation()).filePath(QStringLiteral("exportpresets"));
}
QStringList EncodingParams::GetListOfPresets()
{
QDir d = EncodingParams::GetPresetPath();
return d.entryList(QDir::Files);
}
void EncodingParams::EnableVideo(const VideoParams &video_params, const ExportCodec::Codec &vcodec)
@@ -121,134 +131,79 @@ void EncodingParams::EnableSubtitles(const ExportCodec::Codec &scodec)
subtitles_codec_ = scodec;
}
void EncodingParams::set_video_option(const QString &key, const QString &value)
void EncodingParams::EnableSidecarSubtitles(const ExportFormat::Format &sfmt, const ExportCodec::Codec &scodec)
{
video_opts_.insert(key, value);
subtitles_enabled_ = true;
subtitles_are_sidecar_ = true;
subtitle_sidecar_fmt_ = sfmt;
subtitles_codec_ = scodec;
}
void EncodingParams::set_video_bit_rate(const int64_t &rate)
void EncodingParams::DisableVideo()
{
video_bit_rate_ = rate;
video_enabled_ = false;
}
void EncodingParams::set_video_min_bit_rate(const int64_t &rate)
void EncodingParams::DisableAudio()
{
video_min_bit_rate_ = rate;
audio_enabled_ = false;
}
void EncodingParams::set_video_max_bit_rate(const int64_t &rate)
void EncodingParams::DisableSubtitles()
{
video_max_bit_rate_ = rate;
subtitles_enabled_ = false;
}
void EncodingParams::set_video_buffer_size(const int64_t &sz)
bool EncodingParams::Load(QXmlStreamReader *reader)
{
video_buffer_size_ = sz;
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("export")) {
int version = 0;
XMLAttributeLoop(reader, attr) {
if (attr.name() == QStringLiteral("version")) {
version = attr.value().toInt();
}
}
switch (version) {
case 1:
return LoadV1(reader);
}
} else {
reader->skipCurrentElement();
}
}
return false;
}
void EncodingParams::set_video_threads(const int &threads)
bool EncodingParams::Load(QIODevice *device)
{
video_threads_ = threads;
QXmlStreamReader reader(device);
return Load(&reader);
}
void EncodingParams::set_video_pix_fmt(const QString &s)
void EncodingParams::Save(QIODevice *device) const
{
video_pix_fmt_ = s;
}
const QString &EncodingParams::filename() const
{
return filename_;
}
bool EncodingParams::video_enabled() const
{
return video_enabled_;
}
const ExportCodec::Codec &EncodingParams::video_codec() const
{
return video_codec_;
}
const VideoParams &EncodingParams::video_params() const
{
return video_params_;
}
const QHash<QString, QString> &EncodingParams::video_opts() const
{
return video_opts_;
}
const int64_t &EncodingParams::video_bit_rate() const
{
return video_bit_rate_;
}
const int64_t &EncodingParams::video_min_bit_rate() const
{
return video_min_bit_rate_;
}
const int64_t &EncodingParams::video_max_bit_rate() const
{
return video_max_bit_rate_;
}
const int64_t &EncodingParams::video_buffer_size() const
{
return video_buffer_size_;
}
const int &EncodingParams::video_threads() const
{
return video_threads_;
}
const QString &EncodingParams::video_pix_fmt() const
{
return video_pix_fmt_;
}
bool EncodingParams::audio_enabled() const
{
return audio_enabled_;
}
const ExportCodec::Codec &EncodingParams::audio_codec() const
{
return audio_codec_;
}
const AudioParams &EncodingParams::audio_params() const
{
return audio_params_;
}
bool EncodingParams::subtitles_enabled() const
{
return subtitles_enabled_;
}
ExportCodec::Codec EncodingParams::subtitles_codec() const
{
return subtitles_codec_;
}
const rational &EncodingParams::GetExportLength() const
{
return export_length_;
}
void EncodingParams::SetExportLength(const rational &export_length)
{
export_length_ = export_length;
QXmlStreamWriter writer(device);
Save(&writer);
}
void EncodingParams::Save(QXmlStreamWriter *writer) const
{
writer->writeStartDocument();
writer->writeStartElement(QStringLiteral("export"));
writer->writeAttribute(QStringLiteral("version"), QString::number(kEncoderParamsVersion));
writer->writeTextElement(QStringLiteral("filename"), filename_);
writer->writeTextElement(QStringLiteral("format"), QString::number(format_));
writer->writeTextElement(QStringLiteral("range"), QString::number(has_custom_range_));
writer->writeTextElement(QStringLiteral("customrangein"), custom_range_.in().toString());
writer->writeTextElement(QStringLiteral("customrangeout"), custom_range_.out().toString());
writer->writeStartElement(QStringLiteral("video"));
@@ -262,10 +217,18 @@ void EncodingParams::Save(QXmlStreamWriter *writer) const
writer->writeTextElement(QStringLiteral("timebase"), video_params_.time_base().toString());
writer->writeTextElement(QStringLiteral("divider"), QString::number(video_params_.divider()));
writer->writeTextElement(QStringLiteral("bitrate"), QString::number(video_bit_rate_));
writer->writeTextElement(QStringLiteral("minbitrate"), QString::number(video_max_bit_rate_));
writer->writeTextElement(QStringLiteral("minbitrate"), QString::number(video_min_bit_rate_));
writer->writeTextElement(QStringLiteral("maxbitrate"), QString::number(video_max_bit_rate_));
writer->writeTextElement(QStringLiteral("bufsize"), QString::number(video_buffer_size_));
writer->writeTextElement(QStringLiteral("threads"), QString::number(video_threads_));
writer->writeTextElement(QStringLiteral("pixfmt"), video_pix_fmt_);
writer->writeTextElement(QStringLiteral("imgseq"), QString::number(video_is_image_sequence_));
writer->writeStartElement(QStringLiteral("color"));
writer->writeTextElement(QStringLiteral("output"), color_transform_.output());
writer->writeEndElement(); // colortransform
writer->writeTextElement(QStringLiteral("vscale"), QString::number(video_scaling_method_));
if (!video_opts_.isEmpty()) {
writer->writeStartElement(QStringLiteral("opts"));
@@ -297,7 +260,24 @@ void EncodingParams::Save(QXmlStreamWriter *writer) const
writer->writeTextElement(QStringLiteral("format"), QString::number(audio_params_.format()));
}
writer->writeStartElement(QStringLiteral("subtitles"));
writer->writeAttribute(QStringLiteral("enabled"), QString::number(subtitles_enabled_));
if (subtitles_enabled_) {
writer->writeTextElement(QStringLiteral("sidecar"), QString::number(subtitles_are_sidecar_));
writer->writeTextElement(QStringLiteral("sidecarformat"), QString::number(subtitle_sidecar_fmt_));
writer->writeTextElement(QStringLiteral("codec"), QString::number(subtitles_codec_));
}
writer->writeEndElement(); // subtitles
writer->writeEndElement(); // audio
writer->writeEndElement(); // export
writer->writeEndDocument();
}
Encoder* Encoder::CreateFromID(Type id, const EncodingParams& params)
@@ -346,6 +326,11 @@ Encoder *Encoder::CreateFromFormat(ExportFormat::Format f, const EncodingParams
return CreateFromID(GetTypeFromFormat(f), params);
}
Encoder *Encoder::CreateFromParams(const EncodingParams &params)
{
return CreateFromFormat(params.format(), params);
}
QStringList Encoder::GetPixelFormatsForCodec(ExportCodec::Codec c) const
{
return QStringList();
@@ -356,4 +341,157 @@ std::vector<AudioParams::Format> Encoder::GetSampleFormatsForCodec(ExportCodec::
return std::vector<AudioParams::Format>();
}
QMatrix4x4 EncodingParams::GenerateMatrix(EncodingParams::VideoScalingMethod method,
int source_width, int source_height,
int dest_width, int dest_height)
{
QMatrix4x4 preview_matrix;
if (method == EncodingParams::kStretch) {
return preview_matrix;
}
float export_ar = static_cast<float>(dest_width) / static_cast<float>(dest_height);
float source_ar = static_cast<float>(source_width) / static_cast<float>(source_height);
if (qFuzzyCompare(export_ar, source_ar)) {
return preview_matrix;
}
if ((export_ar > source_ar) == (method == EncodingParams::kFit)) {
preview_matrix.scale(source_ar / export_ar, 1.0F);
} else {
preview_matrix.scale(1.0F, export_ar / source_ar);
}
return preview_matrix;
}
bool EncodingParams::LoadV1(QXmlStreamReader *reader)
{
rational custom_range_in, custom_range_out;
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("filename")) {
filename_ = reader->readElementText();
} else if (reader->name() == QStringLiteral("format")) {
format_ = static_cast<ExportFormat::Format>(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("range")) {
has_custom_range_ = reader->readElementText().toInt();
} else if (reader->name() == QStringLiteral("customrangein")) {
custom_range_in = rational::fromString(reader->readElementText());
} else if (reader->name() == QStringLiteral("customrangeout")) {
custom_range_out = rational::fromString(reader->readElementText());
} else if (reader->name() == QStringLiteral("video")) {
XMLAttributeLoop(reader, attr) {
if (attr.name() == QStringLiteral("enabled")) {
video_enabled_ = attr.value().toInt();
}
}
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("codec")) {
video_codec_ = static_cast<ExportCodec::Codec>(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("width")) {
video_params_.set_width(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("height")) {
video_params_.set_height(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("format")) {
video_params_.set_format(static_cast<VideoParams::Format>(reader->readElementText().toInt()));
} else if (reader->name() == QStringLiteral("timebase")) {
video_params_.set_time_base(rational::fromString(reader->readElementText()));
} else if (reader->name() == QStringLiteral("divider")) {
video_params_.set_divider(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("bitrate")) {
video_bit_rate_ = reader->readElementText().toLongLong();
} else if (reader->name() == QStringLiteral("minbitrate")) {
video_min_bit_rate_ = reader->readElementText().toLongLong();
} else if (reader->name() == QStringLiteral("maxbitrate")) {
video_max_bit_rate_ = reader->readElementText().toLongLong();
} else if (reader->name() == QStringLiteral("bufsize")) {
video_buffer_size_ = reader->readElementText().toLongLong();
} else if (reader->name() == QStringLiteral("threads")) {
video_threads_ = reader->readElementText().toInt();
} else if (reader->name() == QStringLiteral("pixfmt")) {
video_pix_fmt_ = reader->readElementText();
} else if (reader->name() == QStringLiteral("imgseq")) {
video_is_image_sequence_ = reader->readElementText().toInt();
} else if (reader->name() == QStringLiteral("color")) {
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("output")) {
color_transform_ = reader->readElementText();
} else {
reader->skipCurrentElement();
}
}
} else if (reader->name() == QStringLiteral("vscale")) {
video_scaling_method_ = static_cast<VideoScalingMethod>(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("opts")) {
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("entry")) {
QString key, value;
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("key")) {
key = reader->readElementText();
} else if (reader->name() == QStringLiteral("value")) {
value = reader->readElementText();
} else {
reader->skipCurrentElement();
}
}
set_video_option(key, value);
} else {
reader->skipCurrentElement();
}
}
} else {
reader->skipCurrentElement();
}
}
} else if (reader->name() == QStringLiteral("audio")) {
XMLAttributeLoop(reader, attr) {
if (attr.name() == QStringLiteral("enabled")) {
audio_enabled_ = attr.value().toInt();
}
}
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("codec")) {
audio_codec_ = static_cast<ExportCodec::Codec>(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("samplerate")) {
audio_params_.set_sample_rate(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("channellayout")) {
audio_params_.set_channel_layout(reader->readElementText().toULongLong());
} else if (reader->name() == QStringLiteral("format")) {
audio_params_.set_format(static_cast<AudioParams::Format>(reader->readElementText().toInt()));
} else {
reader->skipCurrentElement();
}
}
} else if (reader->name() == QStringLiteral("subtitles")) {
XMLAttributeLoop(reader, attr) {
if (attr.name() == QStringLiteral("enabled")) {
subtitles_enabled_ = attr.value().toInt();
}
}
while (XMLReadNextStartElement(reader)) {
if (reader->name() == QStringLiteral("sidecar")) {
subtitles_are_sidecar_ = reader->readElementText().toInt();
} else if (reader->name() == QStringLiteral("sidecarformat")) {
subtitle_sidecar_fmt_ = static_cast<ExportFormat::Format>(reader->readElementText().toInt());
} else if (reader->name() == QStringLiteral("codec")) {
subtitles_codec_ = static_cast<ExportCodec::Codec>(reader->readElementText().toInt());
} else {
reader->skipCurrentElement();
}
}
} else {
reader->skipCurrentElement();
}
}
return true;
}
}
app/codec/encoder.h
+97 -48
View File
@@ -41,69 +41,109 @@ namespace olive {
class Encoder;
using EncoderPtr = std::shared_ptr<Encoder>;
class EncodingParams {
class EncodingParams
{
public:
enum VideoScalingMethod {
kFit,
kStretch,
kCrop
};
EncodingParams();
void SetFilename(const QString& filename);
static QDir GetPresetPath();
static QStringList GetListOfPresets();
bool IsValid() const
{
return video_enabled_ || audio_enabled_ || subtitles_enabled_;
}
void SetFilename(const QString& filename) { filename_ = filename; }
void EnableVideo(const VideoParams& video_params, const ExportCodec::Codec& vcodec);
void EnableAudio(const AudioParams& audio_params, const ExportCodec::Codec &acodec);
void EnableSubtitles(const ExportCodec::Codec &scodec);
void EnableSidecarSubtitles(const ExportFormat::Format &sfmt, const ExportCodec::Codec &scodec);
void set_video_option(const QString& key, const QString& value);
void set_video_bit_rate(const int64_t& rate);
void set_video_min_bit_rate(const int64_t& rate);
void set_video_max_bit_rate(const int64_t& rate);
void set_video_buffer_size(const int64_t& sz);
void set_video_threads(const int& threads);
void set_video_pix_fmt(const QString& s);
void set_video_is_image_sequence(bool s)
void DisableVideo();
void DisableAudio();
void DisableSubtitles();
const ExportFormat::Format &format() const { return format_; }
void set_format(const ExportFormat::Format &format) { format_ = format; }
void set_video_option(const QString& key, const QString& value) { video_opts_.insert(key, value); }
void set_video_bit_rate(const int64_t& rate) { video_bit_rate_ = rate; }
void set_video_min_bit_rate(const int64_t& rate) { video_min_bit_rate_ = rate; }
void set_video_max_bit_rate(const int64_t& rate) { video_max_bit_rate_ = rate; }
void set_video_buffer_size(const int64_t& sz) { video_buffer_size_ = sz; }
void set_video_threads(const int& threads) { video_threads_ = threads; }
void set_video_pix_fmt(const QString& s) { video_pix_fmt_ = s; }
void set_video_is_image_sequence(bool s) { video_is_image_sequence_ = s; }
void set_color_transform(const ColorTransform& color_transform) { color_transform_ = color_transform; }
const QString& filename() const { return filename_; }
bool video_enabled() const { return video_enabled_; }
const ExportCodec::Codec& video_codec() const { return video_codec_; }
const VideoParams& video_params() const { return video_params_; }
const QHash<QString, QString>& video_opts() const { return video_opts_; }
QString video_option(const QString &key) const { return video_opts_.value(key); }
bool has_video_opt(const QString &key) const { return video_opts_.contains(key); }
const int64_t& video_bit_rate() const { return video_bit_rate_; }
const int64_t& video_min_bit_rate() const { return video_min_bit_rate_; }
const int64_t& video_max_bit_rate() const { return video_max_bit_rate_; }
const int64_t& video_buffer_size() const { return video_buffer_size_; }
const int& video_threads() const { return video_threads_; }
const QString& video_pix_fmt() const { return video_pix_fmt_; }
bool video_is_image_sequence() const { return video_is_image_sequence_; }
const ColorTransform& color_transform() const { return color_transform_; }
bool audio_enabled() const { return audio_enabled_; }
const ExportCodec::Codec &audio_codec() const { return audio_codec_; }
const AudioParams& audio_params() const { return audio_params_; }
const int64_t& audio_bit_rate() const { return audio_bit_rate_; }
void set_audio_bit_rate(const int64_t& b) { audio_bit_rate_ = b; }
bool subtitles_enabled() const { return subtitles_enabled_; }
bool subtitles_are_sidecar() const { return subtitles_are_sidecar_; }
ExportFormat::Format subtitle_sidecar_fmt() const { return subtitle_sidecar_fmt_; }
ExportCodec::Codec subtitles_codec() const { return subtitles_codec_; }
const rational& GetExportLength() const { return export_length_; }
void SetExportLength(const rational& export_length) { export_length_ = export_length; }
bool Load(QIODevice *device);
bool Load(QXmlStreamReader *reader);
void Save(QIODevice *device) const;
void Save(QXmlStreamWriter* writer) const;
bool has_custom_range() const { return has_custom_range_; }
const TimeRange& custom_range() const { return custom_range_; }
void set_custom_range(const TimeRange& custom_range)
{
video_is_image_sequence_ = s;
has_custom_range_ = true;
custom_range_ = custom_range;
}
const QString& filename() const;
const VideoScalingMethod& video_scaling_method() const { return video_scaling_method_; }
void set_video_scaling_method(const VideoScalingMethod& video_scaling_method) { video_scaling_method_ = video_scaling_method; }
bool video_enabled() const;
const ExportCodec::Codec& video_codec() const;
const VideoParams& video_params() const;
const QHash<QString, QString>& video_opts() const;
const int64_t& video_bit_rate() const;
const int64_t& video_min_bit_rate() const;
const int64_t& video_max_bit_rate() const;
const int64_t& video_buffer_size() const;
const int& video_threads() const;
const QString& video_pix_fmt() const;
bool video_is_image_sequence() const
{
return video_is_image_sequence_;
}
bool audio_enabled() const;
const ExportCodec::Codec &audio_codec() const;
const AudioParams& audio_params() const;
const int64_t& audio_bit_rate() const
{
return audio_bit_rate_;
}
void set_audio_bit_rate(const int64_t& b)
{
audio_bit_rate_ = b;
}
bool subtitles_enabled() const;
ExportCodec::Codec subtitles_codec() const;
const rational& GetExportLength() const;
void SetExportLength(const rational& GetExportLength);
virtual void Save(QXmlStreamWriter* writer) const;
static QMatrix4x4 GenerateMatrix(VideoScalingMethod method,
int source_width, int source_height,
int dest_width, int dest_height);
private:
static const int kEncoderParamsVersion = 1;
bool LoadV1(QXmlStreamReader *reader);
QString filename_;
ExportFormat::Format format_;
bool video_enabled_;
ExportCodec::Codec video_codec_;
@@ -116,6 +156,7 @@ private:
int video_threads_;
QString video_pix_fmt_;
bool video_is_image_sequence_;
ColorTransform color_transform_;
bool audio_enabled_;
ExportCodec::Codec audio_codec_;
@@ -123,9 +164,15 @@ private:
int64_t audio_bit_rate_;
bool subtitles_enabled_;
bool subtitles_are_sidecar_;
ExportFormat::Format subtitle_sidecar_fmt_;
ExportCodec::Codec subtitles_codec_;
rational export_length_;
VideoScalingMethod video_scaling_method_;
bool has_custom_range_;
TimeRange custom_range_;
};
@@ -154,6 +201,8 @@ public:
static Encoder *CreateFromFormat(ExportFormat::Format f, const EncodingParams &params);
static Encoder *CreateFromParams(const EncodingParams &params);
virtual QStringList GetPixelFormatsForCodec(ExportCodec::Codec c) const;
virtual std::vector<AudioParams::Format> GetSampleFormatsForCodec(ExportCodec::Codec c) const;
app/codec/ffmpeg/ffmpegdecoder.cpp
+79 -21
View File
@@ -78,6 +78,7 @@ bool FFmpegDecoder::OpenInternal()
working_frame_ = av_frame_alloc();
working_packet_ = av_packet_alloc();
frame_rate_tb_ = rational::NaN;
return true;
}
@@ -140,28 +141,32 @@ bool FFmpegDecoder::OpenInternal()
return output_frame;
}*/
TexturePtr FFmpegDecoder::RetrieveVideoInternal(Renderer *renderer, const rational &timecode, const RetrieveVideoParams &params, const QAtomicInt *cancelled)
TexturePtr FFmpegDecoder::RetrieveVideoInternal(const RetrieveVideoParams &p)
{
if (AVFramePtr f = RetrieveFrame(timecode, cancelled)) {
if (cancelled && *cancelled) {
if (AVFramePtr f = RetrieveFrame(p.time, p.cancelled)) {
if (p.cancelled && p.cancelled->IsCancelled()) {
return nullptr;
}
if (InitScaler(f.get(), params)) {
int &src_fmt = f.get()->format;
src_fmt = FFmpegUtils::ConvertJPEGSpaceToRegularSpace(static_cast<AVPixelFormat>(src_fmt));
f->color_range = p.force_range == VideoParams::kColorRangeFull ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
if (InitScaler(f.get(), p)) {
VideoParams vp(instance_.avstream()->codecpar->width,
instance_.avstream()->codecpar->height,
native_output_pix_fmt_,
native_channel_count_,
av_guess_sample_aspect_ratio(instance_.fmt_ctx(), instance_.avstream(), nullptr),
VideoParams::kInterlaceNone,
params.divider);
p.divider);
TexturePtr tex = nullptr;
const bool hwscale = true;
bool hwscale = true;
// Attempt to use GLSL shader for faster YUV to RGB conversion
if (hwscale) {
AVPixelFormat src_fmt = AVPixelFormat(f.get()->format);
if (src_fmt == AV_PIX_FMT_YUV420P
|| src_fmt == AV_PIX_FMT_YUV422P
|| src_fmt == AV_PIX_FMT_YUV444P
@@ -173,7 +178,7 @@ TexturePtr FFmpegDecoder::RetrieveVideoInternal(Renderer *renderer, const ration
|| src_fmt == AV_PIX_FMT_YUV444P12LE) {
if (Yuv2RgbShader.isNull()) {
// Compile shader
Yuv2RgbShader = renderer->CreateNativeShader(ShaderCode(FileFunctions::ReadFileAsString(QStringLiteral(":/shaders/yuv2rgb.frag"))));
Yuv2RgbShader = p.renderer->CreateNativeShader(ShaderCode(FileFunctions::ReadFileAsString(QStringLiteral(":/shaders/yuv2rgb.frag"))));
}
if (!Yuv2RgbShader.isNull()) {
@@ -205,7 +210,7 @@ TexturePtr FFmpegDecoder::RetrieveVideoInternal(Renderer *renderer, const ration
plane_params.set_channel_count(1);
plane_params.set_divider(1);
plane_params.set_format(native_internal_pix_fmt_);
TexturePtr y_plane = renderer->CreateTexture(plane_params, f->data[0], f->linesize[0] / px_size);
TexturePtr y_plane = p.renderer->CreateTexture(plane_params, f->data[0], f->linesize[0] / px_size);
if (src_fmt == AV_PIX_FMT_YUV420P
|| src_fmt == AV_PIX_FMT_YUV422P
@@ -222,17 +227,47 @@ TexturePtr FFmpegDecoder::RetrieveVideoInternal(Renderer *renderer, const ration
plane_params.set_height(plane_params.height()/2);
}
TexturePtr u_plane = renderer->CreateTexture(plane_params, f->data[1], f->linesize[1] / px_size);
TexturePtr v_plane = renderer->CreateTexture(plane_params, f->data[2], f->linesize[2] / px_size);
TexturePtr u_plane = p.renderer->CreateTexture(plane_params, f->data[1], f->linesize[1] / px_size);
TexturePtr v_plane = p.renderer->CreateTexture(plane_params, f->data[2], f->linesize[2] / px_size);
ShaderJob job;
job.Insert(QStringLiteral("y_channel"), NodeValue(NodeValue::kTexture, QVariant::fromValue(y_plane)));
job.Insert(QStringLiteral("u_channel"), NodeValue(NodeValue::kTexture, QVariant::fromValue(u_plane)));
job.Insert(QStringLiteral("v_channel"), NodeValue(NodeValue::kTexture, QVariant::fromValue(v_plane)));
job.Insert(QStringLiteral("bits_per_pixel"), NodeValue(NodeValue::kInt, bits_per_pixel));
job.Insert(QStringLiteral("full_range"), NodeValue(NodeValue::kBoolean, f->color_range == AVCOL_RANGE_JPEG));
tex = renderer->CreateTexture(vp);
renderer->BlitToTexture(Yuv2RgbShader, job, tex.get(), false);
const int *yuv_coeffs = sws_getCoefficients(FFmpegUtils::GetSwsColorspaceFromAVColorSpace(f.get()->colorspace));
job.Insert(QStringLiteral("yuv_crv"), NodeValue(NodeValue::kInt, yuv_coeffs[0]));
job.Insert(QStringLiteral("yuv_cgu"), NodeValue(NodeValue::kInt, yuv_coeffs[2]));
job.Insert(QStringLiteral("yuv_cgv"), NodeValue(NodeValue::kInt, yuv_coeffs[3]));
job.Insert(QStringLiteral("yuv_cbu"), NodeValue(NodeValue::kInt, yuv_coeffs[1]));
int interlacing = 0;
if (p.src_interlacing != VideoParams::kInterlaceNone) {
if (frame_rate_tb_.isNull()) {
frame_rate_tb_ = av_guess_frame_rate(instance_.fmt_ctx(), instance_.avstream(), f.get());
// Double frame rate for interlaced fields
frame_rate_tb_ *= 2;
// Flip frame rate so it can be used as a timebase
frame_rate_tb_.flip();
}
int64_t req = Timecode::time_to_timestamp(p.time, frame_rate_tb_);
int64_t frm = Timecode::rescale_timestamp(f->pts - instance_.avstream()->start_time, instance_.avstream()->time_base, frame_rate_tb_);
bool first = (req == frm);
bool top_first = (p.src_interlacing == VideoParams::kInterlacedTopFirst);
interlacing = (first == top_first) ? 1 : 2;
}
job.Insert(QStringLiteral("interlacing"), NodeValue(NodeValue::kInt, interlacing));
job.Insert(QStringLiteral("pixel_height"), NodeValue(NodeValue::kInt, f->height));
tex = p.renderer->CreateTexture(vp);
p.renderer->BlitToTexture(Yuv2RgbShader, job, tex.get(), false);
}
}
}
@@ -240,6 +275,7 @@ TexturePtr FFmpegDecoder::RetrieveVideoInternal(Renderer *renderer, const ration
if (!tex) {
// Fallback to software pixel format conversion
int r;
r = av_buffersrc_add_frame_flags(buffersrc_ctx_, f.get(), AV_BUFFERSRC_FLAG_KEEP_REF);
if (r < 0) {
return nullptr;
@@ -249,7 +285,7 @@ TexturePtr FFmpegDecoder::RetrieveVideoInternal(Renderer *renderer, const ration
return nullptr;
}
tex = renderer->CreateTexture(vp, working_frame_->data[0], working_frame_->linesize[0] / vp.GetBytesPerPixel());
tex = p.renderer->CreateTexture(vp, working_frame_->data[0], working_frame_->linesize[0] / vp.GetBytesPerPixel());
av_frame_unref(working_frame_);
}
@@ -288,7 +324,7 @@ QString FFmpegDecoder::id() const
return QStringLiteral("ffmpeg");
}
FootageDescription FFmpegDecoder::Probe(const QString &filename, const QAtomicInt *cancelled) const
FootageDescription FFmpegDecoder::Probe(const QString &filename, CancelAtom *cancelled) const
{
// Return value
FootageDescription desc(id());
@@ -414,6 +450,7 @@ FootageDescription FFmpegDecoder::Probe(const QString &filename, const QAtomicIn
stream.set_start_time(avstream->start_time);
stream.set_time_base(avstream->time_base);
stream.set_duration(avstream->duration);
stream.set_color_range(avstream->codecpar->color_range == AVCOL_RANGE_JPEG ? VideoParams::kColorRangeFull : VideoParams::kColorRangeLimited);
// Defaults to false, requires user intervention if incorrect
stream.set_premultiplied_alpha(false);
@@ -498,6 +535,8 @@ FootageDescription FFmpegDecoder::Probe(const QString &filename, const QAtomicIn
}
desc.SetStreamCount(fmt_ctx->nb_streams);
}
// Free all memory
@@ -513,7 +552,7 @@ QString FFmpegDecoder::FFmpegError(int error_code)
return QStringLiteral("%1 %2").arg(QString::number(error_code), err);
}
bool FFmpegDecoder::ConformAudioInternal(const QVector<QString> &filenames, const AudioParams &params, const QAtomicInt *cancelled)
bool FFmpegDecoder::ConformAudioInternal(const QVector<QString> &filenames, const AudioParams &params, CancelAtom *cancelled)
{
// Iterate through each audio frame and extract the PCM data
@@ -563,7 +602,7 @@ bool FFmpegDecoder::ConformAudioInternal(const QVector<QString> &filenames, cons
while (true) {
// Check if we have a `cancelled` ptr and its value
if (cancelled && *cancelled) {
if (cancelled && cancelled->IsCancelled()) {
break;
}
@@ -743,7 +782,7 @@ void FFmpegDecoder::ClearFrameCache()
}
}
AVFramePtr FFmpegDecoder::RetrieveFrame(const rational& time, const QAtomicInt *cancelled)
AVFramePtr FFmpegDecoder::RetrieveFrame(const rational& time, CancelAtom *cancelled)
{
int64_t target_ts = GetTimeInTimebaseUnits(time, instance_.avstream()->time_base, instance_.avstream()->start_time);
@@ -781,7 +820,7 @@ AVFramePtr FFmpegDecoder::RetrieveFrame(const rational& time, const QAtomicInt *
while (true) {
// Break out of loop if we've cancelled
if (cancelled && *cancelled) {
if (cancelled && cancelled->IsCancelled()) {
break;
}
@@ -792,7 +831,7 @@ AVFramePtr FFmpegDecoder::RetrieveFrame(const rational& time, const QAtomicInt *
// Pull from the decoder
ret = instance_.GetFrame(working_packet_, filtered.get());
if (cancelled && *cancelled) {
if (cancelled && cancelled->IsCancelled()) {
break;
}
@@ -877,7 +916,12 @@ AVFramePtr FFmpegDecoder::RetrieveFrame(const rational& time, const QAtomicInt *
bool FFmpegDecoder::InitScaler(AVFrame *input, const RetrieveVideoParams& params)
{
if (params == filter_params_ && filter_graph_ && input_fmt_ == input->format) {
if (params.divider == filter_params_.divider
&& params.force_range == filter_params_.force_range
&& params.maximum_format == filter_params_.maximum_format
&& params.src_interlacing == filter_params_.src_interlacing
&& filter_graph_
&& input_fmt_ == input->format) {
// We have an appropriate filter for these parameters, just return true
return true;
}
@@ -942,6 +986,20 @@ bool FFmpegDecoder::InitScaler(AVFrame *input, const RetrieveVideoParams& params
// Link filters as necessary
AVFilterContext *last_filter = buffersrc_ctx_;
// Add deinterlace filter if necessary
if (filter_params_.src_interlacing != VideoParams::kInterlaceNone) {
AVFilterContext* deint_filter;
snprintf(filter_args, kFilterArgSz, "mode=1:parity=%s",
filter_params_.src_interlacing == VideoParams::kInterlacedTopFirst ? "0" : "1");
avfilter_graph_create_filter(&deint_filter, avfilter_get_by_name("yadif"), "deint", filter_args, nullptr, filter_graph_);
avfilter_link(last_filter, 0, deint_filter, 0);
last_filter = deint_filter;
}
// Add scale filter if necessary
int dst_width, dst_height;
if (filter_params_.divider > 1) {
app/codec/ffmpeg/ffmpegdecoder.h
+7 -11
View File
@@ -25,27 +25,22 @@
#include <inttypes.h>
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
}
#include <QAtomicInt>
#include <QTimer>
#include <QVector>
#include <QWaitCondition>
#include "codec/decoder.h"
#include "common/ffmpegutils.h"
namespace olive {
using AVFramePtr = std::shared_ptr<AVFrame>;
inline AVFramePtr CreateAVFramePtr(AVFrame *f)
{
return std::shared_ptr<AVFrame>(f, [](AVFrame *g){ av_frame_free(&g); });
}
/**
* @brief A Decoder derivative that wraps FFmpeg functions as on Olive decoder
*/
@@ -64,12 +59,12 @@ public:
virtual bool SupportsVideo() override{return true;}
virtual bool SupportsAudio() override{return true;}
virtual FootageDescription Probe(const QString &filename, const QAtomicInt *cancelled) const override;
virtual FootageDescription Probe(const QString &filename, CancelAtom *cancelled) const override;
protected:
virtual bool OpenInternal() override;
virtual TexturePtr RetrieveVideoInternal(Renderer *renderer, const rational& timecode, const RetrieveVideoParams& params, const QAtomicInt *cancelled) override;
virtual bool ConformAudioInternal(const QVector<QString>& filenames, const AudioParams &params, const QAtomicInt* cancelled) override;
virtual TexturePtr RetrieveVideoInternal(const RetrieveVideoParams& p) override;
virtual bool ConformAudioInternal(const QVector<QString>& filenames, const AudioParams &params, CancelAtom *cancelled) override;
virtual void CloseInternal() override;
private:
@@ -151,7 +146,7 @@ private:
void ClearFrameCache();
AVFramePtr RetrieveFrame(const rational &time, const QAtomicInt *cancelled);
AVFramePtr RetrieveFrame(const rational &time, CancelAtom *cancelled);
void RemoveFirstFrame();
@@ -165,6 +160,7 @@ private:
VideoParams::Format native_internal_pix_fmt_;
VideoParams::Format native_output_pix_fmt_;
int native_channel_count_;
rational frame_rate_tb_;
AVFrame *working_frame_;
AVPacket *working_packet_;
app/codec/ffmpeg/ffmpegencoder.cpp
+104 -80
View File
@@ -21,6 +21,8 @@
#include "ffmpegencoder.h"
extern "C" {
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/pixdesc.h>
}
@@ -36,8 +38,9 @@ FFmpegEncoder::FFmpegEncoder(const EncodingParams &params) :
fmt_ctx_(nullptr),
video_stream_(nullptr),
video_codec_ctx_(nullptr),
video_alpha_scale_ctx_(nullptr),
video_noalpha_scale_ctx_(nullptr),
video_scale_ctx_(nullptr),
video_buffersrc_ctx_(nullptr),
video_buffersink_ctx_(nullptr),
audio_stream_(nullptr),
audio_codec_ctx_(nullptr),
audio_resample_ctx_(nullptr),
@@ -54,6 +57,11 @@ QStringList FFmpegEncoder::GetPixelFormatsForCodec(ExportCodec::Codec c) const
if (codec_info) {
for (int i=0; codec_info->pix_fmts[i]!=-1; i++) {
if (FFmpegUtils::ConvertJPEGSpaceToRegularSpace(codec_info->pix_fmts[i]) != codec_info->pix_fmts[i]) {
// This is a deprecated "JPEG" space, skip it
continue;
}
const char* pix_fmt_name = av_get_pix_fmt_name(codec_info->pix_fmts[i]);
pix_fmts.append(pix_fmt_name);
}
@@ -142,29 +150,59 @@ bool FFmpegEncoder::Open()
// This is the pixel format the encoder wants to encode to
AVPixelFormat encoder_pix_fmt = video_codec_ctx_->pix_fmt;
// Set up a scaling context - if the native pixel format is not equal to the encoder's, we'll need to convert it
// before encoding. Even if we don't, this may be useful for converting between linesizes, etc.
video_alpha_scale_ctx_ = sws_getContext(params().video_params().width(),
params().video_params().height(),
src_alpha_pix_fmt,
params().video_params().width(),
params().video_params().height(),
encoder_pix_fmt,
0,
nullptr,
nullptr,
nullptr);
video_scale_ctx_ = avfilter_graph_alloc();
if (!video_scale_ctx_) {
return false;
}
video_noalpha_scale_ctx_ = sws_getContext(params().video_params().width(),
params().video_params().height(),
src_noalpha_pix_fmt,
params().video_params().width(),
params().video_params().height(),
encoder_pix_fmt,
0,
nullptr,
nullptr,
nullptr);
static const int FILTER_ARG_SZ = 1024;
char filter_args[FILTER_ARG_SZ];
snprintf(filter_args, FILTER_ARG_SZ, "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
params().video_params().effective_width(),
params().video_params().effective_height(),
src_alpha_pix_fmt,
params().video_params().time_base().numerator(),
params().video_params().time_base().denominator(),
params().video_params().pixel_aspect_ratio().numerator(),
params().video_params().pixel_aspect_ratio().denominator());
avfilter_graph_create_filter(&video_buffersrc_ctx_, avfilter_get_by_name("buffer"), "in", filter_args, nullptr, video_scale_ctx_);
avfilter_graph_create_filter(&video_buffersink_ctx_, avfilter_get_by_name("buffersink"), "out", nullptr, nullptr, video_scale_ctx_);
AVFilterContext *last_filter = video_buffersrc_ctx_;
{
// Set color range
AVFilterContext* range_filter;
snprintf(filter_args, FILTER_ARG_SZ, "in_range=full:out_range=%s",
params().video_params().color_range() == VideoParams::kColorRangeFull ? "full" : "limited");
avfilter_graph_create_filter(&range_filter, avfilter_get_by_name("scale"), "range", filter_args, nullptr, video_scale_ctx_);
avfilter_link(last_filter, 0, range_filter, 0);
last_filter = range_filter;
}
if (src_alpha_pix_fmt != encoder_pix_fmt) {
// Transform pixel format
AVFilterContext* format_filter;
snprintf(filter_args, FILTER_ARG_SZ, "pix_fmts=%u", encoder_pix_fmt);
avfilter_graph_create_filter(&format_filter, avfilter_get_by_name("format"), "format", filter_args, nullptr, video_scale_ctx_);
avfilter_link(last_filter, 0, format_filter, 0);
last_filter = format_filter;
}
avfilter_link(last_filter, 0, video_buffersink_ctx_, 0);
if (avfilter_graph_config(video_scale_ctx_, nullptr) < 0) {
SetError(tr("Failed to configure filter graph"));
return false;
}
}
// Initialize an audio stream if it's enabled
@@ -203,67 +241,41 @@ bool FFmpegEncoder::Open()
bool FFmpegEncoder::WriteFrame(FramePtr frame, rational time)
{
bool success = false;
AVFrame* encoded_frame = av_frame_alloc();
int error_code;
const char* input_data;
int input_linesize;
// Frame must be video
encoded_frame->width = frame->width();
encoded_frame->height = frame->height();
encoded_frame->format = video_codec_ctx_->pix_fmt;
// Set interlacing
if (frame->video_params().interlacing() != VideoParams::kInterlaceNone) {
encoded_frame->interlaced_frame = 1;
if (frame->video_params().interlacing() == VideoParams::kInterlacedTopFirst) {
encoded_frame->top_field_first = 1;
} else {
encoded_frame->top_field_first = 0;
}
}
error_code = av_frame_get_buffer(encoded_frame, 0);
if (error_code < 0) {
FFmpegError(tr("Failed to create AVFrame buffer"), error_code);
goto fail;
}
// We may need to convert this frame to a frame that swscale will understand
if (frame->format() != video_conversion_fmt_) {
frame = frame->convert(video_conversion_fmt_);
}
// Use swscale context to convert formats/linesizes
input_data = frame->const_data();
input_linesize = frame->linesize_bytes();
AVFramePtr input_frame = CreateAVFramePtr(av_frame_alloc());
input_frame->width = frame->width();
input_frame->height = frame->height();
input_frame->format = FFmpegUtils::GetFFmpegPixelFormat(frame->format(), frame->channel_count());
input_frame->data[0] = reinterpret_cast<uint8_t*>(frame->data());
input_frame->linesize[0] = frame->linesize_bytes();
error_code = sws_scale((frame->channel_count() == VideoParams::kRGBAChannelCount) ? video_alpha_scale_ctx_ : video_noalpha_scale_ctx_,
reinterpret_cast<const uint8_t**>(&input_data),
&input_linesize,
0,
frame->height(),
encoded_frame->data,
encoded_frame->linesize);
input_frame->color_primaries = video_codec_ctx_->color_primaries;
input_frame->color_trc = video_codec_ctx_->color_trc;
input_frame->colorspace = video_codec_ctx_->colorspace;
input_frame->color_range = video_codec_ctx_->color_range;
int r;
r = av_buffersrc_add_frame_flags(video_buffersrc_ctx_, input_frame.get(), AV_BUFFERSRC_FLAG_KEEP_REF);
if (r < 0) {
FFmpegError(tr("Failed to add frame to filter graph"), r);
return false;
}
if (error_code < 0) {
FFmpegError(tr("Failed to scale frame"), error_code);
goto fail;
AVFramePtr encoded_frame = CreateAVFramePtr(av_frame_alloc());
r = av_buffersink_get_frame(video_buffersink_ctx_, encoded_frame.get());
if (r < 0) {
FFmpegError(tr("Failed to retrieve frame from buffer sink"), r);
return false;
}
encoded_frame->pts = qRound64(time.toDouble() / av_q2d(video_codec_ctx_->time_base));
success = WriteAVFrame(encoded_frame, video_codec_ctx_, video_stream_);
fail:
av_frame_free(&encoded_frame);
return success;
return WriteAVFrame(encoded_frame.get(), video_codec_ctx_, video_stream_);
}
bool FFmpegEncoder::WriteAudio(const SampleBuffer &audio)
@@ -484,14 +496,11 @@ void FFmpegEncoder::Close()
audio_frame_ = nullptr;
}
if (video_alpha_scale_ctx_) {
sws_freeContext(video_alpha_scale_ctx_);
video_alpha_scale_ctx_ = nullptr;
}
if (video_noalpha_scale_ctx_) {
sws_freeContext(video_noalpha_scale_ctx_);
video_noalpha_scale_ctx_ = nullptr;
if (video_scale_ctx_) {
avfilter_graph_free(&video_scale_ctx_);
video_scale_ctx_ = nullptr;
video_buffersrc_ctx_ = nullptr;
video_buffersink_ctx_ = nullptr;
}
if (video_codec_ctx_) {
@@ -606,6 +615,7 @@ bool FFmpegEncoder::InitializeStream(AVMediaType type, AVStream** stream_ptr, AV
codec_ctx->time_base = params().video_params().frame_rate_as_time_base().toAVRational();
codec_ctx->framerate = params().video_params().frame_rate().toAVRational();
codec_ctx->pix_fmt = av_get_pix_fmt(params().video_pix_fmt().toUtf8());
codec_ctx->color_range = params().video_params().color_range() == VideoParams::kColorRangeFull ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
if (params().video_params().interlacing() != VideoParams::kInterlaceNone) {
// FIXME: I actually don't know what these flags do, the documentation helpfully doesn't
@@ -628,8 +638,10 @@ bool FFmpegEncoder::InitializeStream(AVMediaType type, AVStream** stream_ptr, AV
// Set custom options
{
for (auto i=params().video_opts().begin();i!=params().video_opts().end();i++) {
if (!i.key().startsWith(QStringLiteral("ove_"))) {
av_opt_set(codec_ctx->priv_data, i.key().toUtf8(), i.value().toUtf8(), AV_OPT_SEARCH_CHILDREN);
}
}
if (params().video_bit_rate() > 0) {
codec_ctx->bit_rate = params().video_bit_rate();
@@ -646,6 +658,18 @@ bool FFmpegEncoder::InitializeStream(AVMediaType type, AVStream** stream_ptr, AV
if (params().video_buffer_size() > 0) {
codec_ctx->rc_buffer_size = static_cast<int>(params().video_buffer_size());
}
// nclc tags. See https://ffmpeg.org/doxygen/4.0/pixfmt_8h.html#ad384ee5a840bafd73daef08e6d9cafe7
// ffprobe -v error -show_format -show_streams "C:\Users\Tom\Documents\srgb correct tags.mov"
if (params().color_transform().output().contains(QStringLiteral("sRGB"), Qt::CaseInsensitive)) {
codec_ctx->color_primaries = AVCOL_PRI_BT709;
codec_ctx->color_trc = AVCOL_TRC_IEC61966_2_1;
codec_ctx->colorspace = AVCOL_SPC_BT709;
} else { // Assume Rec.709
codec_ctx->color_primaries = AVCOL_PRI_BT709;
codec_ctx->color_trc = AVCOL_TRC_BT709;
codec_ctx->colorspace = AVCOL_SPC_BT709;
}
}
} else if (type == AVMEDIA_TYPE_AUDIO) {
app/codec/ffmpeg/ffmpegencoder.h
+4 -3
View File
@@ -23,8 +23,8 @@
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
#include <libavutil/opt.h>
}
@@ -88,8 +88,9 @@ private:
AVStream* video_stream_;
AVCodecContext* video_codec_ctx_;
SwsContext* video_alpha_scale_ctx_;
SwsContext* video_noalpha_scale_ctx_;
AVFilterGraph *video_scale_ctx_;
AVFilterContext *video_buffersrc_ctx_;
AVFilterContext *video_buffersink_ctx_;
VideoParams::Format video_conversion_fmt_;
AVStream* audio_stream_;
app/codec/footagemeta.h
-10
View File
@@ -1,10 +0,0 @@
#ifndef FOOTAGEMETA_H
#define FOOTAGEMETA_H
struct FootageData {
struct StreamData {
};
};
#endif // FOOTAGEMETA_H
app/codec/oiio/oiiodecoder.cpp
+12 -11
View File
@@ -45,7 +45,7 @@ QString OIIODecoder::id() const
return QStringLiteral("oiio");
}
FootageDescription OIIODecoder::Probe(const QString &filename, const QAtomicInt* cancelled) const
FootageDescription OIIODecoder::Probe(const QString &filename, CancelAtom *cancelled) const
{
Q_UNUSED(cancelled)
@@ -73,7 +73,8 @@ FootageDescription OIIODecoder::Probe(const QString &filename, const QAtomicInt*
bool stream_enabled = true;
for (int i=0; in->seek_subimage(i, 0); i++) {
int i;
for (i=0; in->seek_subimage(i, 0); i++) {
OIIO::ImageSpec spec = in->spec();
VideoParams video_params = GetVideoParamsFromImageSpec(spec);
@@ -104,6 +105,8 @@ FootageDescription OIIODecoder::Probe(const QString &filename, const QAtomicInt*
desc.AddVideoStream(video_params);
}
desc.SetStreamCount(i);
// If we're here, we have a successful image open
in->close();
@@ -116,22 +119,20 @@ bool OIIODecoder::OpenInternal()
return OpenImageHandler(stream().filename(), stream().stream());
}
TexturePtr OIIODecoder::RetrieveVideoInternal(Renderer *renderer, const rational &timecode, const RetrieveVideoParams &params, const QAtomicInt *cancelled)
TexturePtr OIIODecoder::RetrieveVideoInternal(const RetrieveVideoParams &p)
{
Q_UNUSED(timecode)
Q_UNUSED(cancelled)
VideoParams vp = GetVideoParamsFromImageSpec(image_->spec());
vp.set_divider(params.divider);
vp.set_divider(p.divider);
if (!buffer_.is_allocated() || last_params_ != params) {
last_params_ = params;
if (!buffer_.is_allocated()
|| last_params_.divider != p.divider) {
last_params_ = p;
buffer_.destroy();
buffer_.set_video_params(vp);
buffer_.allocate();
if (params.divider == 1) {
if (p.divider == 1) {
// Just upload straight to the buffer
image_->read_image(oiio_pix_fmt_, buffer_.data(), OIIO::AutoStride, buffer_.linesize_bytes());
} else {
@@ -153,7 +154,7 @@ TexturePtr OIIODecoder::RetrieveVideoInternal(Renderer *renderer, const rational
}
}
return renderer->CreateTexture(vp, buffer_.data(), buffer_.linesize_pixels());
return p.renderer->CreateTexture(vp, buffer_.data(), buffer_.linesize_pixels());
}
void OIIODecoder::CloseInternal()
app/codec/oiio/oiiodecoder.h
+2 -2
View File
@@ -40,11 +40,11 @@ public:
virtual bool SupportsVideo() override{return true;}
virtual FootageDescription Probe(const QString& filename, const QAtomicInt* cancelled) const override;
virtual FootageDescription Probe(const QString& filename, CancelAtom *cancelled) const override;
protected:
virtual bool OpenInternal() override;
virtual TexturePtr RetrieveVideoInternal(Renderer *renderer, const rational& timecode, const RetrieveVideoParams& params, const QAtomicInt *cancelled) override;
virtual TexturePtr RetrieveVideoInternal(const RetrieveVideoParams& p) override;
virtual void CloseInternal() override;
private:
app/common/CMakeLists.txt
-2
View File
@@ -52,8 +52,6 @@ set(OLIVE_SOURCES
common/ratiodialog.h
common/rational.cpp
common/rational.h
common/threadedobject.cpp
common/threadedobject.h
common/threadsafemap.h
common/timecodefunctions.cpp
common/timecodefunctions.h
app/common/cancelableobject.h
+11 -8
View File
@@ -21,35 +21,38 @@
#ifndef CANCELABLEOBJECT_H
#define CANCELABLEOBJECT_H
#include <QAtomicInt>
#include "common/define.h"
#include "render/cancelatom.h"
namespace olive {
class CancelableObject {
public:
CancelableObject() :
cancelled_(false)
CancelableObject()
{
}
void Cancel()
{
cancelled_ = true;
cancel_.Cancel();
CancelEvent();
}
const QAtomicInt& IsCancelled() const
CancelAtom *GetCancelAtom()
{
return cancelled_;
return &cancel_;
}
bool IsCancelled()
{
return cancel_.IsCancelled();
}
protected:
virtual void CancelEvent(){}
private:
QAtomicInt cancelled_;
CancelAtom cancel_;
};
app/common/ffmpegutils.cpp
+37
View File
@@ -111,6 +111,43 @@ AVSampleFormat FFmpegUtils::GetFFmpegSampleFormat(const AudioParams::Format &smp
return AV_SAMPLE_FMT_NONE;
}
int FFmpegUtils::GetSwsColorspaceFromAVColorSpace(AVColorSpace cs)
{
switch (cs) {
case AVCOL_SPC_BT709:
return SWS_CS_ITU709;
case AVCOL_SPC_FCC:
return SWS_CS_FCC;
case AVCOL_SPC_BT470BG:
return SWS_CS_ITU624;
case AVCOL_SPC_SMPTE170M:
return SWS_CS_SMPTE170M;
case AVCOL_SPC_SMPTE240M:
return SWS_CS_SMPTE240M;
case AVCOL_SPC_BT2020_NCL:
return SWS_CS_BT2020;
default:
break;
}
return SWS_CS_DEFAULT;
}
AVPixelFormat FFmpegUtils::ConvertJPEGSpaceToRegularSpace(AVPixelFormat f)
{
switch (f) {
case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
case AV_PIX_FMT_YUVJ440P: return AV_PIX_FMT_YUV440P;
case AV_PIX_FMT_YUVJ411P: return AV_PIX_FMT_YUV411P;
default:
break;
}
return f;
}
AVPixelFormat FFmpegUtils::GetFFmpegPixelFormat(const VideoParams::Format &pix_fmt, int channel_layout)
{
if (channel_layout == VideoParams::kRGBChannelCount) {
app/common/ffmpegutils.h
+24
View File
@@ -24,6 +24,7 @@
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
#include "render/audioparams.h"
@@ -57,8 +58,31 @@ public:
* @brief Returns an FFmpeg sample format type for a given native type
*/
static AVSampleFormat GetFFmpegSampleFormat(const AudioParams::Format &smp_fmt);
/**
* @brief Returns an SWS_CS_* macro from an AVColorSpace enum member
*
* Why aren't these the same thing anyway? And for that matter, why doesn't FFmpeg provide a
* convenience function to do this conversion for us? Who knows, but here we are.
*/
static int GetSwsColorspaceFromAVColorSpace(AVColorSpace cs);
/**
* @brief Convert "JPEG"/full-range colorspace to its regular counterpart
*
* "JPEG "spaces are deprecated in favor of the regular space and setting `color_range`. For the
* time being, FFmpeg still uses these JPEG spaces, so for simplicity (since we *are* color_range
* aware), we use this function.
*/
static AVPixelFormat ConvertJPEGSpaceToRegularSpace(AVPixelFormat f);
};
using AVFramePtr = std::shared_ptr<AVFrame>;
inline AVFramePtr CreateAVFramePtr(AVFrame *f)
{
return std::shared_ptr<AVFrame>(f, [](AVFrame *g){ av_frame_free(&g); });
}
}
#endif // FFMPEGABSTRACTION_H
app/common/qtutils.cpp
+43 -7
View File
@@ -20,6 +20,8 @@
#include "qtutils.h"
#include <QDebug>
namespace olive {
int QtUtils::QFontMetricsWidth(QFontMetrics fm, const QString& s) {
@@ -45,7 +47,7 @@ QFrame *QtUtils::CreateVerticalLine()
return l;
}
int QtUtils::MessageBox(QWidget *parent, QMessageBox::Icon icon, const QString &title, const QString &message, QMessageBox::StandardButtons buttons)
int QtUtils::MsgBox(QWidget *parent, QMessageBox::Icon icon, const QString &title, const QString &message, QMessageBox::StandardButtons buttons)
{
QMessageBox b(parent);
b.setIcon(icon);
@@ -94,19 +96,43 @@ QStringList QtUtils::WordWrapString(const QString &s, const QFontMetrics &fm, in
QString this_line = lines.at(i);
while (this_line.size() > 1 && QFontMetricsWidth(fm, this_line) >= bounding_width) {
int old_size = this_line.size();
int hard_break = -1;
for (int j=this_line.size()-1; j>=0; j--) {
if (this_line.at(j).isSpace()) {
const QChar &char_test = this_line.at(j);
if (char_test.isSpace()
|| char_test == '-') {
if (QFontMetricsWidth(fm, this_line.left(j)) < bounding_width) {
if (!char_test.isSpace()) {
j++;
}
QString chopped = this_line.left(j);
if (QFontMetricsWidth(fm, chopped) < bounding_width) {
list.append(chopped);
int k = j+1;
while (k < this_line.size() && this_line.at(k).isSpace()) {
k++;
while (j < this_line.size() && this_line.at(j).isSpace()) {
j++;
}
this_line.remove(0, k);
this_line.remove(0, j);
break;
}
} else if (hard_break == -1 && QFontMetricsWidth(fm, this_line.left(j)) < bounding_width) {
// In case we can't find a better place to split, split at the earliest time the line
// goes under the width limit
hard_break = j;
}
}
if (old_size == this_line.size()) {
if (hard_break != -1) {
list.append(this_line.left(hard_break));
this_line.remove(0, hard_break);
} else {
qWarning() << "Failed to find anywhere to wrap. Returning full line.";
break;
}
}
}
@@ -136,4 +162,14 @@ Qt::KeyboardModifiers QtUtils::FlipControlAndShiftModifiers(Qt::KeyboardModifier
return e;
}
void QtUtils::SetComboBoxData(QComboBox *cb, int data)
{
for (int i=0; i<cb->count(); i++) {
if (cb->itemData(i).toInt() == data) {
cb->setCurrentIndex(i);
break;
}
}
}
}
app/common/qtutils.h
+19 -13
View File
@@ -21,24 +21,13 @@
#ifndef QTVERSIONABSTRACTION_H
#define QTVERSIONABSTRACTION_H
/**
*
* A fairly simple header for reducing the amount of Qt version checks necessary throughout the code
*
*/
#include <QComboBox>
#include <QDateTime>
#include <QFileInfo>
#include <QFontMetrics>
#include <QFrame>
#include <QMessageBox>
#include "common/define.h"
#ifdef MessageBox
#undef MessageBox
#endif
namespace olive {
class QtUtils {
@@ -56,7 +45,7 @@ public:
static QFrame* CreateVerticalLine();
static int MessageBox(QWidget *parent, QMessageBox::Icon icon, const QString& title, const QString& message, QMessageBox::StandardButtons buttons = QMessageBox::Ok);
static int MsgBox(QWidget *parent, QMessageBox::Icon icon, const QString& title, const QString& message, QMessageBox::StandardButtons buttons = QMessageBox::Ok);
static QDateTime GetCreationDate(const QFileInfo &info);
@@ -66,6 +55,23 @@ public:
static Qt::KeyboardModifiers FlipControlAndShiftModifiers(Qt::KeyboardModifiers e);
static void SetComboBoxData(QComboBox *cb, int data);
template <typename T>
static T *GetParentOfType(const QObject *child)
{
QObject *t = child->parent();
while (t) {
if (T *p = dynamic_cast<T*>(t)) {
return p;
}
t = t->parent();
}
return nullptr;
}
};
}
app/config/config.cpp
+6
View File
@@ -108,6 +108,11 @@ void Config::SetDefaults()
SetEntryInternal(QStringLiteral("DefaultAudioTransition"), NodeValue::kText, QStringLiteral("org.olivevideoeditor.Olive.crossdissolve"));
SetEntryInternal(QStringLiteral("DefaultTransitionLength"), NodeValue::kRational, QVariant::fromValue(rational(1)));
SetEntryInternal(QStringLiteral("DefaultSubtitleSize"), NodeValue::kInt, 48);
SetEntryInternal(QStringLiteral("DefaultSubtitleFamily"), NodeValue::kText, QString());
SetEntryInternal(QStringLiteral("DefaultSubtitleWeight"), NodeValue::kInt, QFont::Bold);
SetEntryInternal(QStringLiteral("AntialiasSubtitles"), NodeValue::kBoolean, true);
SetEntryInternal(QStringLiteral("AutoCacheDelay"), NodeValue::kInt, 1000);
SetEntryInternal(QStringLiteral("CatColor0"), NodeValue::kInt, ColorCoding::kRed);
@@ -145,6 +150,7 @@ void Config::SetDefaults()
SetEntryInternal(QStringLiteral("DefaultSequencePixelAspect"), NodeValue::kRational, QVariant::fromValue(rational(1)));
SetEntryInternal(QStringLiteral("DefaultSequenceFrameRate"), NodeValue::kRational, QVariant::fromValue(rational(1001, 30000)));
SetEntryInternal(QStringLiteral("DefaultSequenceInterlacing"), NodeValue::kInt, VideoParams::kInterlaceNone);
SetEntryInternal(QStringLiteral("DefaultSequenceAutoCache2"), NodeValue::kBoolean, false);
SetEntryInternal(QStringLiteral("DefaultSequenceAudioFrequency"), NodeValue::kInt, 48000);
SetEntryInternal(QStringLiteral("DefaultSequenceAudioLayout"), NodeValue::kInt, QVariant::fromValue(static_cast<int64_t>(AV_CH_LAYOUT_STEREO)));
app/core.cpp
+2
View File
@@ -586,6 +586,8 @@ void Core::ImportTaskComplete(Task* task)
}
undo_stack_.pushIfHasChildren(command);
main_window_->SelectFootage(import_task->GetImportedFootage());
}
bool Core::ConfirmImageSequence(const QString& filename)
app/dialog/export/CMakeLists.txt
+2
View File
@@ -26,6 +26,8 @@ set(OLIVE_SOURCES
dialog/export/exportaudiotab.h
dialog/export/exportformatcombobox.cpp
dialog/export/exportformatcombobox.h
dialog/export/exportsavepresetdialog.cpp
dialog/export/exportsavepresetdialog.h
dialog/export/exportsubtitlestab.cpp
dialog/export/exportsubtitlestab.h
dialog/export/exportvideotab.cpp
app/dialog/export/codec/cineformsection.cpp
+5
View File
@@ -82,4 +82,9 @@ void CineformSection::AddOpts(EncodingParams *params)
params->set_video_option(QStringLiteral("quality"), QString::number(quality_combobox_->currentIndex()));
}
void CineformSection::SetOpts(const EncodingParams *p)
{
quality_combobox_->setCurrentIndex(p->video_option(QStringLiteral("quality")).toInt());
}
}
app/dialog/export/codec/cineformsection.h
+2
View File
@@ -35,6 +35,8 @@ public:
virtual void AddOpts(EncodingParams* params) override;
virtual void SetOpts(const EncodingParams *p) override;
private:
QComboBox *quality_combobox_;
app/dialog/export/codec/codecsection.h
+2
View File
@@ -35,6 +35,8 @@ public:
virtual void AddOpts(EncodingParams* params){Q_UNUSED(params)}
virtual void SetOpts(const EncodingParams *p){Q_UNUSED(p)}
};
}
app/dialog/export/codec/h264section.cpp
+52 -1
View File
@@ -105,6 +105,10 @@ void H264Section::AddOpts(EncodingParams *params)
CompressionMethod method = static_cast<CompressionMethod>(compression_method_stack_->currentIndex());
// This option is not used by the encoder (nor is anything with the ove_ prefix), it's to help us
// identify which option was chosen when params are restored
params->set_video_option(QStringLiteral("ove_compressionmethod"), QString::number(method));
if (method == kConstantRateFactor) {
// Simply set CRF value
@@ -121,9 +125,12 @@ void H264Section::AddOpts(EncodingParams *params)
max_rate = bitrate_section_->GetMaximumBitRate();
} else {
// Calculate the bit rate from the file size divided by the sequence length in seconds (bits per second)
target_rate = qRound64(static_cast<double>(filesize_section_->GetFileSize()) / params->GetExportLength().toDouble());
int64_t target_fs = filesize_section_->GetFileSize();
target_rate = qRound64(static_cast<double>(target_fs) / params->GetExportLength().toDouble());
min_rate = target_rate;
max_rate = target_rate;
params->set_video_option(QStringLiteral("ove_targetfilesize"), QString::number(target_fs));
}
// Disable CRF encoding
@@ -139,6 +146,29 @@ void H264Section::AddOpts(EncodingParams *params)
params->set_video_option(QStringLiteral("preset"), QString::number(preset_combobox_->currentIndex()));
}
void H264Section::SetOpts(const EncodingParams *p)
{
CompressionMethod method = static_cast<CompressionMethod>(p->video_option(QStringLiteral("ove_compressionmethod")).toInt());
compression_method_stack_->setCurrentIndex(method);
if (method == kConstantRateFactor) {
crf_section_->SetValue(p->video_option(QStringLiteral("crf")).toInt());
} else {
int64_t target_rate = p->video_bit_rate();
int64_t max_rate = p->video_max_bit_rate();
if (method == kTargetBitRate) {
// Use user-supplied values for the bit rate
bitrate_section_->SetTargetBitRate(target_rate);
bitrate_section_->SetMaximumBitRate(max_rate);
} else {
// Calculate the bit rate from the file size divided by the sequence length in seconds (bits per second)
filesize_section_->SetFileSize(p->video_option(QStringLiteral("ove_targetfilesize")).toLongLong());
}
}
}
H264CRFSection::H264CRFSection(int default_crf, QWidget *parent) :
QWidget(parent)
{
@@ -168,6 +198,11 @@ int H264CRFSection::GetValue() const
return crf_slider_->value();
}
void H264CRFSection::SetValue(int c)
{
crf_slider_->setValue(c);
}
H264BitRateSection::H264BitRateSection(QWidget *parent) :
QWidget(parent)
{
@@ -207,11 +242,21 @@ int64_t H264BitRateSection::GetTargetBitRate() const
return qRound64(target_rate_->GetValue() * 1000000.0);
}
void H264BitRateSection::SetTargetBitRate(int64_t b)
{
target_rate_->SetValue(double(b) * 0.000001);
}
int64_t H264BitRateSection::GetMaximumBitRate() const
{
return qRound64(max_rate_->GetValue() * 1000000.0);
}
void H264BitRateSection::SetMaximumBitRate(int64_t b)
{
max_rate_->SetValue(double(b) * 0.000001);
}
H264FileSizeSection::H264FileSizeSection(QWidget *parent) :
QWidget(parent)
{
@@ -243,6 +288,12 @@ int64_t H264FileSizeSection::GetFileSize() const
return qRound64(file_size_->GetValue() * 1024.0 * 1024.0 * 8.0);
}
void H264FileSizeSection::SetFileSize(int64_t f)
{
// Convert bits back to megabytes
file_size_->SetValue(double(f) / 8.0 / 1024.0 / 1024.0);
}
H265Section::H265Section(QWidget *parent) :
H264Section(H264CRFSection::kDefaultH265CRF, parent)
{
app/dialog/export/codec/h264section.h
+6
View File
@@ -37,6 +37,7 @@ public:
H264CRFSection(int default_crf, QWidget* parent = nullptr);
int GetValue() const;
void SetValue(int c);
static const int kDefaultH264CRF = 18;
static const int kDefaultH265CRF = 23;
@@ -59,11 +60,13 @@ public:
* @brief Get user-selected target bit rate (returns in BITS)
*/
int64_t GetTargetBitRate() const;
void SetTargetBitRate(int64_t b);
/**
* @brief Get user-selected maximum bit rate (returns in BITS)
*/
int64_t GetMaximumBitRate() const;
void SetMaximumBitRate(int64_t b);
private:
FloatSlider* target_rate_;
@@ -82,6 +85,7 @@ public:
* @brief Returns file size in BITS
*/
int64_t GetFileSize() const;
void SetFileSize(int64_t f);
private:
FloatSlider* file_size_;
@@ -103,6 +107,8 @@ public:
virtual void AddOpts(EncodingParams* params) override;
virtual void SetOpts(const EncodingParams *p) override;
private:
QStackedWidget* compression_method_stack_;
app/dialog/export/codec/imagesection.h
+5
View File
@@ -39,6 +39,11 @@ public:
return image_sequence_checkbox_->isChecked();
}
void SetImageSequenceChecked(bool e)
{
image_sequence_checkbox_->setChecked(e);
}
void SetTimebase(const rational& r)
{
frame_slider_->SetTimebase(r);
app/dialog/export/export.cpp
+231 -47
View File
@@ -32,8 +32,8 @@
#include "common/digit.h"
#include "common/qtutils.h"
#include "core.h"
#include "dialog/task/task.h"
#include "exportsavepresetdialog.h"
#include "node/project/project.h"
#include "node/project/sequence/sequence.h"
#include "task/taskmanager.h"
@@ -42,8 +42,10 @@
namespace olive {
#define super QDialog
ExportDialog::ExportDialog(ViewerOutput *viewer_node, QWidget *parent) :
QDialog(parent),
super(parent),
viewer_node_(viewer_node)
{
QHBoxLayout* layout = new QHBoxLayout(this);
@@ -80,21 +82,21 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, QWidget *parent) :
QLabel* preset_lbl = new QLabel(tr("Preset:"));
preset_lbl->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
preferences_layout->addWidget(preset_lbl, row, 0);
QComboBox* preset_combobox = new QComboBox();
preset_combobox->addItem(tr("Same As Source - High Quality"));
preset_combobox->addItem(tr("Same As Source - Medium Quality"));
preset_combobox->addItem(tr("Same As Source - Low Quality"));
preferences_layout->addWidget(preset_combobox, row, 1);
preset_combobox_ = new QComboBox();
LoadPresets();
connect(preset_combobox_, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &ExportDialog::PresetComboBoxChanged);
preferences_layout->addWidget(preset_combobox_, row, 1, 1, 2);
QPushButton* preset_load_btn = new QPushButton();
/*QPushButton* preset_load_btn = new QPushButton();
preset_load_btn->setIcon(icon::Open);
preset_load_btn->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
preferences_layout->addWidget(preset_load_btn, row, 2);
preferences_layout->addWidget(preset_load_btn, row, 2);*/
QPushButton* preset_save_btn = new QPushButton();
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);
row++;
@@ -131,7 +133,7 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, QWidget *parent) :
audio_enabled_ = new QCheckBox(tr("Export Audio"));
av_enabled_layout->addWidget(audio_enabled_);
subtitles_enabled_ = new QCheckBox(tr("Export Subtitle"));
subtitles_enabled_ = new QCheckBox(tr("Export Subtitles"));
av_enabled_layout->addWidget(subtitles_enabled_);
preferences_layout->addLayout(av_enabled_layout, row, 0, 1, 4);
@@ -182,6 +184,7 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, QWidget *parent) :
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_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
connect(preview_viewer_, &ViewerWidget::TimeChanged, video_tab_, &ExportVideoTab::SetTime);
preview_layout->addWidget(preview_viewer_);
@@ -195,25 +198,9 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, QWidget *parent) :
// Set defaults
previously_selected_format_ = ExportFormat::kFormatMPEG4Video;
format_combobox_->SetFormat(ExportFormat::kFormatMPEG4Video);
connect(format_combobox_, &ExportFormatComboBox::FormatChanged, this, &ExportDialog::FormatChanged);
FormatChanged(format_combobox_->GetFormat());
VideoParams vp = viewer_node_->GetVideoParams();
AudioParams ap = viewer_node_->GetAudioParams();
video_tab_->width_slider()->SetValue(vp.width());
video_tab_->width_slider()->SetDefaultValue(vp.width());
video_tab_->height_slider()->SetValue(vp.height());
video_tab_->height_slider()->SetDefaultValue(vp.height());
video_tab_->SetSelectedFrameRate(vp.frame_rate());
video_tab_->pixel_aspect_combobox()->SetPixelAspectRatio(vp.pixel_aspect_ratio());
video_tab_->pixel_format_field()->SetPixelFormat(static_cast<VideoParams::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(ap.channel_layout());
video_aspect_ratio_ = static_cast<double>(vp.width()) / static_cast<double>(vp.height());
connect(video_tab_->width_slider(),
@@ -245,10 +232,31 @@ ExportDialog::ExportDialog(ViewerOutput *viewer_node, QWidget *parent) :
this,
&ExportDialog::ImageSequenceCheckBoxChanged);
// Set viewer to view the node
// We don't check if the codec supports subtitles because we can always export to a sidecar file
bool has_subtitle_tracks = SequenceHasSubtitles();
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 (viewer_node_->GetLastUsedEncodingParams().IsValid()) {
SetParams(viewer_node_->GetLastUsedEncodingParams());
} else {
SetDefaults();
}
// 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());
qApp->installEventFilter(this);
connect(video_enabled_, &QCheckBox::toggled, video_tab_, &QWidget::setEnabled);
video_tab_->setEnabled(video_enabled_->isChecked());
connect(audio_enabled_, &QCheckBox::toggled, audio_tab_, &QWidget::setEnabled);
audio_tab_->setEnabled(audio_enabled_->isChecked());
connect(subtitles_enabled_, &QCheckBox::toggled, subtitle_tab_, &QWidget::setEnabled);
subtitle_tab_->setEnabled(subtitles_enabled_->isChecked());
}
rational ExportDialog::GetSelectedTimebase() const
@@ -256,10 +264,15 @@ rational ExportDialog::GetSelectedTimebase() const
return video_tab_->GetSelectedFrameRate().flipped();
}
void ExportDialog::SetSelectedTimebase(const rational &r)
{
video_tab_->SetSelectedFrameRate(r.flipped());
}
void ExportDialog::StartExport()
{
if (!video_enabled_->isChecked() && !audio_enabled_->isChecked() && !subtitles_enabled_->isChecked()) {
QtUtils::MessageBox(this, QMessageBox::Critical, tr("Invalid parameters"),
QtUtils::MsgBox(this, QMessageBox::Critical, tr("Invalid parameters"),
tr("Video, audio, and subtitles are disabled. There's nothing to export."));
return;
}
@@ -271,7 +284,7 @@ void ExportDialog::StartExport()
// 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::MessageBox(this, QMessageBox::Warning, tr("Invalid filename"),
if (QtUtils::MsgBox(this, QMessageBox::Warning, tr("Invalid filename"),
tr("The filename must contain the extension \"%1\". Would you like to append it "
"automatically?").arg(necessary_ext),
QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
@@ -288,7 +301,7 @@ 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::MessageBox(this, QMessageBox::Critical, tr("Failed to create output directory"),
QtUtils::MsgBox(this, QMessageBox::Critical, tr("Failed to create output directory"),
tr("The intended output directory doesn't exist and Olive couldn't create it. "
"Please choose a different filename."));
return;
@@ -298,7 +311,7 @@ void ExportDialog::StartExport()
if (video_tab_->IsImageSequenceSet()) {
// Ensure filename contains digits
if (!Encoder::FilenameContainsDigitPlaceholder(proposed_filename)) {
QtUtils::MessageBox(this, QMessageBox::Critical, tr("Invalid filename"),
QtUtils::MsgBox(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;
@@ -308,7 +321,7 @@ void ExportDialog::StartExport()
int64_t needed_digit_count = GetDigitCount(frame_count);
int current_digit_count = Encoder::GetImageSequencePlaceholderDigitCount(proposed_filename);
if (current_digit_count < needed_digit_count) {
QtUtils::MessageBox(this, QMessageBox::Critical, tr("Invalid filename"),
QtUtils::MsgBox(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)).", nullptr, frame_count)
.arg(QString::number(needed_digit_count)));
@@ -318,7 +331,7 @@ void ExportDialog::StartExport()
// Validate if the file exists and whether the user wishes to overwrite it
if (file_info.exists()) {
if (QtUtils::MessageBox(this, QMessageBox::Warning, tr("Confirm Overwrite"),
if (QtUtils::MsgBox(this, QMessageBox::Warning, tr("Confirm Overwrite"),
tr("The file \"%1\" already exists. Do you want to overwrite it?")
.arg(proposed_filename),
QMessageBox::Yes | QMessageBox::No) == QMessageBox::No) {
@@ -330,7 +343,7 @@ void ExportDialog::StartExport()
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::MessageBox(this, QMessageBox::Critical, tr("Invalid Parameters"),
QtUtils::MsgBox(this, QMessageBox::Critical, tr("Invalid Parameters"),
tr("Width and height must be multiples of 2."));
return;
}
@@ -384,11 +397,27 @@ void ExportDialog::ImageSequenceCheckBoxChanged(bool e)
filename_edit_->setText(current_fileinfo.dir().filePath(basename));
}
void ExportDialog::closeEvent(QCloseEvent *e)
void ExportDialog::SavePreset()
{
preview_viewer_->ConnectViewerNode(nullptr);
ExportSavePresetDialog d(GenerateParams(), this);
if (d.exec() == QDialog::Accepted) {
LoadPresets();
preset_combobox_->setCurrentText(d.GetSelectedPresetName());
}
}
QDialog::closeEvent(e);
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());
} else {
SetParams(presets_.at(preset_number));
}
}
void ExportDialog::AddPreferencesTab(QWidget *inner_widget, const QString &title)
@@ -444,9 +473,9 @@ void ExportDialog::FormatChanged(ExportFormat::Format current_format)
audio_enabled_->setChecked(has_audio_codecs);
audio_enabled_->setEnabled(has_audio_codecs);
bool has_subtitle_codecs = subtitle_tab_->SetFormat(current_format);
subtitles_enabled_->setChecked(has_subtitle_codecs);
subtitles_enabled_->setEnabled(has_subtitle_codecs);
if (subtitles_enabled_->isEnabled()) {
subtitle_tab_->SetFormat(current_format);
}
}
void ExportDialog::ResolutionChanged()
@@ -483,7 +512,32 @@ void ExportDialog::ResolutionChanged()
void ExportDialog::LoadPresets()
{
preset_combobox_->clear();
presets_.clear();
preset_combobox_->addItem(tr("Default"), kPresetDefault);
if (viewer_node_->GetLastUsedEncodingParams().IsValid()) {
preset_combobox_->addItem(tr("Last Used"), kPresetLastUsed);
}
preset_combobox_->insertSeparator(preset_combobox_->count());
QStringList l = EncodingParams::GetListOfPresets();
presets_.reserve(l.size());
for (const QString &preset : l) {
EncodingParams p;
QFile f(EncodingParams::GetPresetPath().filePath(preset));
if (f.open(QFile::ReadOnly)) {
if (p.Load(&f)) {
preset_combobox_->addItem(preset, int(presets_.size()));
presets_.push_back(p);
}
f.close();
}
}
}
void ExportDialog::SetDefaultFilename()
@@ -502,7 +556,43 @@ void ExportDialog::SetDefaultFilename()
filename_edit_->setText(file_location);
}
ExportParams ExportDialog::GenerateParams() const
bool ExportDialog::SequenceHasSubtitles() 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()) {
return true;
}
}
}
return false;
}
void ExportDialog::SetDefaults()
{
format_combobox_->SetFormat(ExportFormat::kFormatMPEG4Video);
FormatChanged(format_combobox_->GetFormat());
VideoParams vp = viewer_node_->GetVideoParams();
AudioParams ap = viewer_node_->GetAudioParams();
video_tab_->width_slider()->SetValue(vp.width());
video_tab_->width_slider()->SetDefaultValue(vp.width());
video_tab_->height_slider()->SetValue(vp.height());
video_tab_->height_slider()->SetDefaultValue(vp.height());
video_tab_->SetSelectedFrameRate(vp.frame_rate());
video_tab_->pixel_aspect_combobox()->SetPixelAspectRatio(vp.pixel_aspect_ratio());
video_tab_->pixel_format_field()->SetPixelFormat(static_cast<VideoParams::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(ap.channel_layout());
subtitles_enabled_->setChecked(SequenceHasSubtitles());
}
EncodingParams ExportDialog::GenerateParams() const
{
VideoParams video_render_params(static_cast<int>(video_tab_->width_slider()->GetValue()),
static_cast<int>(video_tab_->height_slider()->GetValue()),
@@ -517,8 +607,8 @@ ExportParams ExportDialog::GenerateParams() const
audio_tab_->channel_layout_combobox()->GetChannelLayout(),
audio_tab_->sample_format_combobox()->GetSampleFormat());
ExportParams params;
params.set_encoder(Encoder::GetTypeFromFormat(format_combobox_->GetFormat()));
EncodingParams params;
params.set_format(format_combobox_->GetFormat());
params.SetFilename(filename_edit_->text().trimmed());
params.SetExportLength(viewer_node_->GetLength());
@@ -532,11 +622,14 @@ ExportParams ExportDialog::GenerateParams() const
}
if (video_tab_->scaling_method_combobox()->isEnabled()) {
params.set_video_scaling_method(static_cast<ExportParams::VideoScalingMethod>(video_tab_->scaling_method_combobox()->currentData().toInt()));
params.set_video_scaling_method(static_cast<EncodingParams::VideoScalingMethod>(video_tab_->scaling_method_combobox()->currentData().toInt()));
}
if (video_enabled_->isChecked()) {
ExportCodec::Codec video_codec = video_tab_->GetSelectedCodec();
video_render_params.set_color_range(video_tab_->color_range());
params.EnableVideo(video_render_params, video_codec);
params.set_video_threads(video_tab_->threads());
@@ -559,13 +652,104 @@ ExportParams ExportDialog::GenerateParams() const
params.set_audio_bit_rate(audio_tab_->bit_rate_slider()->GetValue() * 1000);
}
if (subtitles_enabled_->isChecked()) {
if (subtitles_enabled_->isEnabled()
&& subtitles_enabled_->isChecked()) {
if (!subtitle_tab_->GetSidecarEnabled()) {
// Export subtitles embedded in container
params.EnableSubtitles(subtitle_tab_->GetSubtitleCodec());
} else {
// Export subtitles to a sidecar file
params.EnableSidecarSubtitles(subtitle_tab_->GetSidecarFormat(), subtitle_tab_->GetSubtitleCodec());
}
}
return params;
}
void ExportDialog::SetParams(const EncodingParams &e)
{
format_combobox_->SetFormat(e.format());
if (e.has_custom_range() && viewer_node_->GetWorkArea()->enabled()) {
range_combobox_->setCurrentIndex(kRangeInToOut);
}
QtUtils::SetComboBoxData(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(e.video_params().format());
video_tab_->pixel_aspect_combobox()->SetPixelAspectRatio(e.video_params().pixel_aspect_ratio());
video_tab_->interlaced_combobox()->SetInterlaceMode(e.video_params().interlacing());
video_tab_->SetSelectedCodec(e.video_codec());
video_tab_->SetColorRange(e.video_params().color_range());
video_tab_->SetThreads(e.video_threads());
if (video_tab_->isVisible()) {
video_tab_->GetCodecSection()->SetOpts(&e);
}
video_tab_->SetOCIOColorSpace(e.color_transform().output());
video_tab_->SetPixFmt(e.video_pix_fmt());
video_tab_->SetImageSequence(e.video_is_image_sequence());
}
audio_enabled_->setChecked(e.audio_enabled());
if (e.audio_enabled()) {
audio_tab_->sample_rate_combobox()->SetSampleRate(e.audio_params().sample_rate());
audio_tab_->channel_layout_combobox()->SetChannelLayout(e.audio_params().channel_layout());
audio_tab_->sample_format_combobox()->SetSampleFormat(e.audio_params().format());
audio_tab_->SetCodec(e.audio_codec());
audio_tab_->bit_rate_slider()->SetValue(e.audio_bit_rate() / 1000);
}
if (subtitles_enabled_->isEnabled()) {
subtitles_enabled_->setChecked(e.subtitles_enabled());
subtitle_tab_->SetSidecarEnabled(e.subtitles_are_sidecar());
if (e.subtitles_enabled()) {
subtitle_tab_->SetSubtitleCodec(e.subtitles_codec());
if (e.subtitles_are_sidecar()) {
subtitle_tab_->SetSidecarFormat(e.subtitle_sidecar_fmt());
}
}
}
}
bool ExportDialog::eventFilter(QObject *o, QEvent *e)
{
// Any parameters in scrollable areas, ignore wheel events so the user doesn't unwittingly change
// them while trying to scroll through the pages
if (e->type() == QEvent::Wheel) {
while ((o = o->parent())) {
if (o == video_tab_ || o == audio_tab_ || o == subtitle_tab_) {
e->ignore();
return true;
}
}
}
return super::eventFilter(o, e);
}
void ExportDialog::done(int r)
{
preview_viewer_->ConnectViewerNode(nullptr);
viewer_node_->SetLastUsedEncodingParams(GenerateParams());
super::done(r);
}
rational ExportDialog::GetExportLength() const
{
if (range_combobox_->currentIndex() == kRangeInToOut) {
@@ -587,8 +771,8 @@ void ExportDialog::UpdateViewerDimensions()
VideoParams vp = viewer_node_->GetVideoParams();
QMatrix4x4 transform = ExportParams::GenerateMatrix(
static_cast<ExportParams::VideoScalingMethod>(video_tab_->scaling_method_combobox()->currentData().toInt()),
QMatrix4x4 transform = EncodingParams::GenerateMatrix(
static_cast<EncodingParams::VideoScalingMethod>(video_tab_->scaling_method_combobox()->currentData().toInt()),
vp.width(),
vp.height(),
static_cast<int>(video_tab_->width_slider()->GetValue()),
app/dialog/export/export.h
+23 -3
View File
@@ -34,6 +34,7 @@
#include "exportsubtitlestab.h"
#include "exportvideotab.h"
#include "task/export/export.h"
#include "widget/nodeparamview/nodeparamviewwidgetbridge.h"
#include "widget/viewer/viewer.h"
namespace olive {
@@ -45,6 +46,7 @@ public:
ExportDialog(ViewerOutput* viewer_node, QWidget* parent = nullptr);
rational GetSelectedTimebase() const;
void SetSelectedTimebase(const rational &r);
void SetTime(const rational &time)
{
@@ -54,8 +56,13 @@ public:
preview_viewer_->SetAudioScrubbingEnabled(true);
}
protected:
virtual void closeEvent(QCloseEvent *e) override;
EncodingParams GenerateParams() const;
void SetParams(const EncodingParams &e);
virtual bool eventFilter(QObject *o, QEvent *e) override;
public slots:
virtual void done(int r) override;
private:
void AddPreferencesTab(QWidget *inner_widget, const QString &title);
@@ -63,7 +70,9 @@ private:
void LoadPresets();
void SetDefaultFilename();
ExportParams GenerateParams() const;
bool SequenceHasSubtitles() const;
void SetDefaults();
ViewerOutput* viewer_node_;
@@ -77,9 +86,16 @@ private:
kRangeInToOut
};
enum AutoPreset {
kPresetDefault = -1,
kPresetLastUsed = -2,
};
QTabWidget* preferences_tabs_;
QComboBox* preset_combobox_;
QComboBox* range_combobox_;
std::vector<EncodingParams> presets_;
QCheckBox* video_enabled_;
QCheckBox* audio_enabled_;
@@ -115,6 +131,10 @@ private slots:
void ImageSequenceCheckBoxChanged(bool e);
void SavePreset();
void PresetComboBoxChanged();
};
}
app/dialog/export/exportadvancedvideodialog.cpp
+6
View File
@@ -31,6 +31,12 @@ ExportAdvancedVideoDialog::ExportAdvancedVideoDialog(const QList<QString> &pix_f
pixel_layout->addWidget(pixel_format_combobox_, row, 1);
row++;
pixel_layout->addWidget(new QLabel(tr("YUV Color Range:")), row, 0);
yuv_color_range_combobox_ = new QComboBox();
yuv_color_range_combobox_->addItems({tr("Limited (16-235)"), tr("Full (0-255)")});
pixel_layout->addWidget(yuv_color_range_combobox_, row, 1);
}
{
app/dialog/export/exportadvancedvideodialog.h
+13
View File
@@ -4,6 +4,7 @@
#include <QComboBox>
#include <QDialog>
#include "codec/encoder.h"
#include "widget/slider/integerslider.h"
namespace olive {
@@ -35,11 +36,23 @@ public:
pixel_format_combobox_->setCurrentText(s);
}
VideoParams::ColorRange yuv_range() const
{
return static_cast<VideoParams::ColorRange>(yuv_color_range_combobox_->currentIndex());
}
void set_yuv_range(VideoParams::ColorRange i)
{
yuv_color_range_combobox_->setCurrentIndex(i);
}
private:
IntegerSlider* thread_slider_;
QComboBox* pixel_format_combobox_;
QComboBox* yuv_color_range_combobox_;
};
}
app/dialog/export/exportformatcombobox.cpp
+7
View File
@@ -46,6 +46,13 @@ ExportFormatComboBox::ExportFormatComboBox(Mode mode, QWidget *parent) :
continue;
}
break;
case kShowSubtitlesOnly:
if (!ExportFormat::GetVideoCodecs(f).isEmpty()
|| ExportFormat::GetSubtitleCodecs(f).isEmpty()
|| !ExportFormat::GetAudioCodecs(f).isEmpty()) {
continue;
}
break;
}
QString format_name = ExportFormat::GetName(f);
app/dialog/export/exportformatcombobox.h
+2 -1
View File
@@ -34,7 +34,8 @@ public:
enum Mode {
kShowAllFormats,
kShowAudioOnly,
kShowVideoOnly
kShowVideoOnly,
kShowSubtitlesOnly
};
ExportFormatComboBox(Mode mode, QWidget *parent = nullptr);
app/dialog/export/exportsavepresetdialog.cpp
+97
View File
@@ -0,0 +1,97 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2022 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 "exportsavepresetdialog.h"
#include <QDialogButtonBox>
#include <QLabel>
#include <QMessageBox>
#include <QVBoxLayout>
namespace olive {
ExportSavePresetDialog::ExportSavePresetDialog(const EncodingParams &p, QWidget *parent) :
QDialog(parent),
params_(p)
{
auto layout = new QVBoxLayout(this);
name_edit_ = new QLineEdit();
// Populate existing list
QStringList l = EncodingParams::GetListOfPresets();
if (!l.empty()) {
auto list_widget_ = new QListWidget();
for (const QString &f : l) {
list_widget_->addItem(f);
}
connect(list_widget_, &QListWidget::currentTextChanged, name_edit_, &QLineEdit::setText);
layout->addWidget(list_widget_);
}
auto name_layout = new QHBoxLayout();
layout->addLayout(name_layout);
name_layout->addWidget(new QLabel(tr("Name:")));
name_edit_->setFocus();
name_layout->addWidget(name_edit_);
auto btns = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
connect(btns, &QDialogButtonBox::accepted, this, &ExportSavePresetDialog::accept);
connect(btns, &QDialogButtonBox::rejected, this, &ExportSavePresetDialog::reject);
layout->addWidget(btns);
setWindowTitle(tr("Save Export Preset"));
}
void ExportSavePresetDialog::accept()
{
if (name_edit_->text().isEmpty()) {
QMessageBox::critical(this, tr("Invalid Name"), tr("You must enter a name to save an export preset."));
return;
}
QDir d(EncodingParams::GetPresetPath());
if (!d.exists()) {
d.mkpath(QStringLiteral("."));
}
QFile f(d.filePath(name_edit_->text()));
if (f.exists()) {
if (QMessageBox::question(this, tr("Overwrite Preset"), tr("A preset with the name \"%1\" already exists. Do you wish to overwrite it?").arg(name_edit_->text()),
QMessageBox::Yes | QMessageBox::No) == QMessageBox::No) {
return;
}
}
if (!f.open(QFile::WriteOnly)) {
QMessageBox::critical(this, tr("Write Error"), tr("Failed to open file \"%1\" for writing.").arg(f.fileName()));
return;
}
params_.Save(&f);
f.close();
QDialog::accept();
}
}
app/common/threadedobject.h → app/dialog/export/exportsavepresetdialog.h
+19 -14
View File
@@ -18,33 +18,38 @@
***/
#ifndef THREADEDOBJECT_H
#define THREADEDOBJECT_H
#ifndef EXPORTSAVEPRESETDIALOG_H
#define EXPORTSAVEPRESETDIALOG_H
#include <QMutex>
#include <QDialog>
#include <QLineEdit>
#include <QListWidget>
#include "common/define.h"
#include "codec/encoder.h"
namespace olive {
class ThreadedObject
class ExportSavePresetDialog : public QDialog
{
Q_OBJECT
public:
ExportSavePresetDialog(const EncodingParams &p, QWidget *parent = nullptr);
void LockMutex();
void UnlockMutex();
bool TryLockMutex(int timeout = 0);
QString GetSelectedPresetName() const
{
return name_edit_->text();
}
void LockDeletes();
void UnlockDeletes();
bool AreDeletesLocked();
public slots:
virtual void accept() override;
private:
QMutex threadobj_main_lock_;
QLineEdit *name_edit_;
EncodingParams params_;
QAtomicInt threadobj_delete_lock_;
};
}
#endif // THREADEDOBJECT_H
#endif // EXPORTSAVEPRESETDIALOG_H
app/dialog/export/exportsubtitlestab.cpp
+25 -2
View File
@@ -1,7 +1,6 @@
#include "exportsubtitlestab.h"
#include <QGridLayout>
#include <QLabel>
namespace olive {
@@ -15,22 +14,46 @@ ExportSubtitlesTab::ExportSubtitlesTab(QWidget *parent) :
int row = 0;
sidecar_checkbox_ = new QCheckBox(tr("Export to sidecar file"));
layout->addWidget(sidecar_checkbox_, row, 0, 1, 2);
row++;
sidecar_format_label_ = new QLabel(tr("Sidecar Format:"));
sidecar_format_label_->setVisible(false);
layout->addWidget(sidecar_format_label_, row, 0);
sidecar_format_combobox_ = new ExportFormatComboBox(ExportFormatComboBox::kShowSubtitlesOnly);
sidecar_format_combobox_->setVisible(false);
layout->addWidget(sidecar_format_combobox_, row, 1);
row++;
layout->addWidget(new QLabel(tr("Codec:")), row, 0);
codec_combobox_ = new QComboBox();
layout->addWidget(codec_combobox_, row, 1);
outer_layout->addStretch();
connect(sidecar_checkbox_, &QCheckBox::toggled, sidecar_format_label_, &QWidget::setVisible);
connect(sidecar_checkbox_, &QCheckBox::toggled, sidecar_format_combobox_, &QWidget::setVisible);
}
int ExportSubtitlesTab::SetFormat(ExportFormat::Format format)
{
auto scodecs = ExportFormat::GetSubtitleCodecs(format);
setEnabled(!scodecs.isEmpty());
sidecar_checkbox_->setChecked(scodecs.empty());
sidecar_checkbox_->setEnabled(!scodecs.empty());
scodecs = ExportFormat::GetSubtitleCodecs(sidecar_format_combobox_->GetFormat());
codec_combobox_->clear();
foreach (ExportCodec::Codec scodec, scodecs) {
codec_combobox_->addItem(ExportCodec::GetCodecName(scodec), scodec);
}
return scodecs.size();
}
app/dialog/export/exportsubtitlestab.h
+20 -1
View File
@@ -21,10 +21,13 @@
#ifndef EXPORTSUBTITLESTAB_H
#define EXPORTSUBTITLESTAB_H
#include <QCheckBox>
#include <QComboBox>
#include <QLabel>
#include "codec/exportformat.h"
#include "render/subtitleparams.h"
#include "common/qtutils.h"
#include "dialog/export/exportformatcombobox.h"
namespace olive {
@@ -34,6 +37,12 @@ class ExportSubtitlesTab : public QWidget
public:
ExportSubtitlesTab(QWidget *parent = nullptr);
bool GetSidecarEnabled() const { return sidecar_checkbox_->isChecked(); }
void SetSidecarEnabled(bool e) { sidecar_checkbox_->setEnabled(e); }
ExportFormat::Format GetSidecarFormat() const { return sidecar_format_combobox_->GetFormat(); }
void SetSidecarFormat(ExportFormat::Format f) { sidecar_format_combobox_->SetFormat(f); }
int SetFormat(ExportFormat::Format format);
ExportCodec::Codec GetSubtitleCodec()
@@ -41,7 +50,17 @@ public:
return static_cast<ExportCodec::Codec>(codec_combobox_->currentData().toInt());
}
void SetSubtitleCodec(ExportCodec::Codec c)
{
QtUtils::SetComboBoxData(codec_combobox_, c);
}
private:
QCheckBox *sidecar_checkbox_;
QLabel *sidecar_format_label_;
ExportFormatComboBox *sidecar_format_combobox_;
QComboBox *codec_combobox_;
};
app/dialog/export/exportvideotab.cpp
+14 -5
View File
@@ -29,14 +29,14 @@
#include "core.h"
#include "exportadvancedvideodialog.h"
#include "node/color/colormanager/colormanager.h"
#include "task/export/exportparams.h"
namespace olive {
ExportVideoTab::ExportVideoTab(ColorManager* color_manager, QWidget *parent) :
QWidget(parent),
color_manager_(color_manager),
threads_(0)
threads_(0),
color_range_(VideoParams::kColorRangeDefault)
{
QVBoxLayout* outer_layout = new QVBoxLayout(this);
@@ -69,6 +69,13 @@ bool ExportVideoTab::IsImageSequenceSet() const
return (img_section && img_section->IsImageSequenceChecked());
}
void ExportVideoTab::SetImageSequence(bool e) const
{
if (ImageSection* img_section = dynamic_cast<ImageSection*>(codec_stack_->currentWidget())) {
img_section->SetImageSequenceChecked(e);
}
}
QWidget* ExportVideoTab::SetupResolutionSection()
{
int row = 0;
@@ -106,9 +113,9 @@ QWidget* ExportVideoTab::SetupResolutionSection()
scaling_method_combobox_ = new QComboBox();
scaling_method_combobox_->setEnabled(false);
scaling_method_combobox_->addItem(tr("Fit"), ExportParams::kFit);
scaling_method_combobox_->addItem(tr("Stretch"), ExportParams::kStretch);
scaling_method_combobox_->addItem(tr("Crop"), ExportParams::kCrop);
scaling_method_combobox_->addItem(tr("Fit"), EncodingParams::kFit);
scaling_method_combobox_->addItem(tr("Stretch"), EncodingParams::kStretch);
scaling_method_combobox_->addItem(tr("Crop"), EncodingParams::kCrop);
layout->addWidget(scaling_method_combobox_, row, 1);
// Automatically enable/disable the scaling method depending on maintain aspect ratio
@@ -211,10 +218,12 @@ void ExportVideoTab::OpenAdvancedDialog()
d.set_threads(threads_);
d.set_pix_fmt(pix_fmt_);
d.set_yuv_range(color_range_);
if (d.exec() == QDialog::Accepted) {
threads_ = d.threads();
pix_fmt_ = d.pix_fmt();
color_range_ = d.yuv_range();
}
}
app/dialog/export/exportvideotab.h
+22 -2
View File
@@ -25,6 +25,7 @@
#include <QComboBox>
#include <QWidget>
#include "common/qtutils.h"
#include "common/rational.h"
#include "dialog/export/codec/cineformsection.h"
#include "dialog/export/codec/codecstack.h"
@@ -46,6 +47,7 @@ public:
int SetFormat(ExportFormat::Format format);
bool IsImageSequenceSet() const;
void SetImageSequence(bool e) const;
rational GetStillImageTime() const
{
@@ -57,6 +59,11 @@ public:
return static_cast<ExportCodec::Codec>(codec_combobox()->currentData().toInt());
}
void SetSelectedCodec(ExportCodec::Codec c)
{
QtUtils::SetComboBoxData(codec_combobox(), c);
}
QComboBox* codec_combobox() const
{
return codec_combobox_;
@@ -98,6 +105,11 @@ public:
return color_space_chooser_->input();
}
void SetOCIOColorSpace(const QString &s)
{
color_space_chooser_->set_input(s);
}
CodecSection* GetCodecSection() const
{
return static_cast<CodecSection*>(codec_stack_->currentWidget());
@@ -133,10 +145,17 @@ public:
return threads_;
}
const QString& pix_fmt() const {
return pix_fmt_;
void SetThreads(int t)
{
threads_ = t;
}
const QString& pix_fmt() const { return pix_fmt_; }
void SetPixFmt(const QString &s) { pix_fmt_ = s; }
VideoParams::ColorRange color_range() const { return color_range_; }
void SetColorRange(VideoParams::ColorRange c) { color_range_ = c; }
public slots:
void VideoCodecChanged();
@@ -177,6 +196,7 @@ private:
int threads_;
QString pix_fmt_;
VideoParams::ColorRange color_range_;
ExportFormat::Format format_;
app/dialog/footageproperties/footageproperties.h
-5
View File
@@ -83,11 +83,6 @@ private:
*/
QStackedWidget* stacked_widget_;
/**
* @brief ComboBox for interlacing setting
*/
QComboBox* interlacing_box;
/**
* @brief Media name text field
*/
app/dialog/footageproperties/streamproperties/videostreamproperties.cpp
+21 -4
View File
@@ -79,6 +79,17 @@ VideoStreamProperties::VideoStreamProperties(Footage *footage, int video_index)
video_layout->addWidget(video_color_space_, row, 1);
row++;
video_layout->addWidget(new QLabel(tr("Color Range:")), row, 0);
color_range_combo_ = new QComboBox();
color_range_combo_->addItem(tr("Limited (16-235)"), VideoParams::kColorRangeLimited);
color_range_combo_->addItem(tr("Full (0-255)"), VideoParams::kColorRangeFull);
color_range_combo_->setCurrentIndex(vp.color_range());
video_layout->addWidget(color_range_combo_, row, 1);
if (vp.channel_count() == VideoParams::kRGBAChannelCount) {
row++;
@@ -136,14 +147,16 @@ void VideoStreamProperties::Accept(MultiUndoCommand *parent)
if ((video_premultiply_alpha_ && video_premultiply_alpha_->isChecked() != vp.premultiplied_alpha())
|| set_colorspace != vp.colorspace()
|| static_cast<VideoParams::Interlacing>(video_interlace_combo_->currentIndex()) != vp.interlacing()
|| pixel_aspect_combo_->GetPixelAspectRatio() != vp.pixel_aspect_ratio()) {
|| pixel_aspect_combo_->GetPixelAspectRatio() != vp.pixel_aspect_ratio()
|| color_range_combo_->currentData().toInt() != vp.color_range()) {
parent->add_child(new VideoStreamChangeCommand(footage_,
video_index_,
video_premultiply_alpha_ ? video_premultiply_alpha_->isChecked() : vp.premultiplied_alpha(),
set_colorspace,
static_cast<VideoParams::Interlacing>(video_interlace_combo_->currentIndex()),
pixel_aspect_combo_->GetPixelAspectRatio()));
pixel_aspect_combo_->GetPixelAspectRatio(),
static_cast<VideoParams::ColorRange>(color_range_combo_->currentData().toInt())));
}
if (vp.video_type() == VideoParams::kVideoTypeImageSequence) {
@@ -181,13 +194,14 @@ VideoStreamProperties::VideoStreamChangeCommand::VideoStreamChangeCommand(Footag
bool premultiplied,
QString colorspace,
VideoParams::Interlacing interlacing,
const rational &pixel_ar) :
const rational &pixel_ar, VideoParams::ColorRange range) :
footage_(footage),
video_index_(video_index),
new_premultiplied_(premultiplied),
new_colorspace_(colorspace),
new_interlacing_(interlacing),
new_pixel_ar_(pixel_ar)
new_pixel_ar_(pixel_ar),
new_range_(range)
{
}
@@ -204,11 +218,13 @@ void VideoStreamProperties::VideoStreamChangeCommand::redo()
old_colorspace_ = vp.colorspace();
old_interlacing_ = vp.interlacing();
old_pixel_ar_ = vp.pixel_aspect_ratio();
old_range_ = vp.color_range();
vp.set_premultiplied_alpha(new_premultiplied_);
vp.set_colorspace(new_colorspace_);
vp.set_interlacing(new_interlacing_);
vp.set_pixel_aspect_ratio(new_pixel_ar_);
vp.set_color_range(new_range_);
footage_->SetVideoParams(vp, video_index_);
}
@@ -221,6 +237,7 @@ void VideoStreamProperties::VideoStreamChangeCommand::undo()
vp.set_colorspace(old_colorspace_);
vp.set_interlacing(old_interlacing_);
vp.set_pixel_aspect_ratio(old_pixel_ar_);
vp.set_color_range(old_range_);
footage_->SetVideoParams(vp, video_index_);
}
app/dialog/footageproperties/streamproperties/videostreamproperties.h
+9 -1
View File
@@ -56,6 +56,11 @@ private:
*/
QComboBox* video_color_space_;
/**
* @brief Setting for this streams's color range
*/
QComboBox *color_range_combo_;
/**
* @brief Setting for video interlacing
*/
@@ -88,7 +93,8 @@ private:
bool premultiplied,
QString colorspace,
VideoParams::Interlacing interlacing,
const rational& pixel_ar);
const rational& pixel_ar,
VideoParams::ColorRange range);
virtual Project* GetRelevantProject() const override;
@@ -104,11 +110,13 @@ private:
QString new_colorspace_;
VideoParams::Interlacing new_interlacing_;
rational new_pixel_ar_;
VideoParams::ColorRange new_range_;
bool old_premultiplied_;
QString old_colorspace_;
VideoParams::Interlacing old_interlacing_;
rational old_pixel_ar_;
VideoParams::ColorRange old_range_;
};
app/dialog/preferences/tabs/preferencesbehaviortab.cpp
+5
View File
@@ -44,6 +44,11 @@ PreferencesBehaviorTab::PreferencesBehaviorTab()
AddItem(tr("Enable slider ladder"),
QStringLiteral("UseSliderLadders"),
general_group);
AddItem(tr("Scrolling zooms by default"),
QStringLiteral("ScrollZooms"),
tr("By default, scrolling will move the view around, and holding Ctrl/Cmd will make it zoom instead. "
"Enabling this will switch those, scrolling will zoom by default, and holding Ctrl/Cmd will move the view instead."),
general_group);
QTreeWidgetItem* audio_group = AddParent(tr("Audio"));
AddItem(tr("Enable audio scrubbing"),
app/dialog/sequence/sequence.cpp
+2 -2
View File
@@ -102,7 +102,7 @@ void SequenceDialog::SetNameIsEditable(bool e)
void SequenceDialog::accept()
{
if (name_field_->isEnabled() && name_field_->text().isEmpty()) {
QtUtils::MessageBox(this, QMessageBox::Critical, tr("Error editing Sequence"), tr("Please enter a name for this Sequence."));
QtUtils::MsgBox(this, QMessageBox::Critical, tr("Error editing Sequence"), tr("Please enter a name for this Sequence."));
return;
}
@@ -167,7 +167,7 @@ void SequenceDialog::accept()
void SequenceDialog::SetAsDefaultClicked()
{
if (QtUtils::MessageBox(this, QMessageBox::Question, tr("Confirm Set As Default"),
if (QtUtils::MsgBox(this, QMessageBox::Question, tr("Confirm Set As Default"),
tr("Are you sure you want to set the current parameters as defaults?"),
QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
// Maybe replace with Preset system
app/dialog/speedduration/speeddurationdialog.cpp
+46 -6
View File
@@ -38,12 +38,12 @@ SpeedDurationDialog::SpeedDurationDialog(const QVector<ClipBlock *> &clips, cons
clips_(clips),
timebase_(timebase)
{
setWindowTitle(tr("Speed/Duration"));
setWindowTitle(tr("Clip Properties"));
QVBoxLayout *layout = new QVBoxLayout(this);
{
QGroupBox *speed_group = new QGroupBox();
QGroupBox *speed_group = new QGroupBox(tr("Speed/Duration"));
layout->addWidget(speed_group);
QGridLayout *speed_layout = new QGridLayout(speed_group);
@@ -72,16 +72,39 @@ SpeedDurationDialog::SpeedDurationDialog(const QVector<ClipBlock *> &clips, cons
link_box_ = new QCheckBox(tr("Link Speed and Duration"));
link_box_->setChecked(true);
speed_layout->addWidget(link_box_, row, 0, 1, 2);
}
row++;
reverse_box_ = new QCheckBox(tr("Reverse"));
layout->addWidget(reverse_box_);
speed_layout->addWidget(reverse_box_, row, 0, 1, 2);
row++;
maintain_audio_pitch_box_ = new QCheckBox(tr("Maintain Audio Pitch"));
layout->addWidget(maintain_audio_pitch_box_);
speed_layout->addWidget(maintain_audio_pitch_box_, row, 0, 1, 2);
row++;
ripple_box_ = new QCheckBox(tr("Ripple Trailing Clips"));
layout->addWidget(ripple_box_);
speed_layout->addWidget(ripple_box_, row, 0, 1, 2);
}
{
auto loop_box = new QGroupBox(tr("Loop"));
layout->addWidget(loop_box);
auto loop_layout = new QGridLayout(loop_box);
int row = 0;
loop_layout->addWidget(new QLabel(tr("Loop:")), row, 0);
loop_combo_ = new QComboBox();
loop_combo_->addItem(tr("None"), Decoder::kLoopModeOff);
loop_combo_->addItem(tr("Loop"), Decoder::kLoopModeLoop);
loop_combo_->addItem(tr("Clamp"), Decoder::kLoopModeClamp);
loop_layout->addWidget(loop_combo_, row, 1);
}
QDialogButtonBox *btns = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
btns->setCenterButtons(true);
@@ -94,6 +117,7 @@ SpeedDurationDialog::SpeedDurationDialog(const QVector<ClipBlock *> &clips, cons
start_duration_ = clips.first()->length();
start_reverse_ = clips.first()->reverse();
start_maintain_audio_pitch_ = clips.first()->maintain_audio_pitch();
start_loop_ = clips.first()->loop_mode();
for (int i=1; i<clips.size(); i++) {
ClipBlock *c = clips.at(i);
@@ -116,6 +140,10 @@ SpeedDurationDialog::SpeedDurationDialog(const QVector<ClipBlock *> &clips, cons
if (start_maintain_audio_pitch_ != -1 && clip_maintain_pitch != start_maintain_audio_pitch_) {
start_maintain_audio_pitch_ = -1;
}
if (start_loop_ != -1 && c->loop_mode() != start_loop_) {
start_loop_ = -1;
}
}
if (qIsNaN(start_speed_)) {
@@ -141,6 +169,12 @@ SpeedDurationDialog::SpeedDurationDialog(const QVector<ClipBlock *> &clips, cons
} else {
maintain_audio_pitch_box_->setChecked(start_maintain_audio_pitch_);
}
if (start_loop_ == -1) {
loop_combo_->setCurrentIndex(-1);
} else {
loop_combo_->setCurrentIndex(start_loop_);
}
}
void SpeedDurationDialog::accept()
@@ -211,6 +245,12 @@ void SpeedDurationDialog::accept()
}
}
if (loop_combo_->currentIndex() != -1) {
foreach (ClipBlock *c, clips_) {
command->add_child(new NodeParamSetStandardValueCommand(NodeKeyframeTrackReference(NodeInput(c, ClipBlock::kLoopModeInput)), loop_combo_->currentData()));
}
}
Core::instance()->undo_stack()->push(command);
super::accept();
app/dialog/speedduration/speeddurationdialog.h
+5
View File
@@ -22,6 +22,7 @@
#define SPEEDDURATIONDIALOG_H
#include <QCheckBox>
#include <QComboBox>
#include <QDialog>
#include "node/block/clip/clip.h"
@@ -62,6 +63,8 @@ private:
QCheckBox *ripple_box_;
QComboBox *loop_combo_;
int start_reverse_;
int start_maintain_audio_pitch_;
@@ -70,6 +73,8 @@ private:
rational start_duration_;
int start_loop_;
rational timebase_;
private slots:
app/node/block/clip/clip.cpp
+28 -7
View File
@@ -35,6 +35,7 @@ const QString ClipBlock::kSpeedInput = QStringLiteral("speed_in");
const QString ClipBlock::kReverseInput = QStringLiteral("reverse_in");
const QString ClipBlock::kMaintainAudioPitchInput = QStringLiteral("maintain_audio_pitch_in");
const QString ClipBlock::kAutoCacheInput = QStringLiteral("autocache_in");
const QString ClipBlock::kLoopModeInput = QStringLiteral("loop_in");
ClipBlock::ClipBlock() :
in_transition_(nullptr),
@@ -59,6 +60,8 @@ ClipBlock::ClipBlock() :
//SetValueHintForInput(kBufferIn, ValueHint(NodeValue::kBuffer));
SetEffectInput(kBufferIn);
AddInput(kLoopModeInput, NodeValue::kCombo, 0, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
}
QString ClipBlock::Name() const
@@ -92,7 +95,7 @@ void ClipBlock::set_length_and_media_out(const rational &length)
if (reverse()) {
// Calculate media_in adjustment
rational proposed_media_in = SequenceToMediaTime(this->length() - length, true);
rational proposed_media_in = SequenceToMediaTime(this->length() - length, kSTMIgnoreReverse | kSTMIgnoreLoop);
set_media_in(proposed_media_in);
}
@@ -107,8 +110,7 @@ void ClipBlock::set_length_and_media_in(const rational &length)
if (!reverse()) {
// Calculate media_in adjustment
rational proposed_media_in = SequenceToMediaTime(this->length() - length, false, true);
set_media_in(proposed_media_in);
set_media_in(SequenceToMediaTime(this->length() - length, kSTMIgnoreLoop));
}
super::set_length_and_media_in(length);
@@ -129,7 +131,7 @@ void ClipBlock::SetAutocache(bool e)
SetStandardValue(kAutoCacheInput, e);
}
rational ClipBlock::SequenceToMediaTime(const rational &sequence_time, bool ignore_reverse, bool ignore_speed) const
rational ClipBlock::SequenceToMediaTime(const rational &sequence_time, uint64_t flags) const
{
// These constants are not considered "values" per se, so we don't modify them
if (sequence_time == RATIONAL_MIN || sequence_time == RATIONAL_MAX) {
@@ -138,11 +140,11 @@ rational ClipBlock::SequenceToMediaTime(const rational &sequence_time, bool igno
rational media_time = sequence_time;
if (reverse() && !ignore_reverse) {
if (reverse() && !(flags & kSTMIgnoreReverse)) {
media_time = length() - media_time;
}
if (!ignore_speed) {
if (!(flags & kSTMIgnoreSpeed)) {
double speed_value = speed();
if (qIsNull(speed_value)) {
// Effectively holds the frame at the in point
@@ -155,6 +157,23 @@ rational ClipBlock::SequenceToMediaTime(const rational &sequence_time, bool igno
media_time += media_in();
/*if (!(flags & kSTMIgnoreLoop)
&& this->loop_mode() != kLoopModeOff
&& connected_viewer_
&& !connected_viewer_->GetLength().isNull()
&& (media_time < 0 || media_time >= connected_viewer_->GetLength())) {
if (loop_mode() == kLoopModeLoop) {
while (media_time < 0) {
media_time += connected_viewer_->GetLength();
}
while (media_time >= connected_viewer_->GetLength()) {
media_time -= connected_viewer_->GetLength();
}
} else if (loop_mode() == kLoopModeClamp) {
media_time = std::clamp(media_time, rational(0), connected_viewer_->GetLength()-connected_viewer_->GetVideoParams().frame_rate_as_time_base());
}
}*/
return media_time;
}
@@ -412,6 +431,8 @@ void ClipBlock::Retranslate()
SetInputName(kSpeedInput, tr("Speed"));
SetInputName(kReverseInput, tr("Reverse"));
SetInputName(kMaintainAudioPitchInput, tr("Maintain Audio Pitch"));
SetInputName(kLoopModeInput, tr("Loop"));
SetComboBoxStrings(kLoopModeInput, {tr("None"), tr("Loop"), tr("Clamp")});
}
void ClipBlock::AddCachePassthroughFrom(ClipBlock *other)
@@ -448,7 +469,7 @@ void ClipBlock::ConnectedToPreviewEvent()
TimeRange ClipBlock::media_range() const
{
return InputTimeAdjustment(kBufferIn, -1, range());
return InputTimeAdjustment(kBufferIn, -1, TimeRange(0, length()));
}
}
app/node/block/clip/clip.h
+24 -1
View File
@@ -22,6 +22,7 @@
#define CLIPBLOCK_H
#include "audio/audiovisualwaveform.h"
#include "codec/decoder.h"
#include "node/block/block.h"
#include "node/output/track/track.h"
@@ -179,11 +180,25 @@ public:
TimeRange media_range() const;
/**
* @brief Get currently set loop mode
*/
Decoder::LoopMode loop_mode() const
{
return static_cast<Decoder::LoopMode>(GetStandardValue(kLoopModeInput).toInt());
}
void set_loop_mode(Decoder::LoopMode l)
{
SetStandardValue(kLoopModeInput, int(l));
}
static const QString kBufferIn;
static const QString kMediaInInput;
static const QString kSpeedInput;
static const QString kReverseInput;
static const QString kMaintainAudioPitchInput;
static const QString kLoopModeInput;
static const QString kAutoCacheInput;
@@ -197,7 +212,15 @@ protected:
virtual void InputValueChangedEvent(const QString& input, int element) override;
private:
rational SequenceToMediaTime(const rational& sequence_time, bool ignore_reverse = false, bool ignore_speed = false) const;
enum SequenceToMediaTimeFlag
{
kSTMNone = 0x0,
kSTMIgnoreReverse = 0x1,
kSTMIgnoreSpeed = 0x2,
kSTMIgnoreLoop = 0x4
};
rational SequenceToMediaTime(const rational& sequence_time, uint64_t flags = kSTMNone) const;
rational MediaToSequenceTime(const rational& media_time) const;
app/node/block/transition/crossdissolve/crossdissolvetransition.cpp
-7
View File
@@ -53,13 +53,6 @@ ShaderCode CrossDissolveTransition::GetShaderCode(const ShaderRequest &request)
return ShaderCode(FileFunctions::ReadFileAsString(":/shaders/crossdissolve.frag"), QString());
}
void CrossDissolveTransition::ShaderJobEvent(const NodeValueRow &value, ShaderJob &job) const
{
Q_UNUSED(value)
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
}
void CrossDissolveTransition::SampleJobEvent(const SampleBuffer &from_samples, const SampleBuffer &to_samples, SampleBuffer &out_samples, double time_in) const
{
for (int i=0; i<out_samples.sample_count(); i++) {
app/node/block/transition/crossdissolve/crossdissolvetransition.h
-2
View File
@@ -43,8 +43,6 @@ public:
virtual ShaderCode GetShaderCode(const ShaderRequest &request) const override;
protected:
virtual void ShaderJobEvent(const NodeValueRow &value, ShaderJob& job) const override;
virtual void SampleJobEvent(const SampleBuffer &from_samples, const SampleBuffer &to_samples, SampleBuffer &out_samples, double time_in) const override;
};
app/node/distort/cornerpin/cornerpindistortnode.cpp
-1
View File
@@ -71,7 +71,6 @@ void CornerPinDistortNode::Value(const NodeValueRow &value, const NodeGlobals &g
{
ShaderJob job;
job.Insert(value);
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
job.Insert(QStringLiteral("resolution_in"), NodeValue(NodeValue::kVec2, globals.resolution(), this));
// Convert slider values to their pixel values and then convert to clip space (-1.0 ... 1.0) for overriding the
app/node/distort/crop/cropdistortnode.cpp
-1
View File
@@ -79,7 +79,6 @@ void CropDistortNode::Value(const NodeValueRow &value, const NodeGlobals &global
{
ShaderJob job;
job.Insert(value);
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
job.SetWillChangeImageSize(false);
if (TexturePtr texture = job.Get(kTextureInput).toTexture()) {
app/node/distort/mask/mask.cpp
+2 -3
View File
@@ -44,7 +44,7 @@ ShaderCode MaskDistortNode::GetShaderCode(const ShaderRequest &request) const
} else if (request.id == QStringLiteral("feather")) {
return ShaderCode(FileFunctions::ReadFileAsString(QStringLiteral(":/shaders/blur.frag")));
} else {
return ShaderCode();
return super::GetShaderCode(request);
}
}
@@ -58,7 +58,7 @@ void MaskDistortNode::Retranslate()
void MaskDistortNode::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
GenerateJob job = GetGenerateJob(value);
ShaderJob job = GetGenerateJob(value);
if (value[kBaseInput].toTexture()) {
// Push as merge node
@@ -80,7 +80,6 @@ void MaskDistortNode::Value(const NodeValueRow &value, const NodeGlobals &global
feather.Insert(BlurFilterNode::kRadiusInput, NodeValue(NodeValue::kFloat, value[kFeatherInput].toDouble(), this));
feather.SetIterations(2, BlurFilterNode::kTextureInput);
feather.Insert(QStringLiteral("resolution_in"), NodeValue(NodeValue::kVec2, globals.resolution(), this));
feather.SetAlphaChannelRequired(ShaderJob::kAlphaForceOn);
merge.Insert(QStringLiteral("tex_b"), NodeValue(NodeValue::kTexture, feather, this));
} else {
app/node/distort/transform/transformdistortnode.cpp
+18 -19
View File
@@ -22,12 +22,9 @@
#include <QGuiApplication>
#include "common/range.h"
#include "core.h"
#include "node/traverser.h"
namespace olive {
const QString TransformDistortNode::kParentInput = QStringLiteral("parent_in");
const QString TransformDistortNode::kTextureInput = QStringLiteral("tex_in");
const QString TransformDistortNode::kAutoscaleInput = QStringLiteral("autoscale_in");
const QString TransformDistortNode::kInterpolationInput = QStringLiteral("interpolation_in");
@@ -36,6 +33,8 @@ const QString TransformDistortNode::kInterpolationInput = QStringLiteral("interp
TransformDistortNode::TransformDistortNode()
{
AddInput(kParentInput, NodeValue::kMatrix);
AddInput(kAutoscaleInput, NodeValue::kCombo, 0);
AddInput(kInterpolationInput, NodeValue::kCombo, 2);
@@ -73,6 +72,7 @@ void TransformDistortNode::Retranslate()
{
super::Retranslate();
SetInputName(kParentInput, tr("Parent"));
SetInputName(kAutoscaleInput, tr("Auto-Scale"));
SetInputName(kTextureInput, tr("Texture"));
SetInputName(kInterpolationInput, tr("Interpolation"));
@@ -84,12 +84,12 @@ void TransformDistortNode::Retranslate()
void TransformDistortNode::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
// Generate matrix
QMatrix4x4 generated_matrix = GenerateMatrix(value, false, false, false);
QMatrix4x4 generated_matrix = GenerateMatrix(value, false, false, false, value[kParentInput].toMatrix());
// Pop texture
NodeValue texture_meta = value[kTextureInput];
bool pushed_job = false;
QVariant job_to_push;
// If we have a texture, generate a matrix and make it happen
if (TexturePtr texture = texture_meta.toTexture()) {
@@ -103,19 +103,17 @@ void TransformDistortNode::Value(const NodeValueRow &value, const NodeGlobals &g
job.Insert(QStringLiteral("ove_mvpmat"), NodeValue(NodeValue::kMatrix, real_matrix, this));
job.SetInterpolation(QStringLiteral("ove_maintex"), static_cast<Texture::Interpolation>(value[kInterpolationInput].toInt()));
// FIXME: This should be optimized, we can use matrix math to determine if this operation will
// end up with gaps in the screen that will require an alpha channel.
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
table->Push(NodeValue::kTexture, QVariant::fromValue(job), this);
pushed_job = true;
job_to_push = QVariant::fromValue(job);
}
}
if (!pushed_job) {
table->Push(NodeValue::kMatrix, QVariant::fromValue(generated_matrix), this);
if (job_to_push.isNull()) {
// Re-push whatever value we received
table->Push(texture_meta);
} else {
table->Push(NodeValue::kTexture, job_to_push, this);
}
}
@@ -133,7 +131,7 @@ void TransformDistortNode::GizmoDragStart(const NodeValueRow &row, double x, dou
if (gizmo == anchor_gizmo_) {
gizmo_inverted_transform_ = GenerateMatrix(row, true, true, false).toTransform().inverted();
gizmo_inverted_transform_ = GenerateMatrix(row, true, true, false, row[kParentInput].toMatrix()).toTransform().inverted();
} else if (IsAScaleGizmo(gizmo)) {
@@ -175,7 +173,7 @@ void TransformDistortNode::GizmoDragStart(const NodeValueRow &row, double x, dou
}
// Store current matrix
gizmo_inverted_transform_ = GenerateMatrix(row, true, true, true).toTransform().inverted();
gizmo_inverted_transform_ = GenerateMatrix(row, true, true, true, row[kParentInput].toMatrix()).toTransform().inverted();
} else if (gizmo == rotation_gizmo_) {
@@ -360,7 +358,7 @@ void TransformDistortNode::UpdateGizmoPositions(const NodeValueRow &row, const N
// Fold values into a matrix for the rectangle
QMatrix4x4 rectangle_matrix;
rectangle_matrix.scale(sequence_half_res);
rectangle_matrix *= AdjustMatrixByResolutions(GenerateMatrix(row, false, false, false),
rectangle_matrix *= AdjustMatrixByResolutions(GenerateMatrix(row, false, false, false, row[kParentInput].toMatrix()),
sequence_res,
tex_sz,
tex_offset,
@@ -380,7 +378,7 @@ void TransformDistortNode::UpdateGizmoPositions(const NodeValueRow &row, const N
// Draw anchor point
QMatrix4x4 anchor_matrix;
anchor_matrix.scale(sequence_half_res);
anchor_matrix *= AdjustMatrixByResolutions(GenerateMatrix(row, true, false, false),
anchor_matrix *= AdjustMatrixByResolutions(GenerateMatrix(row, true, false, false, row[kParentInput].toMatrix()),
sequence_res,
tex_sz,
tex_offset,
@@ -406,7 +404,8 @@ void TransformDistortNode::UpdateGizmoPositions(const NodeValueRow &row, const N
QTransform TransformDistortNode::GizmoTransformation(const NodeValueRow &row, const NodeGlobals &globals) const
{
if (TexturePtr texture = row[kTextureInput].toTexture()) {
auto m = GenerateMatrix(row, false, false, false);
//auto m = GenerateMatrix(row, false, false, false, row[kParentInput].toMatrix());
auto m = GenerateMatrix(row, false, false, false, QMatrix4x4());
return GenerateAutoScaledMatrix(m, row, globals, texture->params()).toTransform();
}
return super::GizmoTransformation(row, globals);
app/node/distort/transform/transformdistortnode.h
+1
View File
@@ -84,6 +84,7 @@ public:
virtual void UpdateGizmoPositions(const NodeValueRow &row, const NodeGlobals &globals) override;
virtual QTransform GizmoTransformation(const NodeValueRow &row, const NodeGlobals &globals) const override;
static const QString kParentInput;
static const QString kTextureInput;
static const QString kAutoscaleInput;
static const QString kInterpolationInput;
app/node/effect/opacity/opacityeffect.cpp
-1
View File
@@ -52,7 +52,6 @@ void OpacityEffect::Value(const NodeValueRow &value, const NodeGlobals &globals,
// If there's no texture, no need to run an operation
if (job.Get(kTextureInput).toTexture()) {
if (!qFuzzyCompare(job.Get(kValueInput).toDouble(), 1.0)) {
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
table->Push(NodeValue::kTexture, QVariant::fromValue(job), this);
} else {
// 1.0 float is a no-op, so just push the texture
app/node/factory.cpp
+3
View File
@@ -62,6 +62,7 @@
#include "project/folder/folder.h"
#include "project/footage/footage.h"
#include "project/sequence/sequence.h"
#include "time/timeformat/timeformat.h"
#include "time/timeoffset/timeoffsetnode.h"
#include "time/timeremap/timeremap.h"
@@ -291,6 +292,8 @@ Node *NodeFactory::CreateFromFactoryIndex(const NodeFactory::InternalID &id)
return new MaskDistortNode();
case kDropShadowFilter:
return new DropShadowFilter();
case kTimeFormat:
return new TimeFormatNode();
case kInternalNodeCount:
break;
app/node/factory.h
+1
View File
@@ -75,6 +75,7 @@ public:
kChromaKey,
kMaskDistort,
kDropShadowFilter,
kTimeFormat,
// Count value
kInternalNodeCount
app/node/filter/blur/blur.cpp
-5
View File
@@ -159,11 +159,6 @@ void BlurFilterNode::Value(const NodeValueRow &value, const NodeGlobals &globals
}
if (can_push_job) {
// If we're not repeating pixels, expect an alpha channel to appear
if (!job.Get(kRepeatEdgePixelsInput).toBool()) {
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
}
table->Push(NodeValue::kTexture, QVariant::fromValue(job), this);
} else {
// If we're not performing the blur job, just push the texture
app/node/generator/matrix/matrix.cpp
+6 -6
View File
@@ -90,11 +90,11 @@ void MatrixGenerator::Retranslate()
void MatrixGenerator::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
// Push matrix output
QMatrix4x4 mat = GenerateMatrix(value, false, false, false);
QMatrix4x4 mat = GenerateMatrix(value, false, false, false, QMatrix4x4());
table->Push(NodeValue::kMatrix, mat, this);
}
QMatrix4x4 MatrixGenerator::GenerateMatrix(const NodeValueRow &value, bool ignore_anchor, bool ignore_position, bool ignore_scale) const
QMatrix4x4 MatrixGenerator::GenerateMatrix(const NodeValueRow &value, bool ignore_anchor, bool ignore_position, bool ignore_scale, const QMatrix4x4 &mat) const
{
QVector2D anchor;
QVector2D position;
@@ -116,17 +116,17 @@ QMatrix4x4 MatrixGenerator::GenerateMatrix(const NodeValueRow &value, bool ignor
value[kRotationInput].toDouble(),
scale,
value[kUniformScaleInput].toBool(),
anchor);
anchor,
mat);
}
QMatrix4x4 MatrixGenerator::GenerateMatrix(const QVector2D& pos,
const float& rot,
const QVector2D& scale,
bool uniform_scale,
const QVector2D& anchor)
const QVector2D& anchor,
QMatrix4x4 mat)
{
QMatrix4x4 mat;
// Position
mat.translate(pos);
app/node/generator/matrix/matrix.h
+3 -2
View File
@@ -53,12 +53,13 @@ public:
static const QString kAnchorInput;
protected:
QMatrix4x4 GenerateMatrix(const NodeValueRow &value, bool ignore_anchor, bool ignore_position, bool ignore_scale) const;
QMatrix4x4 GenerateMatrix(const NodeValueRow &value, bool ignore_anchor, bool ignore_position, bool ignore_scale, const QMatrix4x4 &mat) const;
static QMatrix4x4 GenerateMatrix(const QVector2D &pos,
const float &rot,
const QVector2D &scale,
bool uniform_scale,
const QVector2D &anchor);
const QVector2D &anchor,
QMatrix4x4 mat);
virtual void InputValueChangedEvent(const QString& input, int element) override;
app/node/generator/polygon/polygon.cpp
+20 -36
View File
@@ -23,8 +23,6 @@
#include <QGuiApplication>
#include <QVector2D>
#include "common/cpuoptimize.h"
namespace olive {
const QString PolygonGenerator::kPointsInput = QStringLiteral("points_in");
@@ -89,20 +87,25 @@ void PolygonGenerator::Retranslate()
SetInputName(kColorInput, tr("Color"));
}
GenerateJob PolygonGenerator::GetGenerateJob(const NodeValueRow &value) const
ShaderJob PolygonGenerator::GetGenerateJob(const NodeValueRow &value) const
{
GenerateJob job;
job.Insert(value);
job.SetRequestedFormat(VideoParams::kFormatFloat32);
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
job.SetRequestedFormat(VideoParams::kFormatUnsigned8);
return job;
// Conversion to RGB
ShaderJob rgb;
rgb.SetShaderID(QStringLiteral("rgb"));
rgb.Insert(QStringLiteral("texture_in"), NodeValue(NodeValue::kTexture, job, this));
rgb.Insert(QStringLiteral("color_in"), value[kColorInput]);
return rgb;
}
void PolygonGenerator::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
GenerateJob job = GetGenerateJob(value);
ShaderJob job = GetGenerateJob(value);
PushMergableJob(value, QVariant::fromValue(job), table);
}
@@ -113,7 +116,7 @@ void PolygonGenerator::GenerateFrame(FramePtr frame, const GenerateJob &job) con
// QImages only support integer pixels and we use float pixels, so what we do here is draw onto
// a single-channel QImage (alpha only) and then transplant that alpha channel to our float buffer
// with correct float RGB.
QImage img(frame->width(), frame->height(), QImage::Format_Grayscale8);
QImage img((uchar *) frame->data(), frame->width(), frame->height(), frame->linesize_bytes(), QImage::Format_RGBA8888_Premultiplied);
img.fill(Qt::transparent);
QVector<NodeValue> points = job.Get(kPointsInput).value< QVector<NodeValue> >();
@@ -128,34 +131,6 @@ void PolygonGenerator::GenerateFrame(FramePtr frame, const GenerateJob &job) con
p.setPen(Qt::NoPen);
p.drawPath(path);
// Transplant alpha channel to frame
Color rgba = job.Get(kColorInput).toColor();
#if defined(Q_PROCESSOR_X86) || defined(Q_PROCESSOR_ARM)
__m128 sse_color = _mm_loadu_ps(rgba.data());
#endif
float *frame_dst = reinterpret_cast<float*>(frame->data());
for (int y=0; y<frame->height(); y++) {
uchar *src_y = img.bits() + img.bytesPerLine() * y;
float *dst_y = frame_dst + y*frame->linesize_pixels()*VideoParams::kRGBAChannelCount;
for (int x=0; x<frame->width(); x++) {
float alpha = float(src_y[x]) / 255.0f;
float *dst = dst_y + x*VideoParams::kRGBAChannelCount;
#if defined(Q_PROCESSOR_X86) || defined(Q_PROCESSOR_ARM)
__m128 sse_alpha = _mm_load1_ps(&alpha);
__m128 sse_res = _mm_mul_ps(sse_color, sse_alpha);
_mm_store_ps(dst, sse_res);
#else
for (int i=0; i<VideoParams::kRGBAChannelCount; i++) {
dst[i] = rgba.data()[i] * alpha;
}
#endif
}
}
}
template<typename T>
@@ -241,6 +216,15 @@ void PolygonGenerator::UpdateGizmoPositions(const NodeValueRow &row, const NodeG
poly_gizmo_->SetPath(GeneratePath(points).translated(half_res));
}
ShaderCode PolygonGenerator::GetShaderCode(const ShaderRequest &request) const
{
if (request.id == QStringLiteral("rgb")) {
return ShaderCode(FileFunctions::ReadFileAsString(":/shaders/rgb.frag"));
} else {
return super::GetShaderCode(request);
}
}
void PolygonGenerator::GizmoDragMove(double x, double y, const Qt::KeyboardModifiers &modifiers)
{
DraggableGizmo *gizmo = static_cast<DraggableGizmo*>(sender());
app/node/generator/polygon/polygon.h
+3 -1
View File
@@ -54,11 +54,13 @@ public:
virtual void UpdateGizmoPositions(const NodeValueRow &row, const NodeGlobals &globals) override;
virtual ShaderCode GetShaderCode(const ShaderRequest &request) const override;
static const QString kPointsInput;
static const QString kColorInput;
protected:
GenerateJob GetGenerateJob(const NodeValueRow &value) const;
ShaderJob GetGenerateJob(const NodeValueRow &value) const;
protected slots:
virtual void GizmoDragMove(double x, double y, const Qt::KeyboardModifiers &modifiers) override;
app/node/generator/shape/shapenode.cpp
+20 -2
View File
@@ -25,10 +25,14 @@ namespace olive {
#define super ShapeNodeBase
QString ShapeNode::kTypeInput = QStringLiteral("type_in");
QString ShapeNode::kRadiusInput = QStringLiteral("radius_in");
ShapeNode::ShapeNode()
{
PrependInput(kTypeInput, NodeValue::kCombo);
AddInput(kRadiusInput, NodeValue::kFloat, 20.0);
SetInputProperty(kRadiusInput, QStringLiteral("min"), 0.0);
}
QString ShapeNode::Name() const
@@ -56,9 +60,10 @@ void ShapeNode::Retranslate()
super::Retranslate();
SetInputName(kTypeInput, tr("Type"));
SetInputName(kRadiusInput, tr("Radius"));
// Coordinate with Type enum
SetComboBoxStrings(kTypeInput, {tr("Rectangle"), tr("Ellipse")});
SetComboBoxStrings(kTypeInput, {tr("Rectangle"), tr("Ellipse"), tr("Rounded Rectangle")});
}
ShaderCode ShapeNode::GetShaderCode(const ShaderRequest &request) const
@@ -76,10 +81,23 @@ void ShapeNode::Value(const NodeValueRow &value, const NodeGlobals &globals, Nod
job.Insert(value);
job.Insert(QStringLiteral("resolution_in"), NodeValue(NodeValue::kVec2, globals.resolution(), this));
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
job.SetShaderID(QStringLiteral("shape"));
PushMergableJob(value, QVariant::fromValue(job), table);
}
void ShapeNode::InputValueChangedEvent(const QString &input, int element)
{
if (input == kTypeInput) {
InputFlags i = GetInputFlags(kRadiusInput);
if (GetStandardValue(kTypeInput).toInt() == kRoundedRectangle) {
i &= InputFlag(~kInputFlagHidden);
} else {
i |= kInputFlagHidden;
}
SetInputFlags(kRadiusInput, i);
}
super::InputValueChangedEvent(input, element);
}
}
app/node/generator/shape/shapenode.h
+6 -1
View File
@@ -33,7 +33,8 @@ public:
enum Type {
kRectangle,
kEllipse
kEllipse,
kRoundedRectangle
};
NODE_DEFAULT_FUNCTIONS(ShapeNode)
@@ -49,6 +50,10 @@ public:
virtual void Value(const NodeValueRow& value, const NodeGlobals &globals, NodeValueTable *table) const override;
static QString kTypeInput;
static QString kRadiusInput;
protected:
virtual void InputValueChangedEvent(const QString &input, int element) override;
};
app/node/generator/text/textv1.cpp
-1
View File
@@ -94,7 +94,6 @@ void TextGeneratorV1::Value(const NodeValueRow &value, const NodeGlobals &global
{
GenerateJob job;
job.Insert(value);
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
if (!job.Get(kTextInput).toString().isEmpty()) {
table->Push(NodeValue::kTexture, QVariant::fromValue(job), this);
app/node/generator/text/textv2.cpp
-1
View File
@@ -96,7 +96,6 @@ void TextGeneratorV2::Value(const NodeValueRow &value, const NodeGlobals &global
{
GenerateJob job;
job.Insert(value);
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
job.SetRequestedFormat(VideoParams::kFormatFloat32);
if (!job.Get(kTextInput).toString().isEmpty()) {
app/node/generator/text/textv3.cpp
+90 -1
View File
@@ -38,6 +38,9 @@ enum TextVerticalAlign {
};
const QString TextGeneratorV3::kTextInput = QStringLiteral("text_in");
const QString TextGeneratorV3::kVerticalAlignmentInput = QStringLiteral("valign_in");
const QString TextGeneratorV3::kUseArgsInput = QStringLiteral("use_args_in");
const QString TextGeneratorV3::kArgsInput = QStringLiteral("args_in");
TextGeneratorV3::TextGeneratorV3() :
ShapeNodeBase(false)
@@ -47,8 +50,17 @@ TextGeneratorV3::TextGeneratorV3() :
SetStandardValue(kSizeInput, QVector2D(400, 300));
AddInput(kVerticalAlignmentInput, NodeValue::kCombo);
AddInput(kUseArgsInput, NodeValue::kBoolean, true, InputFlags(kInputFlagHidden | kInputFlagStatic));
AddInput(kArgsInput, NodeValue::kText, InputFlags(kInputFlagArray));
SetInputProperty(kArgsInput, QStringLiteral("arraystart"), 1);
text_gizmo_ = new TextGizmo(this);
text_gizmo_->SetInput(NodeInput(this, kTextInput));
connect(text_gizmo_, &TextGizmo::Activated, this, &TextGeneratorV3::GizmoActivated);
connect(text_gizmo_, &TextGizmo::Deactivated, this, &TextGeneratorV3::GizmoDeactivated);
}
QString TextGeneratorV3::Name() const
@@ -76,15 +88,32 @@ void TextGeneratorV3::Retranslate()
super::Retranslate();
SetInputName(kTextInput, tr("Text"));
SetInputName(kVerticalAlignmentInput, tr("Vertical Alignment"));
SetComboBoxStrings(kVerticalAlignmentInput, {tr("Top"), tr("Middle"), tr("Bottom")});
SetInputName(kArgsInput, tr("Arguments"));
}
void TextGeneratorV3::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
GenerateJob job;
job.Insert(value);
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
job.SetRequestedFormat(VideoParams::kFormatUnsigned8);
if (value[kUseArgsInput].toBool()) {
auto args = value[kArgsInput].toArray();
if (!args.empty()) {
QStringList list;
list.reserve(args.size());
for (int i=0; i<args.size(); i++) {
list.append(args[i].toString());
}
NodeValue v = job.Get(kTextInput);
v.set_value(FormatString(v.toString(), list));
job.Insert(kTextInput, v);
}
}
// FIXME: Provide user override for this
job.SetColorspace(project()->color_manager()->GetDefaultInputColorSpace());
@@ -123,6 +152,18 @@ void TextGeneratorV3::GenerateFrame(FramePtr frame, const GenerateJob& job) cons
p.translate(frame->video_params().width()/2, frame->video_params().height()/2);
p.setClipRect(0, 0, size.x(), size.y());
switch (static_cast<VerticalAlignment>(job.Get(kVerticalAlignmentInput).toInt())) {
case kVAlignTop:
// Do nothing
break;
case kVAlignMiddle:
p.translate(0, size.y()/2-text_doc.size().height()/2);
break;
case kVAlignBottom:
p.translate(0, size.y()-text_doc.size().height());
break;
}
// Ensure default text color is white
QAbstractTextDocumentLayout::PaintContext ctx;
ctx.palette.setColor(QPalette::Text, Qt::white);
@@ -139,4 +180,52 @@ void TextGeneratorV3::UpdateGizmoPositions(const NodeValueRow &row, const NodeGl
text_gizmo_->SetHtml(row[kTextInput].toString());
}
QString TextGeneratorV3::FormatString(const QString &input, const QStringList &args)
{
QString output;
output.reserve(input.size());
for (int i=0; i<input.size(); i++) {
const QChar &this_char = input.at(i);
if (i < input.size()-1 && this_char == '%') {
const QChar &next_char = input.at(i+1);
if (next_char == '%') {
// Double percent, append a single percent
output.append('%');
i++;
} else if (next_char.isDigit()) {
// Find length of number
QString num;
i++;
while (i < input.size() && input.at(i).isDigit()) {
num.append(input.at(i));
i++;
}
i--;
int index = num.toInt()-1;
if (index >= 0 && index < args.size()) {
output.append(args.at(index));
}
} else {
output.append(this_char);
}
} else {
output.append(this_char);
}
}
return output;
}
void TextGeneratorV3::GizmoActivated()
{
SetStandardValue(kUseArgsInput, false);
}
void TextGeneratorV3::GizmoDeactivated()
{
SetStandardValue(kUseArgsInput, true);
}
}
app/node/generator/text/textv3.h
+16
View File
@@ -47,11 +47,27 @@ public:
virtual void UpdateGizmoPositions(const NodeValueRow &row, const NodeGlobals &globals) override;
enum VerticalAlignment
{
kVAlignTop,
kVAlignMiddle,
kVAlignBottom
};
static const QString kTextInput;
static const QString kVerticalAlignmentInput;
static const QString kUseArgsInput;
static const QString kArgsInput;
static QString FormatString(const QString &input, const QStringList &args);
private:
TextGizmo *text_gizmo_;
private slots:
void GizmoActivated();
void GizmoDeactivated();
};
}
app/node/gizmo/gizmo.cpp
+5
View File
@@ -28,4 +28,9 @@ NodeGizmo::NodeGizmo(QObject *parent) :
setParent(parent);
}
NodeGizmo::~NodeGizmo()
{
setParent(nullptr);
}
}
app/node/gizmo/gizmo.h
+1
View File
@@ -33,6 +33,7 @@ class NodeGizmo : public QObject
Q_OBJECT
public:
explicit NodeGizmo(QObject *parent = nullptr);
virtual ~NodeGizmo() override;
virtual void Draw(QPainter *p) const {}
app/node/gizmo/text.h
+4
View File
@@ -42,6 +42,10 @@ public:
void UpdateInputHtml(const QString &s, const rational &time);
signals:
void Activated();
void Deactivated();
private:
QRectF rect_;
app/node/keying/chromakey/chromakey.cpp
-1
View File
@@ -132,7 +132,6 @@ void ChromaKeyNode::Value(const NodeValueRow &value, const NodeGlobals &globals,
ColorTransformJob job;
job.Insert(value);
job.SetAlphaChannelRequired(ColorTransformJob::kAlphaForceOn);
job.SetColorProcessor(processor());
job.SetInputTexture(value[kTextureInput].toTexture());
job.SetNeedsCustomShader(this);
app/node/keying/colordifferencekey/colordifferencekey.cpp
-1
View File
@@ -95,7 +95,6 @@ void ColorDifferenceKeyNode::Value(const NodeValueRow &value, const NodeGlobals
{
ShaderJob job;
job.Insert(value);
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
// If there's no texture, no need to run an operation
if (job.Get(kTextureInput).toTexture()) {
app/node/math/math/mathbase.cpp
-3
View File
@@ -372,9 +372,6 @@ void MathNodeBase::ValueInternal(Operation operation, Pairing pairing, const QSt
// Replace with adjusted matrix
job.Insert(val_a.type() == NodeValue::kTexture ? param_b_in : param_a_in,
NodeValue(NodeValue::kMatrix, adjusted_matrix, this));
// It's likely an alpha channel will result from this operation
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOn);
}
}
app/node/math/merge/merge.cpp
-6
View File
@@ -90,12 +90,6 @@ void MergeNode::Value(const NodeValueRow &value, const NodeGlobals &globals, Nod
// We only have a base texture, no need to alpha over
table->Push(job.Get(kBaseIn));
} else {
// We have both textures, push the job
if (base_tex->channel_count() < VideoParams::kRGBAChannelCount) {
// Base has no alpha, therefore this merge operation will not add an alpha channel
job.SetAlphaChannelRequired(GenerateJob::kAlphaForceOff);
}
table->Push(NodeValue::kTexture, QVariant::fromValue(job), this);
}
}
app/node/output/track/tracklist.cpp
+1 -1
View File
@@ -38,7 +38,7 @@ TrackList::TrackList(Sequence *parent, const Track::Type &type, const QString &t
Track *TrackList::GetTrackAt(int index) const
{
if (index < track_cache_.size()) {
if (index >= 0 && index < track_cache_.size()) {
return track_cache_.at(index);
} else {
return nullptr;
app/node/output/viewer/viewer.cpp
+14
View File
@@ -398,6 +398,20 @@ void ViewerOutput::ConnectedToPreviewEvent()
}
}
void ViewerOutput::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
if (HasInputWithID(kTextureInput)) {
NodeValue repush = value[kTextureInput];
repush.set_tag(Track::Reference(Track::kVideo, 0).ToString());
table->Push(repush);
}
if (HasInputWithID(kSamplesInput)) {
NodeValue repush = value[kSamplesInput];
repush.set_tag(Track::Reference(Track::kAudio, 0).ToString());
table->Push(value[kSamplesInput]);
}
}
void ViewerOutput::InputValueChangedEvent(const QString &input, int element)
{
if (element == 0) {
app/node/output/viewer/viewer.h
+9 -1
View File
@@ -21,6 +21,7 @@
#ifndef VIEWER_H
#define VIEWER_H
#include "codec/encoder.h"
#include "common/rational.h"
#include "node/node.h"
#include "node/output/track/track.h"
@@ -126,7 +127,7 @@ public:
return InputArraySize(kSubtitleParamsInput);
}
int GetTotalStreamCount() const
virtual int GetTotalStreamCount() const
{
return GetVideoStreamCount() + GetAudioStreamCount() + GetSubtitleStreamCount();
}
@@ -186,6 +187,11 @@ public:
bool IsVideoAutoCacheEnabled() const { qDebug() << "sequence ac is a stub"; return false; }
void SetVideoAutoCacheEnabled(bool e) { qDebug() << "sequence ac is a stub"; }
virtual void Value(const NodeValueRow& value, const NodeGlobals &globals, NodeValueTable *table) const override;
const EncodingParams &GetLastUsedEncodingParams() const { return last_used_encoding_params_; }
void SetLastUsedEncodingParams(const EncodingParams &p) { last_used_encoding_params_ = p; }
static const QString kVideoParamsInput;
static const QString kAudioParamsInput;
static const QString kSubtitleParamsInput;
@@ -243,6 +249,8 @@ private:
bool autocache_input_video_;
bool autocache_input_audio_;
EncodingParams last_used_encoding_params_;
};
}
app/node/param.h
+1
View File
@@ -37,6 +37,7 @@ enum InputFlag {
kInputFlagArray = 0x1,
kInputFlagNotKeyframable = 0x2,
kInputFlagNotConnectable = 0x4,
kInputFlagStatic = kInputFlagNotKeyframable | kInputFlagNotConnectable,
kInputFlagHidden = 0x8
};
app/node/project/folder/folder.cpp
+15
View File
@@ -73,6 +73,21 @@ bool Folder::ChildExistsWithName(const QString &s) const
return ChildExistsWithNameInternal(this, s);
}
bool Folder::HasChildRecursive(Node *child) const
{
for (Node *i : item_children_) {
if (i == child) {
return true;
} else if (Folder *f = dynamic_cast<Folder*>(i)) {
if (f->HasChildRecursive(child)) {
return true;
}
}
}
return false;
}
int Folder::index_of_child_in_array(Node *item) const
{
int index_of_item = item_children_.indexOf(item);
app/node/project/folder/folder.h
+2
View File
@@ -65,6 +65,8 @@ public:
bool ChildExistsWithName(const QString& s) const;
bool HasChildRecursive(Node *child) const;
int item_child_count() const
{
return item_children_.size();
app/node/project/footage/footage.cpp
+19 -22
View File
@@ -37,7 +37,6 @@
namespace olive {
const QString Footage::kFilenameInput = QStringLiteral("file_in");
const QString Footage::kLoopModeInput = QStringLiteral("loop_in");
#define super ViewerOutput
@@ -45,10 +44,9 @@ Footage::Footage(const QString &filename) :
ViewerOutput(false, false),
timestamp_(0),
valid_(false),
cancelled_(nullptr)
cancelled_(nullptr),
total_stream_count_(0)
{
PrependInput(kLoopModeInput, NodeValue::kCombo, 0, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
PrependInput(kFilenameInput, NodeValue::kFile, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
Clear();
@@ -70,8 +68,6 @@ void Footage::Retranslate()
super::Retranslate();
SetInputName(kFilenameInput, tr("Filename"));
SetInputName(kLoopModeInput, tr("Loop Mode"));
SetComboBoxStrings(kLoopModeInput, {tr("None"), tr("Loop"), tr("Clamp")});
}
void Footage::InputValueChangedEvent(const QString &input, int element)
@@ -130,6 +126,9 @@ void Footage::Clear()
// Clear decoder link
decoder_.clear();
// Clear total stream count
total_stream_count_ = 0;
// Reset ready state
valid_ = false;
}
@@ -139,11 +138,6 @@ void Footage::SetValid()
valid_ = true;
}
Footage::LoopMode Footage::loop_mode() const
{
return static_cast<LoopMode>(GetStandardValue(kLoopModeInput).toInt());
}
QString Footage::filename() const
{
return GetStandardValue(kFilenameInput).toString();
@@ -263,17 +257,15 @@ void Footage::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeV
// Pop filename from table
QString file = value[kFilenameInput].toString();
LoopMode loop_mode = static_cast<LoopMode>(value[kLoopModeInput].toInt());
// If the file exists and the reference is valid, push a footage job to the renderer
if (QFileInfo(file).exists()) {
if (QFileInfo::exists(file)) {
// Push length
table->Push(NodeValue::kRational, QVariant::fromValue(GetLength()), this, false, QStringLiteral("length"));
table->Push(NodeValue::kRational, QVariant::fromValue(GetLength()), this, QStringLiteral("length"));
// Push each stream as a footage job
for (int i=0; i<GetTotalStreamCount(); i++) {
Track::Reference ref = GetReferenceFromRealIndex(i);
FootageJob job(decoder_, filename(), ref.type(), GetLength(), loop_mode);
FootageJob job(decoder_, filename(), ref.type(), GetLength());
NodeValue::Type type;
@@ -294,7 +286,7 @@ void Footage::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeV
type = NodeValue::kSamples;
}
table->Push(type, QVariant::fromValue(job), this, false, ref.ToString());
table->Push(type, QVariant::fromValue(job), this, ref.ToString());
}
}
}
@@ -339,7 +331,7 @@ bool TimeIsOutOfBounds(const rational& time, const rational& length)
return time < 0 || time >= length;
}
rational Footage::AdjustTimeByLoopMode(rational time, Footage::LoopMode loop_mode, const rational &length, VideoParams::Type type, const rational& timebase)
rational Footage::AdjustTimeByLoopMode(rational time, Decoder::LoopMode loop_mode, const rational &length, VideoParams::Type type, const rational& timebase)
{
if (type == VideoParams::kVideoTypeStill) {
// No looping for still images
@@ -348,15 +340,15 @@ rational Footage::AdjustTimeByLoopMode(rational time, Footage::LoopMode loop_mod
if (TimeIsOutOfBounds(time, length)) {
switch (loop_mode) {
case kLoopModeOff:
case Decoder::kLoopModeOff:
// Return no time to indicate no frame should be shown here
time = rational::NaN;
break;
case kLoopModeClamp:
case Decoder::kLoopModeClamp:
// Clamp footage time to length
time = clamp(time, rational(0), length - timebase);
break;
case kLoopModeLoop:
case Decoder::kLoopModeLoop:
// Loop footage time around job length
do {
if (time >= length) {
@@ -509,6 +501,8 @@ void Footage::Reprobe()
SetStream(Track::kSubtitle, QVariant::fromValue(footage_info.GetSubtitleStreams().at(i)), i);
}
total_stream_count_ = footage_info.GetStreamCount();
SetValid();
}
@@ -524,10 +518,13 @@ VideoParams Footage::MergeVideoStream(const VideoParams &base, const VideoParams
merged.set_interlacing(over.interlacing());
merged.set_colorspace(over.colorspace());
merged.set_premultiplied_alpha(over.premultiplied_alpha());
if (merged.video_type() == VideoParams::kVideoTypeImageSequence && over.video_type() == VideoParams::kVideoTypeImageSequence) {
merged.set_video_type(over.video_type());
merged.set_color_range(over.color_range());
if (merged.video_type() == VideoParams::kVideoTypeImageSequence) {
merged.set_start_time(over.start_time());
merged.set_duration(over.duration());
merged.set_frame_rate(over.frame_rate());
merged.set_time_base(over.time_base());
}
return merged;
app/node/project/footage/footage.h
+9 -15
View File
@@ -24,10 +24,12 @@
#include <QList>
#include <QDateTime>
#include "codec/decoder.h"
#include "common/rational.h"
#include "footagedescription.h"
#include "node/output/viewer/viewer.h"
#include "render/audioparams.h"
#include "render/cancelatom.h"
#include "render/videoparams.h"
namespace olive {
@@ -43,12 +45,6 @@ class Footage : public ViewerOutput
{
Q_OBJECT
public:
enum LoopMode {
kLoopModeOff,
kLoopModeLoop,
kLoopModeClamp
};
/**
* @brief Footage Constructor
*/
@@ -100,11 +96,6 @@ public:
*/
void SetValid();
/**
* @brief Get currently set loop mode
*/
LoopMode loop_mode() const;
/**
* @brief Return the current filename of this Footage object
*/
@@ -141,7 +132,7 @@ public:
*/
void set_timestamp(const qint64 &t);
void SetCancelPointer(const QAtomicInt* c)
void SetCancelPointer(CancelAtom *c)
{
cancelled_ = c;
}
@@ -182,15 +173,16 @@ public:
virtual Node *GetConnectedSampleOutput() override;
static rational AdjustTimeByLoopMode(rational time, LoopMode loop_mode, const rational& length, VideoParams::Type type, const rational &timebase);
static rational AdjustTimeByLoopMode(rational time, Decoder::LoopMode loop_mode, const rational& length, VideoParams::Type type, const rational &timebase);
virtual void LoadFinishedEvent() override;
virtual qint64 creation_time() const override;
virtual qint64 mod_time() const override;
virtual int GetTotalStreamCount() const override { return total_stream_count_; }
static const QString kFilenameInput;
static const QString kLoopModeInput;
protected:
virtual void InputValueChangedEvent(const QString &input, int element) override;
@@ -232,7 +224,9 @@ private:
bool valid_;
const QAtomicInt* cancelled_;
CancelAtom *cancelled_;
int total_stream_count_;
private slots:
void CheckFootage();
app/node/project/footage/footagedescription.cpp
+12
View File
@@ -43,11 +43,13 @@ bool FootageDescription::Load(const QString &filename)
// Default to first version of metadata (which wasn't versioned at all)
unsigned version = 1;
{
XMLAttributeLoop((&reader), attr) {
if (attr.name() == QStringLiteral("version")) {
version = attr.value().toUInt();
}
}
}
if (version != kFootageMetaVersion) {
// If this is a different version, discard so we can probe new data
@@ -58,6 +60,14 @@ bool FootageDescription::Load(const QString &filename)
if (reader.name() == QStringLiteral("decoder")) {
decoder_ = reader.readElementText();
} else if (reader.name() == QStringLiteral("streams")) {
{
XMLAttributeLoop((&reader), attr) {
if (attr.name() == QStringLiteral("count")) {
total_stream_count_ = attr.value().toInt();
}
}
}
while (XMLReadNextStartElement(&reader)) {
if (reader.name() == QStringLiteral("video")) {
VideoParams vp;
@@ -116,6 +126,8 @@ bool FootageDescription::Save(const QString &filename) const
writer.writeStartElement(QStringLiteral("streams"));
writer.writeAttribute(QStringLiteral("count"), QString::number(total_stream_count_));
foreach (const VideoParams& vp, video_streams_) {
writer.writeStartElement(QStringLiteral("video"));
vp.Save(&writer);
app/node/project/footage/footagedescription.h
+8 -2
View File
@@ -32,7 +32,8 @@ class FootageDescription
{
public:
FootageDescription(const QString& decoder = QString()) :
decoder_(decoder)
decoder_(decoder),
total_stream_count_(0)
{
}
@@ -118,6 +119,9 @@ public:
return StreamIsVideo(index) || StreamIsAudio(index) || StreamIsSubtitle(index);
}
int GetStreamCount() const { return total_stream_count_; }
void SetStreamCount(int s) { total_stream_count_ = s; }
bool Load(const QString& filename);
bool Save(const QString& filename) const;
@@ -138,7 +142,7 @@ public:
}
private:
static constexpr unsigned kFootageMetaVersion = 2;
static constexpr unsigned kFootageMetaVersion = 5;
QString decoder_;
@@ -148,6 +152,8 @@ private:
QVector<SubtitleParams> subtitle_streams_;
int total_stream_count_;
};
}
app/node/project/project.cpp
+2 -10
View File
@@ -23,6 +23,7 @@
#include <QDir>
#include <QFileInfo>
#include "common/qtutils.h"
#include "common/xmlutils.h"
#include "core.h"
#include "dialog/progress/progress.h"
@@ -173,16 +174,7 @@ void Project::RegenerateUuid()
Project *Project::GetProjectFromObject(const QObject *o)
{
QObject *t = o->parent();
while (t) {
if (Project *p = dynamic_cast<Project*>(t)) {
return p;
}
t = t->parent();
}
return nullptr;
return QtUtils::GetParentOfType<Project>(o);
}
void Project::ColorManagerValueChanged(const NodeInput &input, const TimeRange &range)
app/node/project/projectviewmodel.cpp
+5
View File
@@ -170,6 +170,11 @@ QVariant ProjectViewModel::data(const QModelIndex &index, int role) const
}
}
break;
case Qt::EditRole:
if (column_type == kName) {
return internal_item->GetLabel();
}
break;
case Qt::DecorationRole:
// If this is the first column, return the Item's icon
if (column_type == kName) {
app/node/project/serializer/serializer.cpp
+6 -1
View File
@@ -159,6 +159,11 @@ ProjectSerializer::Result ProjectSerializer::Save(const SaveData &data, const QS
Result inner_result = Save(&writer, data, type);
if (writer.hasError()) {
Result r(kXmlError);
return r;
}
project_file.close();
if (inner_result != kSuccess) {
@@ -262,7 +267,7 @@ ProjectSerializer::Result ProjectSerializer::LoadWithSerializerVersion(uint vers
Result r(kSuccess);
if (reader->hasError()) {
r = Result(kXmlError);
r.SetDetails(reader->errorString());
r.SetDetails(QCoreApplication::translate("Serializer", "%1 on line %2").arg(reader->errorString(), QString::number(reader->lineNumber())));
}
r.SetLoadData(ld);
return r;
app/node/project/serializer/serializer220403.cpp
+94 -80
View File
@@ -25,6 +25,20 @@
namespace olive {
// These wrappers may appear to do nothing, but they seem to address a bug where sometimes
// QXmlStreamWriter would insert nonsense null characters into a project. This is probably some
// real edge case like compiler optimization or some bullshit like that. I don't even know if it
// affects all platforms, but it definitely affected me on Linux.
void WriteStartElement(QXmlStreamWriter *writer, const QString &s)
{
writer->writeStartElement(s);
}
void WriteEndElement(QXmlStreamWriter *writer)
{
writer->writeEndElement();
}
ProjectSerializer220403::LoadData ProjectSerializer220403::Load(Project *project, QXmlStreamReader *reader, void *reserved) const
{
QMap<quintptr, QMap<QString, QString> > properties;
@@ -328,23 +342,23 @@ void ProjectSerializer220403::Save(QXmlStreamWriter *writer, const SaveData &dat
{
if (!data.GetOnlySerializeMarkers().empty()) {
writer->writeStartElement(QStringLiteral("markers"));
WriteStartElement(writer, QStringLiteral("markers"));
for (auto it=data.GetOnlySerializeMarkers().cbegin(); it!=data.GetOnlySerializeMarkers().cend(); it++) {
TimelineMarker *marker = *it;
writer->writeStartElement(QStringLiteral("marker"));
WriteStartElement(writer, QStringLiteral("marker"));
SaveMarker(writer, marker);
writer->writeEndElement(); // marker
WriteEndElement(writer); // marker
}
writer->writeEndElement(); // markers
WriteEndElement(writer); // markers
} else if (!data.GetOnlySerializeKeyframes().empty()) {
writer->writeStartElement(QStringLiteral("keyframes"));
WriteStartElement(writer, QStringLiteral("keyframes"));
// Organize keyframes into node+input
QHash<QString, QHash<QString, QMap<int, QMap<int, QVector<NodeKeyframe*> > > > > organized;
@@ -355,57 +369,57 @@ void ProjectSerializer220403::Save(QXmlStreamWriter *writer, const SaveData &dat
}
for (auto it=organized.cbegin(); it!=organized.cend(); it++) {
writer->writeStartElement(QStringLiteral("node"));
WriteStartElement(writer, QStringLiteral("node"));
writer->writeAttribute(QStringLiteral("id"), it.key());
for (auto jt=it.value().cbegin(); jt!=it.value().cend(); jt++) {
writer->writeStartElement(QStringLiteral("input"));
WriteStartElement(writer, QStringLiteral("input"));
writer->writeAttribute(QStringLiteral("id"), jt.key());
for (auto kt=jt.value().cbegin(); kt!=jt.value().cend(); kt++) {
writer->writeStartElement(QStringLiteral("element"));
WriteStartElement(writer, QStringLiteral("element"));
writer->writeAttribute(QStringLiteral("id"), QString::number(kt.key()));
for (auto lt=kt.value().cbegin(); lt!=kt.value().cend(); lt++) {
const QVector<NodeKeyframe *> &keys = lt.value();
writer->writeStartElement(QStringLiteral("track"));
WriteStartElement(writer, QStringLiteral("track"));
writer->writeAttribute(QStringLiteral("id"), QString::number(lt.key()));
for (NodeKeyframe *key : keys) {
writer->writeStartElement(QStringLiteral("key"));
WriteStartElement(writer, QStringLiteral("key"));
SaveKeyframe(writer, key, key->parent()->GetInputDataType(key->input()));
writer->writeEndElement(); // key
WriteEndElement(writer); // key
}
writer->writeEndElement(); // track
WriteEndElement(writer); // track
}
writer->writeEndElement(); // element
WriteEndElement(writer); // element
}
writer->writeEndElement(); // input
WriteEndElement(writer); // input
}
writer->writeEndElement(); // node;
WriteEndElement(writer); // node;
}
writer->writeEndElement(); // keyframes
WriteEndElement(writer); // keyframes
} else if (Project *project = data.GetProject()) {
writer->writeTextElement(QStringLiteral("uuid"), project->GetUuid().toString());
writer->writeStartElement(QStringLiteral("nodes"));
WriteStartElement(writer, QStringLiteral("nodes"));
const QVector<Node*> &using_node_list = (data.GetOnlySerializeNodes().isEmpty()) ? project->nodes() : data.GetOnlySerializeNodes();
foreach (Node* node, using_node_list) {
writer->writeStartElement(QStringLiteral("node"));
WriteStartElement(writer, QStringLiteral("node"));
if (node == project->root()) {
writer->writeAttribute(QStringLiteral("root"), QStringLiteral("1"));
@@ -419,39 +433,39 @@ void ProjectSerializer220403::Save(QXmlStreamWriter *writer, const SaveData &dat
SaveNode(node, writer);
writer->writeEndElement(); // node
WriteEndElement(writer); // node
}
writer->writeEndElement(); // nodes
WriteEndElement(writer); // nodes
writer->writeStartElement(QStringLiteral("positions"));
WriteStartElement(writer, QStringLiteral("positions"));
foreach (Node* context, using_node_list) {
const Node::PositionMap &map = context->GetContextPositions();
if (!map.isEmpty()) {
writer->writeStartElement(QStringLiteral("context"));
WriteStartElement(writer, QStringLiteral("context"));
writer->writeAttribute(QStringLiteral("ptr"), QString::number(reinterpret_cast<quintptr>(context)));
for (auto jt=map.cbegin(); jt!=map.cend(); jt++) {
if (data.GetOnlySerializeNodes().isEmpty() || data.GetOnlySerializeNodes().contains(jt.key())) {
writer->writeStartElement(QStringLiteral("node"));
WriteStartElement(writer, QStringLiteral("node"));
SavePosition(writer, jt.key(), jt.value());
writer->writeEndElement(); // node
WriteEndElement(writer); // node
}
}
writer->writeEndElement(); // context
WriteEndElement(writer); // context
}
}
writer->writeEndElement(); // positions
WriteEndElement(writer); // positions
writer->writeStartElement(QStringLiteral("properties"));
WriteStartElement(writer, QStringLiteral("properties"));
for (auto it=data.GetProperties().cbegin(); it!=data.GetProperties().cend(); it++) {
writer->writeStartElement(QStringLiteral("node"));
WriteStartElement(writer, QStringLiteral("node"));
writer->writeAttribute(QStringLiteral("ptr"), QString::number(reinterpret_cast<quintptr>(it.key())));
@@ -459,10 +473,10 @@ void ProjectSerializer220403::Save(QXmlStreamWriter *writer, const SaveData &dat
writer->writeTextElement(jt.key(), jt.value());
}
writer->writeEndElement(); // node
WriteEndElement(writer); // node
}
writer->writeEndElement(); // properties
WriteEndElement(writer); // properties
// Save main window project layout
project->GetLayoutInfo().toXml(writer);
@@ -583,59 +597,59 @@ void ProjectSerializer220403::SaveNode(Node *node, QXmlStreamWriter *writer) con
writer->writeTextElement(QStringLiteral("color"), QString::number(node->GetOverrideColor()));
foreach (const QString& input, node->inputs()) {
writer->writeStartElement(QStringLiteral("input"));
WriteStartElement(writer, QStringLiteral("input"));
SaveInput(node, writer, input);
writer->writeEndElement(); // input
WriteEndElement(writer); // input
}
writer->writeStartElement(QStringLiteral("links"));
WriteStartElement(writer, QStringLiteral("links"));
foreach (Node* link, node->links()) {
writer->writeTextElement(QStringLiteral("link"), QString::number(reinterpret_cast<quintptr>(link)));
}
writer->writeEndElement(); // links
WriteEndElement(writer); // links
writer->writeStartElement(QStringLiteral("connections"));
WriteStartElement(writer, QStringLiteral("connections"));
for (auto it=node->input_connections().cbegin(); it!=node->input_connections().cend(); it++) {
writer->writeStartElement(QStringLiteral("connection"));
WriteStartElement(writer, QStringLiteral("connection"));
writer->writeAttribute(QStringLiteral("input"), it->first.input());
writer->writeAttribute(QStringLiteral("element"), QString::number(it->first.element()));
writer->writeTextElement(QStringLiteral("output"), QString::number(reinterpret_cast<quintptr>(it->second)));
writer->writeEndElement(); // connection
WriteEndElement(writer); // connection
}
writer->writeEndElement(); // connections
WriteEndElement(writer); // connections
writer->writeStartElement(QStringLiteral("hints"));
WriteStartElement(writer, QStringLiteral("hints"));
for (auto it=node->GetValueHints().cbegin(); it!=node->GetValueHints().cend(); it++) {
writer->writeStartElement(QStringLiteral("hint"));
WriteStartElement(writer, QStringLiteral("hint"));
writer->writeAttribute(QStringLiteral("input"), it.key().input);
writer->writeAttribute(QStringLiteral("element"), QString::number(it.key().element));
SaveValueHint(&it.value(), writer);
writer->writeEndElement(); // hint
WriteEndElement(writer); // hint
}
writer->writeEndElement();
WriteEndElement(writer); // hints
writer->writeStartElement(QStringLiteral("caches"));
WriteStartElement(writer, QStringLiteral("caches"));
writer->writeTextElement(QStringLiteral("audio"), node->audio_playback_cache()->GetUuid().toString());
writer->writeTextElement(QStringLiteral("video"), node->video_frame_cache()->GetUuid().toString());
writer->writeTextElement(QStringLiteral("thumb"), node->thumbnail_cache()->GetUuid().toString());
writer->writeTextElement(QStringLiteral("waveform"), node->waveform_cache()->GetUuid().toString());
writer->writeEndElement(); // caches
WriteEndElement(writer); // caches
writer->writeStartElement(QStringLiteral("custom"));
WriteStartElement(writer, QStringLiteral("custom"));
SaveNodeCustom(writer, node);
writer->writeEndElement(); // custom
WriteEndElement(writer); // custom
}
void ProjectSerializer220403::LoadInput(Node *node, QXmlStreamReader *reader, XMLNodeData &xml_node_data) const
@@ -705,27 +719,27 @@ void ProjectSerializer220403::SaveInput(Node *node, QXmlStreamWriter *writer, co
{
writer->writeAttribute(QStringLiteral("id"), id);
writer->writeStartElement(QStringLiteral("primary"));
WriteStartElement(writer, QStringLiteral("primary"));
SaveImmediate(writer, node, id, -1);
writer->writeEndElement(); // primary
WriteEndElement(writer); // primary
writer->writeStartElement(QStringLiteral("subelements"));
WriteStartElement(writer, QStringLiteral("subelements"));
int arr_sz = node->InputArraySize(id);
writer->writeAttribute(QStringLiteral("count"), QString::number(arr_sz));
for (int i=0; i<arr_sz; i++) {
writer->writeStartElement(QStringLiteral("element"));
WriteStartElement(writer, QStringLiteral("element"));
SaveImmediate(writer, node, id, i);
writer->writeEndElement(); // element
WriteEndElement(writer); // element
}
writer->writeEndElement(); // subelements
WriteEndElement(writer); // subelements
}
void ProjectSerializer220403::LoadImmediate(QXmlStreamReader *reader, Node *node, const QString& input, int element, XMLNodeData &xml_node_data) const
@@ -835,10 +849,10 @@ void ProjectSerializer220403::SaveImmediate(QXmlStreamWriter *writer, Node *node
NodeValue::Type data_type = node->GetInputDataType(input);
// Write standard value
writer->writeStartElement(QStringLiteral("standard"));
WriteStartElement(writer, QStringLiteral("standard"));
foreach (const QVariant& v, node->GetSplitStandardValue(input, element)) {
writer->writeStartElement(QStringLiteral("track"));
WriteStartElement(writer, QStringLiteral("track"));
if (data_type == NodeValue::kVideoParams) {
v.value<VideoParams>().Save(writer);
@@ -848,29 +862,29 @@ void ProjectSerializer220403::SaveImmediate(QXmlStreamWriter *writer, Node *node
writer->writeCharacters(NodeValue::ValueToString(data_type, v, true));
}
writer->writeEndElement(); // track
WriteEndElement(writer); // track
}
writer->writeEndElement(); // standard
WriteEndElement(writer); // standard
// Write keyframes
writer->writeStartElement(QStringLiteral("keyframes"));
WriteStartElement(writer, QStringLiteral("keyframes"));
for (const NodeKeyframeTrack& track : node->GetKeyframeTracks(input, element)) {
writer->writeStartElement(QStringLiteral("track"));
WriteStartElement(writer, QStringLiteral("track"));
for (NodeKeyframe* key : track) {
writer->writeStartElement(QStringLiteral("key"));
WriteStartElement(writer, QStringLiteral("key"));
SaveKeyframe(writer, key, data_type);
writer->writeEndElement(); // key
WriteEndElement(writer); // key
}
writer->writeEndElement(); // track
WriteEndElement(writer); // track
}
writer->writeEndElement(); // keyframes
WriteEndElement(writer); // keyframes
if (data_type == NodeValue::kColor) {
// Save color management information
@@ -1115,9 +1129,9 @@ void ProjectSerializer220403::SaveNodeCustom(QXmlStreamWriter *writer, Node *nod
{
if (ViewerOutput *viewer = dynamic_cast<ViewerOutput*>(node)) {
// Write TimelinePoints
writer->writeStartElement(QStringLiteral("points"));
WriteStartElement(writer, QStringLiteral("points"));
SaveTimelinePoints(writer, viewer);
writer->writeEndElement(); // points
WriteEndElement(writer); // points
if (Footage *footage = dynamic_cast<Footage*>(node)) {
writer->writeTextElement(QStringLiteral("timestamp"), QString::number(footage->timestamp()));
@@ -1125,10 +1139,10 @@ void ProjectSerializer220403::SaveNodeCustom(QXmlStreamWriter *writer, Node *nod
} else if (Track *track = dynamic_cast<Track*>(node)) {
writer->writeTextElement(QStringLiteral("height"), QString::number(track->GetTrackHeight()));
} else if (NodeGroup *group = dynamic_cast<NodeGroup*>(node)) {
writer->writeStartElement(QStringLiteral("inputpassthroughs"));
WriteStartElement(writer, QStringLiteral("inputpassthroughs"));
foreach (const NodeGroup::InputPassthrough &ip, group->GetInputPassthroughs()) {
writer->writeStartElement(QStringLiteral("inputpassthrough"));
WriteStartElement(writer, QStringLiteral("inputpassthrough"));
// Reference to inner input
writer->writeTextElement(QStringLiteral("node"), QString::number(reinterpret_cast<quintptr>(ip.second.node())));
@@ -1149,20 +1163,20 @@ void ProjectSerializer220403::SaveNodeCustom(QXmlStreamWriter *writer, Node *nod
writer->writeTextElement(QStringLiteral("default"), NodeValue::ValueToString(data_type, group_input.GetDefaultValue(), false));
writer->writeStartElement(QStringLiteral("properties"));
WriteStartElement(writer, QStringLiteral("properties"));
auto p = group_input.GetProperties();
for (auto it=p.cbegin(); it!=p.cend(); it++) {
writer->writeStartElement(QStringLiteral("property"));
WriteStartElement(writer, QStringLiteral("property"));
writer->writeTextElement(QStringLiteral("key"), it.key());
writer->writeTextElement(QStringLiteral("value"), it.value().toString());
writer->writeEndElement(); // property
WriteEndElement(writer); // property
}
writer->writeEndElement(); // properties
WriteEndElement(writer); // properties
writer->writeEndElement(); // input
WriteEndElement(writer); // input
}
writer->writeEndElement(); // inputpassthroughs
WriteEndElement(writer); // inputpassthroughs
writer->writeTextElement(QStringLiteral("outputpassthrough"), QString::number(reinterpret_cast<quintptr>(group->GetOutputPassthrough())));
}
@@ -1183,13 +1197,13 @@ void ProjectSerializer220403::LoadTimelinePoints(QXmlStreamReader *reader, Viewe
void ProjectSerializer220403::SaveTimelinePoints(QXmlStreamWriter *writer, ViewerOutput *viewer) const
{
writer->writeStartElement(QStringLiteral("workarea"));
WriteStartElement(writer, QStringLiteral("workarea"));
SaveWorkArea(writer, viewer->GetWorkArea());
writer->writeEndElement(); // workarea
WriteEndElement(writer); // workarea
writer->writeStartElement(QStringLiteral("markers"));
WriteStartElement(writer, QStringLiteral("markers"));
SaveMarkerList(writer, viewer->GetMarkers());
writer->writeEndElement(); // markers
WriteEndElement(writer); // markers
}
void ProjectSerializer220403::LoadMarker(QXmlStreamReader *reader, TimelineMarker *marker) const
@@ -1270,11 +1284,11 @@ void ProjectSerializer220403::SaveMarkerList(QXmlStreamWriter *writer, TimelineM
for (auto it=markers->cbegin(); it!=markers->cend(); it++) {
TimelineMarker* marker = *it;
writer->writeStartElement(QStringLiteral("marker"));
WriteStartElement(writer, QStringLiteral("marker"));
SaveMarker(writer, marker);
writer->writeEndElement(); // marker
WriteEndElement(writer); // marker
}
}
@@ -1305,13 +1319,13 @@ void ProjectSerializer220403::LoadValueHint(Node::ValueHint *hint, QXmlStreamRea
void ProjectSerializer220403::SaveValueHint(const Node::ValueHint *hint, QXmlStreamWriter *writer) const
{
writer->writeStartElement(QStringLiteral("types"));
WriteStartElement(writer, QStringLiteral("types"));
for (auto it=hint->types().cbegin(); it!=hint->types().cend(); it++) {
writer->writeTextElement(QStringLiteral("type"), QString::number(*it));
}
writer->writeEndElement(); // types
WriteEndElement(writer); // types
writer->writeTextElement(QStringLiteral("index"), QString::number(hint->index()));
app/node/time/CMakeLists.txt
+1
View File
@@ -14,6 +14,7 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
add_subdirectory(timeformat)
add_subdirectory(timeoffset)
add_subdirectory(timeremap)
app/node/time/timeformat/CMakeLists.txt
+22
View File
@@ -0,0 +1,22 @@
# Olive - Non-Linear Video Editor
# Copyright (C) 2022 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/>.
set(OLIVE_SOURCES
${OLIVE_SOURCES}
node/time/timeformat/timeformat.cpp
node/time/timeformat/timeformat.h
PARENT_SCOPE
)
app/node/time/timeformat/timeformat.cpp
+79
View File
@@ -0,0 +1,79 @@
/***
Olive - Non-Linear Video Editor
Copyright (C) 2022 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 "timeformat.h"
#include <QDateTime>
namespace olive {
#define super Node
const QString TimeFormatNode::kTimeInput = QStringLiteral("time_in");
const QString TimeFormatNode::kFormatInput = QStringLiteral("format_in");
const QString TimeFormatNode::kLocalTimeInput = QStringLiteral("localtime_in");
TimeFormatNode::TimeFormatNode()
{
AddInput(kTimeInput, NodeValue::kFloat);
AddInput(kFormatInput, NodeValue::kText, QStringLiteral("hh:mm:ss"));
AddInput(kLocalTimeInput, NodeValue::kBoolean);
}
QString TimeFormatNode::Name() const
{
return tr("Time Format");
}
QString TimeFormatNode::id() const
{
return QStringLiteral("org.olivevideoeditor.Olive.timeformat");
}
QVector<Node::CategoryID> TimeFormatNode::Category() const
{
return {kCategoryGenerator};
}
QString TimeFormatNode::Description() const
{
return tr("Format time (in Unix epoch seconds) into a string.");
}
void TimeFormatNode::Retranslate()
{
super::Retranslate();
SetInputName(kTimeInput, tr("Time"));
SetInputName(kFormatInput, tr("Format"));
SetInputName(kLocalTimeInput, tr("Interpret time as local time"));
}
void TimeFormatNode::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
{
qint64 ms_since_epoch = value[kTimeInput].toDouble()*1000;
bool time_is_local = value[kLocalTimeInput].toBool();
QDateTime dt = QDateTime::fromMSecsSinceEpoch(ms_since_epoch, time_is_local ? Qt::LocalTime : Qt::UTC);
QString format = value[kFormatInput].toString();
QString output = dt.toString(format);
table->Push(NodeValue(NodeValue::kText, output, this));
}
}
app/common/threadedobject.cpp → app/node/time/timeformat/timeformat.h
+21 -25
View File
@@ -18,40 +18,36 @@
***/
#include "threadedobject.h"
#ifndef TIMEFORMAT_H
#define TIMEFORMAT_H
#include "node/node.h"
namespace olive {
void ThreadedObject::LockDeletes()
class TimeFormatNode : public Node
{
threadobj_delete_lock_++;
}
Q_OBJECT
public:
TimeFormatNode();
void ThreadedObject::UnlockDeletes()
{
Q_ASSERT(AreDeletesLocked());
NODE_DEFAULT_FUNCTIONS(TimeFormatNode)
threadobj_delete_lock_--;
}
virtual QString Name() const override;
virtual QString id() const override;
virtual QVector<CategoryID> Category() const override;
virtual QString Description() const override;
bool ThreadedObject::AreDeletesLocked()
{
return (threadobj_delete_lock_ > 0);
}
virtual void Retranslate() override;
void ThreadedObject::LockMutex()
{
threadobj_main_lock_.lock();
}
virtual void Value(const NodeValueRow& value, const NodeGlobals &globals, NodeValueTable *table) const override;
void ThreadedObject::UnlockMutex()
{
threadobj_main_lock_.unlock();
}
static const QString kTimeInput;
static const QString kFormatInput;
static const QString kLocalTimeInput;
bool ThreadedObject::TryLockMutex(int timeout)
{
return threadobj_main_lock_.tryLock(timeout);
}
};
}
#endif // TIMEFORMAT_H
app/node/traverser.cpp
+12 -31
View File
@@ -21,6 +21,7 @@
#include "traverser.h"
#include "node.h"
#include "node/block/clip/clip.h"
#include "render/job/footagejob.h"
#include "render/rendermanager.h"
@@ -30,6 +31,12 @@ NodeValueDatabase NodeTraverser::GenerateDatabase(const Node* node, const TimeRa
{
NodeValueDatabase database;
// HACK: Pick up loop mode from clips
Decoder::LoopMode old_loop_mode = loop_mode_;
if (const ClipBlock *clip = dynamic_cast<const ClipBlock*>(node)) {
loop_mode_ = clip->loop_mode();
}
// We need to insert tables into the database for each input
foreach (const QString& input, node->inputs()) {
if (IsCancelled()) {
@@ -39,6 +46,8 @@ NodeValueDatabase NodeTraverser::GenerateDatabase(const Node* node, const TimeRa
database.Insert(input, ProcessInput(node, input, range));
}
loop_mode_ = old_loop_mode;
return database;
}
@@ -167,34 +176,6 @@ NodeGlobals NodeTraverser::GenerateGlobals(const VideoParams &params, const Time
int NodeTraverser::GetChannelCountFromJob(const GenerateJob &job)
{
int max_channel_count = 0;
// Find maximum channel count
for (auto it=job.GetValues().cbegin(); it!=job.GetValues().cend(); it++) {
if (it.value().type() == NodeValue::kTexture) {
if (TexturePtr tex = it.value().toTexture()) {
max_channel_count = qMax(max_channel_count, tex->channel_count());
}
}
}
if (max_channel_count == 0) {
max_channel_count = VideoParams::kRGBChannelCount;
}
switch (job.GetAlphaChannelRequired()) {
case GenerateJob::kAlphaForceOn:
return VideoParams::kRGBAChannelCount;
case GenerateJob::kAlphaForceOff:
if (max_channel_count >= 1 && max_channel_count < VideoParams::kRGBChannelCount) {
return max_channel_count;
} else {
return VideoParams::kRGBChannelCount;
}
case GenerateJob::kAlphaAuto:
return max_channel_count;
}
// Default fallback, should never get here
return VideoParams::kRGBAChannelCount;
}
@@ -268,8 +249,8 @@ NodeValueTable NodeTraverser::ProcessInput(const Node* node, const QString& inpu
NodeTraverser::NodeTraverser() :
cancel_(nullptr),
heard_cancel_(false),
transform_(nullptr)
transform_(nullptr),
loop_mode_(Decoder::kLoopModeOff)
{
}
@@ -459,7 +440,7 @@ void NodeTraverser::ResolveJobs(NodeValue &val, const TimeRange &range)
if (job.type() == Track::kVideo) {
rational footage_time = Footage::AdjustTimeByLoopMode(range.in(), job.loop_mode(), job.length(), job.video_params().video_type(), job.video_params().frame_rate_as_time_base());
rational footage_time = Footage::AdjustTimeByLoopMode(range.in(), loop_mode_, job.length(), job.video_params().video_type(), job.video_params().frame_rate_as_time_base());
TexturePtr tex;
app/node/traverser.h
+12 -15
View File
@@ -27,6 +27,8 @@
#include "common/cancelableobject.h"
#include "node/output/track/track.h"
#include "render/job/cachejob.h"
#include "render/cancelatom.h"
#include "render/job/footagejob.h"
#include "render/job/colortransformjob.h"
#include "render/job/footagejob.h"
#include "value.h"
@@ -127,24 +129,16 @@ protected:
bool IsCancelled()
{
bool c = cancel_ && *cancel_;
if (c) {
heard_cancel_ = true;
}
return c;
return cancel_ && cancel_->IsCancelled();
}
bool HeardCancel() const { return heard_cancel_; }
const QAtomicInt *GetCancelPointer() const
bool HeardCancel() const
{
return cancel_;
return cancel_ && cancel_->HeardCancel();
}
void SetCancelPointer(const QAtomicInt *cancel)
{
cancel_ = cancel;
}
CancelAtom *GetCancelPointer() const { return cancel_; }
void SetCancelPointer(CancelAtom *cancel) { cancel_ = cancel; }
void ResolveJobs(NodeValue &value, const TimeRange &range);
@@ -153,6 +147,8 @@ protected:
return block_stack_.empty() ? nullptr : block_stack_.back();
}
Decoder::LoopMode loop_mode() const { return loop_mode_; }
private:
void PreProcessRow(const TimeRange &range, NodeValueRow &row);
@@ -162,8 +158,7 @@ private:
AudioParams audio_params_;
const QAtomicInt *cancel_;
bool heard_cancel_;
CancelAtom *cancel_;
const Node *transform_start_;
const Node *transform_now_;
@@ -171,6 +166,8 @@ private:
std::list<Block*> block_stack_;
Decoder::LoopMode loop_mode_;
};
}
app/node/value.h
+24
View File
@@ -208,6 +208,12 @@ public:
set_value(data);
}
template <typename T>
NodeValue(Type type, const T& data, const Node* from, const QString& tag) :
NodeValue(type, data, from, false, tag)
{
}
Type type() const
{
return type_;
@@ -238,6 +244,11 @@ public:
return tag_;
}
void set_tag(const QString& tag)
{
tag_ = tag;
}
const Node* source() const
{
return from_;
@@ -328,6 +339,7 @@ public:
QVector3D toVec3() const { return value<QVector3D>(); }
QVector4D toVec4() const { return value<QVector4D>(); }
Bezier toBezier() const { return value<Bezier>(); }
QVector<NodeValue> toArray() const { return value<QVector<NodeValue> >(); }
private:
Type type_;
@@ -375,6 +387,12 @@ public:
Push(NodeValue(type, data, from, array, tag));
}
template <typename T>
void Push(NodeValue::Type type, const T& data, const Node *from, const QString& tag)
{
Push(NodeValue(type, data, from, false, tag));
}
void Prepend(const NodeValue& value)
{
values_.prepend(value);
@@ -386,6 +404,12 @@ public:
Prepend(NodeValue(type, data, from, array, tag));
}
template <typename T>
void Prepend(NodeValue::Type type, const T& data, const Node *from, const QString& tag)
{
Prepend(NodeValue(type, data, from, false, tag));
}
const NodeValue& at(int index) const
{
return values_.at(index);
app/panel/node/node.h
+5
View File
@@ -104,6 +104,11 @@ public:
node_widget_->view()->ZoomOut();
}
virtual void RenameSelected() override
{
node_widget_->view()->LabelSelectedNodes();
}
public slots:
void Select(const QVector<Node::ContextPair> &p)
{
app/panel/panelmanager.cpp
+3 -1
View File
@@ -66,8 +66,10 @@ PanelWidget *PanelManager::CurrentlyFocused(bool enable_hover) const
PanelWidget *PanelManager::CurrentlyHovered() const
{
QPoint global_mouse = QCursor::pos();
foreach (PanelWidget* panel, focus_history_) {
if (panel->underMouse()) {
if (panel->rect().contains(panel->mapFromGlobal(global_mouse))) {
return panel;
}
}

Some files were not shown because too many files have changed in this diff Show More