exportdialog: allow restoring parameters

app/codec/encoder.cpp

@@ -93,7 +93,9 @@ EncodingParams::EncodingParams() :
   audio_enabled_(false),
   audio_bit_rate_(0),
   subtitles_enabled_(false),
-  subtitles_are_sidecar_(false)
+  subtitles_are_sidecar_(false),
+  video_scaling_method_(kStretch),
+  has_custom_range_(false)
 {
 }
 
@@ -142,7 +144,14 @@ void EncodingParams::DisableSubtitles()
 
 void EncodingParams::Save(QXmlStreamWriter *writer) const
 {
+  writer->writeTextElement(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"));
 
@@ -156,10 +165,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"));
@@ -191,6 +208,19 @@ 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
 }
 
@@ -255,4 +285,30 @@ 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;
+}
+
 }

app/codec/encoder.h

@@ -41,10 +41,22 @@ namespace olive {
 class Encoder;
 using EncoderPtr = std::shared_ptr<Encoder>;
 
-class EncodingParams {
+class EncodingParams
+{
 public:
+  enum VideoScalingMethod {
+    kFit,
+    kStretch,
+    kCrop
+  };
+
   EncodingParams();
 
+  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);
@@ -75,6 +87,8 @@ public:
   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_; }
@@ -99,9 +113,26 @@ public:
   const rational& GetExportLength() const { return export_length_; }
   void SetExportLength(const rational& export_length) { export_length_ = export_length; }
 
-  virtual void Save(QXmlStreamWriter* writer) 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)
+  {
+    has_custom_range_ = true;
+    custom_range_ = custom_range;
+  }
+
+  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; }
+
+  static QMatrix4x4 GenerateMatrix(VideoScalingMethod method,
+                                   int source_width, int source_height,
+                                   int dest_width, int dest_height);
 
 private:
+  static const int kEncoderParamsVersion = 1;
+
   QString filename_;
   ExportFormat::Format format_;
 
@@ -129,6 +160,10 @@ private:
   ExportCodec::Codec subtitles_codec_;
 
   rational export_length_;
+  VideoScalingMethod video_scaling_method_;
+
+  bool has_custom_range_;
+  TimeRange custom_range_;
 
 };
 

app/codec/ffmpeg/ffmpegencoder.cpp

@@ -638,7 +638,9 @@ 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++) {
-        av_opt_set(codec_ctx->priv_data, i.key().toUtf8(), i.value().toUtf8(), AV_OPT_SEARCH_CHILDREN);
+        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) {