reworked timeline elements

app/node/block/block.cpp

@@ -24,7 +24,6 @@
 
 #include "node/output/track/track.h"
 #include "transition/transition.h"
-#include "widget/slider/floatslider.h"
 #include "widget/slider/rationalslider.h"
 
 namespace olive {
@@ -32,18 +31,13 @@ namespace olive {
 #define super Node
 
 const QString Block::kLengthInput = QStringLiteral("length_in");
-const QString Block::kMediaInInput = QStringLiteral("media_in_in");
 const QString Block::kEnabledInput = QStringLiteral("enabled_in");
-const QString Block::kSpeedInput = QStringLiteral("speed_in");
-const QString Block::kReverseInput = QStringLiteral("reverse_in");
 
 Block::Block() :
   previous_(nullptr),
   next_(nullptr),
   track_(nullptr),
-  index_(-1),
-  in_transition_(nullptr),
-  out_transition_(nullptr)
+  index_(-1)
 {
   AddInput(kLengthInput, NodeValue::kRational, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
   SetInputProperty(kLengthInput, QStringLiteral("min"), QVariant::fromValue(rational(0, 1)));
@@ -51,21 +45,8 @@ Block::Block() :
   SetInputProperty(kLengthInput, QStringLiteral("viewlock"), true);
   IgnoreHashingFrom(kLengthInput);
 
-  AddInput(kMediaInInput, NodeValue::kRational, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
-  SetInputProperty(kMediaInInput, QStringLiteral("view"), RationalSlider::kTime);
-  SetInputProperty(kMediaInInput, QStringLiteral("viewlock"), true);
-  IgnoreHashingFrom(kMediaInInput);
-
   AddInput(kEnabledInput, NodeValue::kBoolean, true, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
 
-  AddInput(kSpeedInput, NodeValue::kFloat, 1.0, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
-  SetInputProperty(kSpeedInput, QStringLiteral("view"), FloatSlider::kPercentage);
-  SetInputProperty(kSpeedInput, QStringLiteral("min"), 0.0);
-  IgnoreHashingFrom(kSpeedInput);
-
-  AddInput(kReverseInput, NodeValue::kBoolean, false, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
-  IgnoreHashingFrom(kReverseInput);
-
   // A block's length must be greater than 0
   set_length_and_media_out(1);
 }
@@ -82,47 +63,23 @@ rational Block::length() const
 
 void Block::set_length_and_media_out(const rational &length)
 {
-  Q_ASSERT(length > 0);
-
   if (length == this->length()) {
     return;
   }
 
-  if (reverse()) {
-    // Calculate media_in adjustment
-    set_media_in(SequenceToMediaTime(length - this->length(), true));
-  }
-
   set_length_internal(length);
 }
 
 void Block::set_length_and_media_in(const rational &length)
 {
-  Q_ASSERT(length > 0);
-
   if (length == this->length()) {
     return;
   }
 
-  if (!reverse()) {
-    // Calculate media_in adjustment
-    set_media_in(SequenceToMediaTime(this->length() - length));
-  }
-
   // Set the length without setting media out
   set_length_internal(length);
 }
 
-rational Block::media_in() const
-{
-  return GetStandardValue(kMediaInInput).value<rational>();
-}
-
-void Block::set_media_in(const rational &media_in)
-{
-  SetStandardValue(kMediaInInput, QVariant::fromValue(media_in));
-}
-
 bool Block::is_enabled() const
 {
   return GetStandardValue(kEnabledInput).toBool();
@@ -135,65 +92,9 @@ void Block::set_enabled(bool e)
   emit EnabledChanged();
 }
 
-rational Block::SequenceToMediaTime(const rational &sequence_time, bool ignore_reverse) const
-{
-  // These constants are not considered "values" per se, so we don't modify them
-  if (sequence_time == RATIONAL_MIN || sequence_time == RATIONAL_MAX) {
-    return sequence_time;
-  }
-
-  rational local_time = sequence_time;
-
-  double speed_value = speed();
-
-  if (qIsNull(speed_value)) {
-    // Effectively holds the frame at the in point
-    local_time = 0;
-  } else if (!qFuzzyCompare(speed_value, 1.0)) {
-    // Multiply time
-    local_time = rational::fromDouble(local_time.toDouble() * speed_value);
-  }
-
-  rational media_time = local_time + media_in();
-
-  if (reverse() && !ignore_reverse) {
-    media_time = length() - media_time;
-  }
-
-  return media_time;
-}
-
-rational Block::MediaToSequenceTime(const rational &media_time) const
-{
-  // These constants are not considered "values" per se, so we don't modify them
-  if (media_time == RATIONAL_MIN || media_time == RATIONAL_MAX) {
-    return media_time;
-  }
-
-  rational sequence_time = media_time;
-
-  if (reverse()) {
-    sequence_time = length() - sequence_time;
-  }
-
-  sequence_time -= media_in();
-
-  double speed_value = speed();
-
-  if (qIsNull(speed_value)) {
-    // Effectively holds the frame at the in point, also prevents divide by zero
-    sequence_time = 0;
-  } else if (!qFuzzyCompare(speed_value, 1.0)) {
-    // Multiply time
-    sequence_time = rational::fromDouble(sequence_time.toDouble() / speed_value);
-  }
-
-  return sequence_time;
-}
-
 void Block::InputValueChangedEvent(const QString &input, int element)
 {
-  Q_UNUSED(element)
+  super::InputValueChangedEvent(input, element);
 
   if (input == kLengthInput) {
     emit LengthChanged();
@@ -202,19 +103,6 @@ void Block::InputValueChangedEvent(const QString &input, int element)
   }
 }
 
-void Block::LinkChangeEvent()
-{
-  block_links_.clear();
-
-  foreach (Node* n, links()) {
-    Block* b = dynamic_cast<Block*>(n);
-
-    if (b) {
-      block_links_.append(b);
-    }
-  }
-}
-
 bool Block::HashPassthrough(const QString &input, const QString &output, QCryptographicHash &hash, const rational &time, const VideoParams &video_params) const
 {
   if (IsInputConnected(input)) {
@@ -239,10 +127,7 @@ void Block::Retranslate()
   super::Retranslate();
 
   SetInputName(kLengthInput, tr("Length"));
-  SetInputName(kMediaInInput, tr("Media In"));
   SetInputName(kEnabledInput, tr("Enabled"));
-  SetInputName(kSpeedInput, tr("Speed"));
-  SetInputName(kReverseInput, tr("Reverse"));
 }
 
 void Block::Hash(const QString &, QCryptographicHash &, const rational &, const VideoParams &) const

app/node/block/block.h

@@ -62,8 +62,8 @@ public:
   }
 
   rational length() const;
-  void set_length_and_media_out(const rational &length);
-  void set_length_and_media_in(const rational &length);
+  virtual void set_length_and_media_out(const rational &length);
+  virtual void set_length_and_media_in(const rational &length);
 
   TimeRange range() const
   {
@@ -90,9 +90,6 @@ public:
     next_ = next;
   }
 
-  rational media_in() const;
-  void set_media_in(const rational& media_in);
-
   Track* track() const
   {
     return track_;
@@ -108,26 +105,6 @@ public:
 
   virtual void Retranslate() override;
 
-  TransitionBlock* in_transition()
-  {
-    return in_transition_;
-  }
-
-  void set_in_transition(TransitionBlock* t)
-  {
-    in_transition_ = t;
-  }
-
-  TransitionBlock* out_transition()
-  {
-    return out_transition_;
-  }
-
-  void set_out_transition(TransitionBlock* t)
-  {
-    out_transition_ = t;
-  }
-
   int index() const
   {
     return index_;
@@ -138,30 +115,12 @@ public:
     index_ = i;
   }
 
-  const QVector<Block*>& block_links() const
-  {
-    return block_links_;
-  }
-
-  double speed() const
-  {
-    return GetStandardValue(kSpeedInput).toDouble();
-  }
-
-  bool reverse() const
-  {
-    return GetStandardValue(kReverseInput).toBool();
-  }
-
   virtual void Hash(const QString& output, QCryptographicHash &hash, const rational &time, const VideoParams& video_params) const override;
 
   virtual void InvalidateCache(const TimeRange& range, const QString& from, int element = -1, InvalidateCacheOptions options = InvalidateCacheOptions()) override;
 
   static const QString kLengthInput;
-  static const QString kMediaInInput;
   static const QString kEnabledInput;
-  static const QString kSpeedInput;
-  static const QString kReverseInput;
 
 public slots:
 
@@ -171,14 +130,8 @@ signals:
   void LengthChanged();
 
 protected:
-  rational SequenceToMediaTime(const rational& sequence_time, bool ignore_reverse = false) const;
-
-  rational MediaToSequenceTime(const rational& media_time) const;
-
   virtual void InputValueChangedEvent(const QString& input, int element) override;
 
-  virtual void LinkChangeEvent() override;
-
   bool HashPassthrough(const QString &input, const QString& output, QCryptographicHash &hash, const rational &time, const VideoParams& video_params) const;
 
   Block* previous_;
@@ -192,11 +145,6 @@ private:
   Track* track_;
   int index_;
 
-  TransitionBlock* in_transition_;
-  TransitionBlock* out_transition_;
-
-  QVector<Block*> block_links_;
-
   rational last_length_;
 
 };

app/node/block/clip/clip.cpp

@@ -20,17 +20,36 @@
 
 #include "clip.h"
 
+#include "widget/slider/floatslider.h"
+#include "widget/slider/rationalslider.h"
+
 namespace olive {
 
 #define super Block
 
 const QString ClipBlock::kBufferIn = QStringLiteral("buffer_in");
+const QString ClipBlock::kMediaInInput = QStringLiteral("media_in_in");
+const QString ClipBlock::kSpeedInput = QStringLiteral("speed_in");
+const QString ClipBlock::kReverseInput = QStringLiteral("reverse_in");
 
-ClipBlock::ClipBlock(bool create_buffer_in)
+ClipBlock::ClipBlock() :
+  in_transition_(nullptr),
+  out_transition_(nullptr)
 {
-  if (create_buffer_in) {
-    AddInput(kBufferIn, NodeValue::kNone, InputFlags(kInputFlagNotKeyframable));
-  }
+  AddInput(kMediaInInput, NodeValue::kRational, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
+  SetInputProperty(kMediaInInput, QStringLiteral("view"), RationalSlider::kTime);
+  SetInputProperty(kMediaInInput, QStringLiteral("viewlock"), true);
+  IgnoreHashingFrom(kMediaInInput);
+
+  AddInput(kSpeedInput, NodeValue::kFloat, 1.0, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
+  SetInputProperty(kSpeedInput, QStringLiteral("view"), FloatSlider::kPercentage);
+  SetInputProperty(kSpeedInput, QStringLiteral("min"), 0.0);
+  IgnoreHashingFrom(kSpeedInput);
+
+  AddInput(kReverseInput, NodeValue::kBoolean, false, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
+  IgnoreHashingFrom(kReverseInput);
+
+  AddInput(kBufferIn, NodeValue::kNone, InputFlags(kInputFlagNotKeyframable));
 }
 
 Node *ClipBlock::copy() const
@@ -53,6 +72,100 @@ QString ClipBlock::Description() const
   return tr("A time-based node that represents a media source.");
 }
 
+void ClipBlock::set_length_and_media_out(const rational &length)
+{
+  if (length == this->length()) {
+    return;
+  }
+
+  if (reverse()) {
+    // Calculate media_in adjustment
+    set_media_in(SequenceToMediaTime(length - this->length(), true));
+  }
+
+  super::set_length_and_media_out(length);
+}
+
+void ClipBlock::set_length_and_media_in(const rational &length)
+{
+  if (length == this->length()) {
+    return;
+  }
+
+  if (!reverse()) {
+    // Calculate media_in adjustment
+    set_media_in(SequenceToMediaTime(this->length() - length));
+  }
+
+  super::set_length_and_media_in(length);
+}
+
+rational ClipBlock::media_in() const
+{
+  return GetStandardValue(kMediaInInput).value<rational>();
+}
+
+void ClipBlock::set_media_in(const rational &media_in)
+{
+  SetStandardValue(kMediaInInput, QVariant::fromValue(media_in));
+}
+
+rational ClipBlock::SequenceToMediaTime(const rational &sequence_time, bool ignore_reverse) const
+{
+  // These constants are not considered "values" per se, so we don't modify them
+  if (sequence_time == RATIONAL_MIN || sequence_time == RATIONAL_MAX) {
+    return sequence_time;
+  }
+
+  rational local_time = sequence_time;
+
+  double speed_value = speed();
+
+  if (qIsNull(speed_value)) {
+    // Effectively holds the frame at the in point
+    local_time = 0;
+  } else if (!qFuzzyCompare(speed_value, 1.0)) {
+    // Multiply time
+    local_time = rational::fromDouble(local_time.toDouble() * speed_value);
+  }
+
+  rational media_time = local_time + media_in();
+
+  if (reverse() && !ignore_reverse) {
+    media_time = length() - media_time;
+  }
+
+  return media_time;
+}
+
+rational ClipBlock::MediaToSequenceTime(const rational &media_time) const
+{
+  // These constants are not considered "values" per se, so we don't modify them
+  if (media_time == RATIONAL_MIN || media_time == RATIONAL_MAX) {
+    return media_time;
+  }
+
+  rational sequence_time = media_time;
+
+  if (reverse()) {
+    sequence_time = length() - sequence_time;
+  }
+
+  sequence_time -= media_in();
+
+  double speed_value = speed();
+
+  if (qIsNull(speed_value)) {
+    // Effectively holds the frame at the in point, also prevents divide by zero
+    sequence_time = 0;
+  } else if (!qFuzzyCompare(speed_value, 1.0)) {
+    // Multiply time
+    sequence_time = rational::fromDouble(sequence_time.toDouble() / speed_value);
+  }
+
+  return sequence_time;
+}
+
 void ClipBlock::InvalidateCache(const TimeRange& range, const QString& from, int element, InvalidateCacheOptions options)
 {
   Q_UNUSED(element)
@@ -70,6 +183,19 @@ void ClipBlock::InvalidateCache(const TimeRange& range, const QString& from, int
   }
 }
 
+void ClipBlock::LinkChangeEvent()
+{
+  block_links_.clear();
+
+  foreach (Node* n, links()) {
+    ClipBlock* b = dynamic_cast<ClipBlock*>(n);
+
+    if (b) {
+      block_links_.append(b);
+    }
+  }
+}
+
 TimeRange ClipBlock::InputTimeAdjustment(const QString& input, int element, const TimeRange& input_time) const
 {
   Q_UNUSED(element)
@@ -110,9 +236,10 @@ void ClipBlock::Retranslate()
 {
   super::Retranslate();
 
-  if (HasInputWithID(kBufferIn)) {
-    SetInputName(kBufferIn, tr("Buffer"));
-  }
+  SetInputName(kBufferIn, tr("Buffer"));
+  SetInputName(kMediaInInput, tr("Media In"));
+  SetInputName(kSpeedInput, tr("Speed"));
+  SetInputName(kReverseInput, tr("Reverse"));
 }
 
 void ClipBlock::Hash(const QString &out, QCryptographicHash &hash, const rational &time, const VideoParams &video_params) const

app/node/block/clip/clip.h

@@ -32,7 +32,7 @@ class ClipBlock : public Block
 {
   Q_OBJECT
 public:
-  ClipBlock(bool create_buffer_in = true);
+  ClipBlock();
 
   NODE_DEFAULT_DESTRUCTOR(ClipBlock)
 
@@ -42,6 +42,12 @@ public:
   virtual QString id() const override;
   virtual QString Description() const override;
 
+  virtual void set_length_and_media_out(const rational &length) override;
+  virtual void set_length_and_media_in(const rational &length) override;
+
+  rational media_in() const;
+  void set_media_in(const rational& media_in);
+
   virtual void InvalidateCache(const TimeRange& range, const QString& from, int element, InvalidateCacheOptions options) override;
 
   virtual TimeRange InputTimeAdjustment(const QString& input, int element, const TimeRange& input_time) const override;
@@ -54,7 +60,58 @@ public:
 
   virtual void Hash(const QString& output, QCryptographicHash &hash, const rational &time, const VideoParams& video_params) const override;
 
+  double speed() const
+  {
+    return GetStandardValue(kSpeedInput).toDouble();
+  }
+
+  bool reverse() const
+  {
+    return GetStandardValue(kReverseInput).toBool();
+  }
+
+  TransitionBlock* in_transition()
+  {
+    return in_transition_;
+  }
+
+  void set_in_transition(TransitionBlock* t)
+  {
+    in_transition_ = t;
+  }
+
+  TransitionBlock* out_transition()
+  {
+    return out_transition_;
+  }
+
+  void set_out_transition(TransitionBlock* t)
+  {
+    out_transition_ = t;
+  }
+
+  const QVector<Block*>& block_links() const
+  {
+    return block_links_;
+  }
+
   static const QString kBufferIn;
+  static const QString kMediaInInput;
+  static const QString kSpeedInput;
+  static const QString kReverseInput;
+
+protected:
+  virtual void LinkChangeEvent() override;
+
+private:
+  rational SequenceToMediaTime(const rational& sequence_time, bool ignore_reverse = false) const;
+
+  rational MediaToSequenceTime(const rational& media_time) const;
+
+  QVector<Block*> block_links_;
+
+  TransitionBlock* in_transition_;
+  TransitionBlock* out_transition_;
 
 };
 

app/node/block/subtitle/subtitle.cpp

@@ -26,8 +26,7 @@ namespace olive {
 
 const QString SubtitleBlock::kTextIn = QStringLiteral("text_in");
 
-SubtitleBlock::SubtitleBlock() :
-  super(false)
+SubtitleBlock::SubtitleBlock()
 {
   AddInput(kTextIn, NodeValue::kText, InputFlags(kInputFlagNotConnectable | kInputFlagNotKeyframable));
 }

app/node/block/transition/transition.cpp

@@ -21,6 +21,7 @@
 #include "transition.h"
 
 #include "common/clamp.h"
+#include "node/block/clip/clip.h"
 #include "node/output/track/track.h"
 
 namespace olive {
@@ -30,6 +31,8 @@ namespace olive {
 const QString TransitionBlock::kOutBlockInput = QStringLiteral("out_block_in");
 const QString TransitionBlock::kInBlockInput = QStringLiteral("in_block_in");
 const QString TransitionBlock::kCurveInput = QStringLiteral("curve_in");
+const QString TransitionBlock::kInOffsetInput = QStringLiteral("in_offset_in");
+const QString TransitionBlock::kOutOffsetInput = QStringLiteral("out_offset_in");
 
 TransitionBlock::TransitionBlock() :
   connected_out_block_(nullptr),
@@ -40,6 +43,12 @@ TransitionBlock::TransitionBlock() :
   AddInput(kInBlockInput, NodeValue::kNone, InputFlags(kInputFlagNotKeyframable));
 
   AddInput(kCurveInput, NodeValue::kCombo, InputFlags(kInputFlagNotKeyframable | kInputFlagNotConnectable));
+
+  AddInput(kInOffsetInput, NodeValue::kRational, InputFlags(kInputFlagNotKeyframable | kInputFlagNotConnectable));
+
+  AddInput(kOutOffsetInput, NodeValue::kRational, InputFlags(kInputFlagNotKeyframable | kInputFlagNotConnectable));
+
+  set_length_and_media_out(0);
 }
 
 void TransitionBlock::Retranslate()
@@ -49,6 +58,8 @@ void TransitionBlock::Retranslate()
   SetInputName(kOutBlockInput, tr("From"));
   SetInputName(kInBlockInput, tr("To"));
   SetInputName(kCurveInput, tr("Curve"));
+  SetInputName(kInOffsetInput, tr("In Offset"));
+  SetInputName(kOutOffsetInput, tr("Out Offset"));
 
   // These must correspond to the CurveType enum
   SetComboBoxStrings(kCurveInput, { tr("Linear"), tr("Exponential"), tr("Logarithmic") });
@@ -56,34 +67,22 @@ void TransitionBlock::Retranslate()
 
 rational TransitionBlock::in_offset() const
 {
-  // If no in block is connected, there's no in offset
-  if (!connected_in_block()) {
-    return 0;
-  }
+  return GetStandardValue(kInOffsetInput).value<rational>();
+}
 
-  if (!connected_out_block()) {
-    // Assume only an in block is connected, in which case this entire transition length
-    return length();
-  }
-
-  // Assume both are connected
-  return length() + media_in();
+void TransitionBlock::set_in_offset(const rational &os)
+{
+  SetStandardValue(kInOffsetInput, QVariant::fromValue(os));
 }
 
 rational TransitionBlock::out_offset() const
 {
-  // If no in block is connected, there's no in offset
-  if (!connected_out_block()) {
-    return 0;
-  }
+  return GetStandardValue(kOutOffsetInput).value<rational>();
+}
 
-  if (!connected_in_block()) {
-    // Assume only an in block is connected, in which case this entire transition length
-    return length();
-  }
-
-  // Assume both are connected
-  return -media_in();
+void TransitionBlock::set_out_offset(const rational &os)
+{
+  SetStandardValue(kOutOffsetInput, QVariant::fromValue(os));
 }
 
 Block *TransitionBlock::connected_out_block() const
@@ -267,12 +266,12 @@ void TransitionBlock::InputConnectedEvent(const QString &input, int element, con
 
   if (input == kOutBlockInput) {
     // If node is not a block, this will just be null
-    if ((connected_out_block_ = dynamic_cast<Block*>(output.node()))) {
+    if ((connected_out_block_ = dynamic_cast<ClipBlock*>(output.node()))) {
       connected_out_block_->set_out_transition(this);
     }
   } else if (input == kInBlockInput) {
     // If node is not a block, this will just be null
-    if ((connected_in_block_ = dynamic_cast<Block*>(output.node()))) {
+    if ((connected_in_block_ = dynamic_cast<ClipBlock*>(output.node()))) {
       connected_in_block_->set_in_transition(this);
     }
   }

app/node/block/transition/transition.h

@@ -25,6 +25,8 @@
 
 namespace olive {
 
+class ClipBlock;
+
 class TransitionBlock : public Block
 {
   Q_OBJECT
@@ -36,7 +38,9 @@ public:
   virtual void Retranslate() override;
 
   rational in_offset() const;
+  void set_in_offset(const rational &os);
   rational out_offset() const;
+  void set_out_offset(const rational &os);
 
   Block* connected_out_block() const;
   Block* connected_in_block() const;
@@ -54,6 +58,8 @@ public:
   static const QString kOutBlockInput;
   static const QString kInBlockInput;
   static const QString kCurveInput;
+  static const QString kInOffsetInput;
+  static const QString kOutOffsetInput;
 
 protected:
   virtual void ShaderJobEvent(NodeValueDatabase &value, ShaderJob& job) const;
@@ -81,9 +87,9 @@ private:
 
   void InsertTransitionTimes(AcceleratedJob* job, const double& time) const;
 
-  Block* connected_out_block_;
+  ClipBlock* connected_out_block_;
 
-  Block* connected_in_block_;
+  ClipBlock* connected_in_block_;
 
 };