Node system overhaul for better flexibility and usability

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "ext/core"]
-	path = ext/core
-	url = https://github.com/olive-editor/core
 [submodule "ext/KDDockWidgets"]
 	path = ext/KDDockWidgets
 	url = https://github.com/olive-editor/KDDockWidgets.git

CMakeLists.txt

@@ -101,7 +101,7 @@ list(APPEND OLIVE_INCLUDE_DIRS ${OPENEXR_INCLUDES})
 
 # Link Olive
 list(APPEND OLIVE_LIBRARIES olivecore)
-list(APPEND OLIVE_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ext/core/include)
+list(APPEND OLIVE_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/lib/olive/include)
 
 # Link Qt
 set(QT_LIBRARIES
@@ -168,7 +168,7 @@ list(APPEND OLIVE_LIBRARIES
 )
 
 # Link FFmpeg
-find_package(FFMPEG 3.0 REQUIRED
+find_package(FFMPEG 5.0 REQUIRED
   COMPONENTS
   avutil
   avcodec
@@ -257,6 +257,7 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)
 list(APPEND OLIVE_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/ext)
 
 add_subdirectory(ext)
+add_subdirectory(lib)
 add_subdirectory(app)
 
 if (BUILD_TESTS)

app/audio/audioprocessor.cpp

@@ -34,7 +34,6 @@ namespace olive {
 AudioProcessor::AudioProcessor()
 {
   filter_graph_ = nullptr;
-  in_frame_ = nullptr;
   out_frame_ = nullptr;
 }
 
@@ -61,12 +60,12 @@ bool AudioProcessor::Open(const AudioParams &from, const AudioParams &to, double
 
   // Set up audio buffer args
   char filter_args[200];
-  snprintf(filter_args, 200, "time_base=%d/%d:sample_rate=%d:sample_fmt=%d:channel_layout=0x%" PRIx64,
+  snprintf(filter_args, 200, "time_base=%d/%d:sample_rate=%d:sample_fmt=%d:channel_layout=%s",
            1,
            from.sample_rate(),
            from.sample_rate(),
            from_fmt_,
-           from.channel_layout());
+           from.channel_layout().toString().toUtf8().constData());
 
   int r;
 
@@ -120,10 +119,10 @@ bool AudioProcessor::Open(const AudioParams &from, const AudioParams &to, double
       || (to.format().is_planar() && create_tempo)) { // Tempo processor automatically converts to packed,
                                                   // so if the desired output is planar, it'll need
                                                   // to be converted
-    snprintf(filter_args, 200, "sample_fmts=%s:sample_rates=%d:channel_layouts=0x%" PRIx64,
+    snprintf(filter_args, 200, "sample_fmts=%s:sample_rates=%d:channel_layouts=%s",
              av_get_sample_fmt_name(to_fmt_),
              to.sample_rate(),
-             to.channel_layout());
+             to.channel_layout().toString().toUtf8().constData());
 
     AVFilterContext *c;
     r = avfilter_graph_create_filter(&c, avfilter_get_by_name("aformat"), "fmt", filter_args, nullptr, filter_graph_);
@@ -165,19 +164,6 @@ bool AudioProcessor::Open(const AudioParams &from, const AudioParams &to, double
     return false;
   }
 
-  in_frame_ = av_frame_alloc();
-  if (in_frame_) {
-    in_frame_->sample_rate = from.sample_rate();
-    in_frame_->format = from_fmt_;
-    in_frame_->channel_layout = from.channel_layout();
-    in_frame_->channels = from.channel_count();
-    in_frame_->pts = 0;
-  } else {
-    qCritical() << "Failed to allocate input frame";
-    Close();
-    return false;
-  }
-
   out_frame_ = av_frame_alloc();
   if (!out_frame_) {
     qCritical() << "Failed to allocate output frame";
@@ -200,11 +186,6 @@ void AudioProcessor::Close()
     buffersink_ctx_ = nullptr;
   }
 
-  if (in_frame_) {
-    av_frame_free(&in_frame_);
-    in_frame_ = nullptr;
-  }
-
   if (out_frame_) {
     av_frame_free(&out_frame_);
     out_frame_ = nullptr;
@@ -221,14 +202,32 @@ int AudioProcessor::Convert(float **in, int nb_in_samples, AudioProcessor::Buffe
   int r = 0;
 
   if (in && nb_in_samples) {
-    // Set frame parameters
-    in_frame_->nb_samples = nb_in_samples;
+    // Pass pointers to AVFilter through an AVFrame
+    AVFrame *in_frame = av_frame_alloc();
+    if (!in_frame) {
+      qCritical() << "Failed to allocate input frame";
+      return -1;
+    }
+
+    in_frame->sample_rate = from_.sample_rate();
+    in_frame->format = from_fmt_;
+    from_.channel_layout().exportTo(&in_frame->ch_layout);
+    in_frame->pts = 0;
+
+    in_frame->nb_samples = nb_in_samples;
+    for (int i=0; i<from_.channel_count(); i++) {
+      in_frame->data[i] = reinterpret_cast<uint8_t*>(in[i]);
+      in_frame->linesize[i] = from_.samples_to_bytes(nb_in_samples);
+    }
+
+    r = av_buffersrc_add_frame_flags(buffersrc_ctx_, in_frame, AV_BUFFERSRC_FLAG_KEEP_REF);
+
     for (int i=0; i<from_.channel_count(); i++) {
-      in_frame_->data[i] = reinterpret_cast<uint8_t*>(in[i]);
-      in_frame_->linesize[i] = from_.samples_to_bytes(nb_in_samples);
+      in_frame->data[i] = nullptr;
+      in_frame->linesize[i] = 0;
     }
 
-    r = av_buffersrc_add_frame_flags(buffersrc_ctx_, in_frame_, AV_BUFFERSRC_FLAG_KEEP_REF);
+    av_frame_free(&in_frame);
     if (r < 0) {
       qCritical() << "Failed to add frame to buffersrc:" << r;
       return r;

app/audio/audioprocessor.h

@@ -22,19 +22,17 @@
 #define AUDIOPROCESSOR_H
 
 #include <inttypes.h>
-#include <olive/core/core.h>
 #include <QByteArray>
 
 extern "C" {
 #include <libavfilter/avfilter.h>
 }
 
 #include "common/define.h"
+#include "core.h"
 
 namespace olive {
 
-using namespace core;
-
 class AudioProcessor
 {
 public:
@@ -73,8 +71,6 @@ class AudioProcessor
   AudioParams to_;
   AVSampleFormat to_fmt_;
 
-  AVFrame *in_frame_;
-
   AVFrame *out_frame_;
 
 };

app/audio/audiovisualwaveform.cpp

@@ -24,6 +24,7 @@
 #include <QtGlobal>
 
 #include "config/config.h"
+#include "util/cpuoptimize.h"
 
 namespace olive {
 

app/audio/audiovisualwaveform.h

@@ -21,13 +21,12 @@
 #ifndef SUMSAMPLES_H
 #define SUMSAMPLES_H
 
-#include <olive/core/core.h>
 #include <QPainter>
 #include <QVector>
 
-namespace olive {
+#include "render/samplebuffer.h"
 
-using namespace core;
+namespace olive {
 
 /**
  * @brief A buffer of data used to store a visual representation of audio

app/codec/conformmanager.cpp

@@ -2,6 +2,7 @@
 
 #include <QDir>
 
+#include "common/filefunctions.h"
 #include "task/taskmanager.h"
 
 namespace olive {
@@ -66,7 +67,7 @@ QVector<QString> ConformManager::GetConformedFilename(const QString &cache_path,
                                                                    QString::number(stream.stream()),
                                                                    QString::number(params.sample_rate()),
                                                                    QString::number(params.format()),
-                                                                   QString::number(params.channel_layout()),
+                                                                   params.channel_layout().toString(),
                                                                    QString::number(i));
 
     filenames[i] = QDir(cache_path).filePath(index_fn);

app/codec/decoder.cpp

@@ -123,7 +123,7 @@ TexturePtr Decoder::RetrieveVideo(const RetrieveVideoParams &p)
   return cached_texture_;
 }
 
-Decoder::RetrieveAudioStatus Decoder::RetrieveAudio(SampleBuffer &dest, const TimeRange &range, const AudioParams &params, const QString& cache_path, LoopMode loop_mode, RenderMode::Mode mode)
+Decoder::RetrieveAudioStatus Decoder::RetrieveAudio(SampleBuffer &dest, const rational &time, const QString& cache_path, LoopMode loop_mode, RenderMode::Mode mode)
 {
   QMutexLocker locker(&mutex_);
 
@@ -139,18 +139,24 @@ Decoder::RetrieveAudioStatus Decoder::RetrieveAudio(SampleBuffer &dest, const Ti
     return kInvalid;
   }
 
-  // Get conform state from ConformManager
-  ConformManager::Conform conform = ConformManager::instance()->GetConformState(id(), cache_path, stream_, params, (mode == RenderMode::kOnline));
-  if (conform.state == ConformManager::kConformGenerating) {
-    // If we need the task, it's available in `conform.task`
-    return kWaitingForConform;
-  }
+  const bool use_conforms = false;
+
+  if (use_conforms) {
+    // Get conform state from ConformManager
+    ConformManager::Conform conform = ConformManager::instance()->GetConformState(id(), cache_path, stream_, dest.audio_params(), (mode == RenderMode::kOnline));
+    if (conform.state == ConformManager::kConformGenerating) {
+      // If we need the task, it's available in `conform.task`
+      return kWaitingForConform;
+    }
 
-  // See if we got the conform
-  if (RetrieveAudioFromConform(dest, conform.filenames, range, loop_mode, params)) {
-    return kOK;
+    // See if we got the conform
+    if (RetrieveAudioFromConform(dest, conform.filenames, time, loop_mode)) {
+      return kOK;
+    } else {
+      return kUnknownError;
+    }
   } else {
-    return kUnknownError;
+    return RetrieveAudioInternal(dest, time);
   }
 }
 
@@ -280,14 +286,16 @@ bool Decoder::ConformAudioInternal(const QVector<QString> &filenames, const Audi
   return false;
 }
 
-bool Decoder::RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, TimeRange range, LoopMode loop_mode, const AudioParams &input_params)
+bool Decoder::RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, rational time, LoopMode loop_mode)
 {
+  const AudioParams &input_params = sample_buffer.audio_params();
+
   PlanarFileDevice input;
   if (input.open(conform_filenames, QFile::ReadOnly)) {
     // Offset range by audio start offset
-    range -= GetAudioStartOffset();
+    time -= GetAudioStartOffset();
 
-    qint64 read_index = input_params.time_to_bytes(range.in()) / input_params.channel_count();
+    qint64 read_index = input_params.time_to_bytes(time) / input_params.channel_count();
     qint64 write_index = 0;
 
     const qint64 buffer_length_in_bytes = sample_buffer.sample_count() * input_params.bytes_per_sample_per_channel();

app/codec/decoder.h

@@ -192,7 +192,7 @@ class Decoder : public QObject
    *
    * 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, LoopMode loop_mode, RenderMode::Mode mode);
+  RetrieveAudioStatus RetrieveAudio(SampleBuffer &dest, const rational& time, const QString &cache_path, LoopMode loop_mode, RenderMode::Mode mode);
 
   /**
    * @brief Determine the last time this decoder instance was used in any way
@@ -272,6 +272,11 @@ class Decoder : public QObject
    */
   virtual TexturePtr RetrieveVideoInternal(const RetrieveVideoParams& p);
 
+  virtual RetrieveAudioStatus RetrieveAudioInternal(SampleBuffer &dest, const rational &time)
+  {
+    return kOK;
+  }
+
   virtual bool ConformAudioInternal(const QVector<QString>& filenames, const AudioParams &params, CancelAtom *cancelled);
 
   void SignalProcessingProgress(int64_t ts, int64_t duration);
@@ -288,6 +293,8 @@ class Decoder : public QObject
 
   virtual rational GetAudioStartOffset() const { return 0; }
 
+  virtual int GetAudioSampleRate() const { return 0; }
+
 signals:
   /**
    * @brief While indexing, this signal will provide progress as a percentage (0-100 inclusive) if
@@ -298,7 +305,7 @@ class Decoder : public QObject
 private:
   void UpdateLastAccessed();
 
-  bool RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, TimeRange range, LoopMode loop_mode, const AudioParams &params);
+  bool RetrieveAudioFromConform(SampleBuffer &sample_buffer, const QVector<QString> &conform_filenames, rational time, LoopMode loop_mode);
 
   CodecStream stream_;
 

app/codec/encoder.cpp

@@ -22,6 +22,7 @@
 
 #include <QFile>
 
+#include "common/filefunctions.h"
 #include "common/xmlutils.h"
 #include "ffmpeg/ffmpegencoder.h"
 #include "oiio/oiioencoder.h"
@@ -201,8 +202,8 @@ void EncodingParams::Save(QXmlStreamWriter *writer) const
   writer->writeTextElement(QStringLiteral("format"), QString::number(format_));
 
   writer->writeTextElement(QStringLiteral("range"), QString::number(has_custom_range_));
-  writer->writeTextElement(QStringLiteral("customrangein"), QString::fromStdString(custom_range_.in().toString()));
-  writer->writeTextElement(QStringLiteral("customrangeout"), QString::fromStdString(custom_range_.out().toString()));
+  writer->writeTextElement(QStringLiteral("customrangein"), custom_range_.in().toString());
+  writer->writeTextElement(QStringLiteral("customrangeout"), custom_range_.out().toString());
 
   writer->writeStartElement(QStringLiteral("video"));
 
@@ -213,8 +214,8 @@ void EncodingParams::Save(QXmlStreamWriter *writer) const
     writer->writeTextElement(QStringLiteral("width"), QString::number(video_params_.width()));
     writer->writeTextElement(QStringLiteral("height"), QString::number(video_params_.height()));
     writer->writeTextElement(QStringLiteral("format"), QString::number(video_params_.format()));
-    writer->writeTextElement(QStringLiteral("pixelaspect"), QString::fromStdString(video_params_.pixel_aspect_ratio().toString()));
-    writer->writeTextElement(QStringLiteral("timebase"), QString::fromStdString(video_params_.time_base().toString()));
+    writer->writeTextElement(QStringLiteral("pixelaspect"), video_params_.pixel_aspect_ratio().toString());
+    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_min_bit_rate_));
@@ -256,8 +257,8 @@ void EncodingParams::Save(QXmlStreamWriter *writer) const
   if (audio_enabled_) {
     writer->writeTextElement(QStringLiteral("codec"), QString::number(audio_codec_));
     writer->writeTextElement(QStringLiteral("samplerate"), QString::number(audio_params_.sample_rate()));
-    writer->writeTextElement(QStringLiteral("channellayout"), QString::number(audio_params_.channel_layout()));
-    writer->writeTextElement(QStringLiteral("format"), QString::fromStdString(audio_params_.format().to_string()));
+    writer->writeTextElement(QStringLiteral("channellayout"), audio_params_.channel_layout().toString());
+    writer->writeTextElement(QStringLiteral("format"), audio_params_.format().to_string());
     writer->writeTextElement(QStringLiteral("bitrate"), QString::number(audio_bit_rate_));
   }
 
@@ -380,9 +381,9 @@ bool EncodingParams::LoadV1(QXmlStreamReader *reader)
     } 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().toStdString());
+      custom_range_in = rational::fromString(reader->readElementText());
     } else if (reader->name() == QStringLiteral("customrangeout")) {
-      custom_range_out = rational::fromString(reader->readElementText().toStdString());
+      custom_range_out = rational::fromString(reader->readElementText());
     } else if (reader->name() == QStringLiteral("video")) {
       XMLAttributeLoop(reader, attr) {
         if (attr.name() == QStringLiteral("enabled")) {
@@ -400,9 +401,9 @@ bool EncodingParams::LoadV1(QXmlStreamReader *reader)
         } else if (reader->name() == QStringLiteral("format")) {
           video_params_.set_format(static_cast<PixelFormat::Format>(reader->readElementText().toInt()));
         } else if (reader->name() == QStringLiteral("pixelaspect")) {
-          video_params_.set_pixel_aspect_ratio(rational::fromString(reader->readElementText().toStdString()));
+          video_params_.set_pixel_aspect_ratio(rational::fromString(reader->readElementText()));
         } else if (reader->name() == QStringLiteral("timebase")) {
-          video_params_.set_time_base(rational::fromString(reader->readElementText().toStdString()));
+          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")) {
@@ -469,9 +470,9 @@ bool EncodingParams::LoadV1(QXmlStreamReader *reader)
         } 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());
+          audio_params_.set_channel_layout(AudioChannelLayout::fromString(reader->readElementText()));
         } else if (reader->name() == QStringLiteral("format")) {
-          audio_params_.set_format(SampleFormat::from_string(reader->readElementText().toStdString()));
+          audio_params_.set_format(SampleFormat::from_string(reader->readElementText()));
         } else if (reader->name() == QStringLiteral("bitrate")) {
           audio_bit_rate_ = reader->readElementText().toLongLong();
         } else {

app/codec/encoder.h

@@ -229,7 +229,7 @@ class Encoder : public QObject
 public slots:
   virtual bool Open() = 0;
 
-  virtual bool WriteFrame(olive::FramePtr frame, olive::core::rational time) = 0;
+  virtual bool WriteFrame(olive::FramePtr frame, rational time) = 0;
   virtual bool WriteAudio(const olive::SampleBuffer &audio) = 0;
   virtual bool WriteSubtitle(const SubtitleBlock *sub_block) = 0;