src/model_options.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Simple x264 Launcher
   3 // Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License along
  16 // with this program; if not, write to the Free Software Foundation, Inc.,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // http://www.gnu.org/licenses/gpl-2.0.txt
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 #include "model_options.h"
  23
  24 #include "global.h"
  25 #include "model_sysinfo.h"
  26
  27 #include <QDesktopServices>
  28 #include <QSettings>
  29 #include <QStringList>
  30 #include <QApplication>
  31
  32 #define COMPARE_VAL(OTHER, NAME) ((this->NAME) == (OTHER->NAME))
  33 #define COMPARE_STR(OTHER, NAME) ((this->NAME).compare((model->NAME), Qt::CaseInsensitive) == 0)
  34 #define ASSIGN_FROM(OTHER, NAME) ((this->NAME) = (OTHER.NAME))
  35
  36 //Template keys
  37 static const char *KEY_ENCODER_TYPE    = "encoder_type";
  38 static const char *KEY_ENCODER_ARCH    = "encoder_arch";
  39 static const char *KEY_ENCODER_VARIANT = "encoder_variant";
  40 static const char *KEY_RATECTRL_MODE   = "rate_control_mode";
  41 static const char *KEY_TARGET_BITRATE  = "target_bitrate";
  42 static const char *KEY_TARGET_QUANT    = "target_quantizer";
  43 static const char *KEY_PRESET_NAME     = "preset_name";
  44 static const char *KEY_TUNING_NAME     = "tuning_name";
  45 static const char *KEY_PROFILE_NAME    = "profile_name";
  46 static const char *KEY_CUSTOM_ENCODER  = "custom_params_encoder";
  47 static const char *KEY_CUSTOM_AVS2YUV  = "custom_params_avs2yuv";
  48
  49 const char *const OptionsModel::TUNING_UNSPECIFIED   = "<None>";
  50 const char *const OptionsModel::PROFILE_UNRESTRICTED = "<Unrestricted>";
  51
  52 OptionsModel::OptionsModel(const SysinfoModel *sysinfo)
  53 {
  54         m_encoderType = EncType_X264;
  55         m_encoderArch = sysinfo->hasX64Support() ? EncArch_x64 : EncArch_x32;
  56         m_encoderVariant = EncVariant_LoBit;
  57         m_rcMode = RCMode_CRF;
  58         m_bitrate = 1200;
  59         m_quantizer = 22;
  60         m_preset = "Medium";
  61         m_tune = QString::fromLatin1(OptionsModel::TUNING_UNSPECIFIED);
  62         m_profile = QString::fromLatin1(OptionsModel::PROFILE_UNRESTRICTED);
  63         m_custom_encoder = QString();
  64         m_custom_avs2yuv = QString();
  65 }
  66
  67 OptionsModel::OptionsModel(const OptionsModel &rhs)
  68 {
  69         ASSIGN_FROM(rhs, m_encoderType);
  70         ASSIGN_FROM(rhs, m_encoderArch);
  71         ASSIGN_FROM(rhs, m_encoderVariant);
  72         ASSIGN_FROM(rhs, m_rcMode);
  73         ASSIGN_FROM(rhs, m_bitrate);
  74         ASSIGN_FROM(rhs, m_quantizer);
  75         ASSIGN_FROM(rhs, m_preset);
  76         ASSIGN_FROM(rhs, m_tune);
  77         ASSIGN_FROM(rhs, m_profile);
  78         ASSIGN_FROM(rhs, m_custom_encoder);
  79         ASSIGN_FROM(rhs, m_custom_avs2yuv);
  80 }
  81
  82 OptionsModel::~OptionsModel(void)
  83 {
  84 }
  85
  86 QString OptionsModel::rcMode2String(RCMode mode)
  87 {
  88         switch(mode)
  89         {
  90         case RCMode_CRF:
  91                 return QObject::tr("CRF");
  92                 break;
  93         case RCMode_CQ:
  94                 return QObject::tr("CQ");
  95                 break;
  96         case RCMode_2Pass:
  97                 return QObject::tr("2-Pass");
  98                 break;
  99         case RCMode_ABR:
 100                 return QObject::tr("ABR");
 101                 break;
 102         default:
 103                 return QString();
 104                 break;
 105         }
 106 }
 107
 108 bool OptionsModel::equals(const OptionsModel *model)
 109 {
 110         bool equal = true;
 111
 112         equal = equal && COMPARE_VAL(model, m_encoderType);
 113         equal = equal && COMPARE_VAL(model, m_encoderArch);
 114         equal = equal && COMPARE_VAL(model, m_encoderVariant);
 115         equal = equal && COMPARE_VAL(model, m_rcMode);
 116         equal = equal && COMPARE_VAL(model, m_bitrate);
 117         equal = equal && COMPARE_VAL(model, m_quantizer);
 118         equal = equal && COMPARE_STR(model, m_preset);
 119         equal = equal && COMPARE_STR(model, m_tune);
 120         equal = equal && COMPARE_STR(model, m_profile);
 121         equal = equal && COMPARE_STR(model, m_custom_encoder);
 122         equal = equal && COMPARE_STR(model, m_custom_avs2yuv);
 123
 124         return equal;
 125 }
 126
 127 bool OptionsModel::saveTemplate(const OptionsModel *model, const QString &name)
 128 {
 129         const QString templateName = name.simplified();
 130         const QString appDir = x264_data_path();
 131
 132         if(templateName.contains('\\') || templateName.contains('/'))
 133         {
 134                 return false;
 135         }
 136
 137         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 138         settings.beginGroup(templateName);
 139
 140         const bool okay = saveOptions(model, settings);
 141
 142         settings.endGroup();
 143         settings.sync();
 144
 145         return okay;
 146 }
 147
 148 bool OptionsModel::loadTemplate(OptionsModel *model, const QString &name)
 149 {
 150         const QString appDir = x264_data_path();
 151
 152         if(name.contains('\\') || name.contains('/'))
 153         {
 154                 return false;
 155         }
 156
 157         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 158
 159         settings.beginGroup(name);
 160         const bool okay = loadOptions(model, settings);
 161         settings.endGroup();
 162
 163         return okay;
 164 }
 165
 166 QMap<QString, OptionsModel*> OptionsModel::loadAllTemplates(const SysinfoModel *sysinfo)
 167 {
 168         QMap<QString, OptionsModel*> list;
 169         const QString appDir = x264_data_path();
 170         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 171         QStringList allTemplates = settings.childGroups();
 172
 173         while(!allTemplates.isEmpty())
 174         {
 175                 QString name = allTemplates.takeFirst();
 176                 if(!(name.contains('<') || name.contains('>') || name.contains('\\') || name.contains('/')))
 177                 {
 178                         OptionsModel *options = new OptionsModel(sysinfo);
 179                         if(loadTemplate(options, name))
 180                         {
 181                                 list.insert(name, options);
 182                                 continue;
 183                         }
 184                         X264_DELETE(options);
 185                 }
 186         }
 187
 188         return list;
 189 }
 190
 191 bool OptionsModel::templateExists(const QString &name)
 192 {
 193         const QString appDir = x264_data_path();
 194         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 195         QStringList allGroups = settings.childGroups();
 196         return allGroups.contains(name, Qt::CaseInsensitive);
 197 }
 198
 199 bool OptionsModel::deleteTemplate(const QString &name)
 200 {
 201         const QString appDir = x264_data_path();
 202         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 203
 204         if(settings.childGroups().contains(name, Qt::CaseInsensitive))
 205         {
 206                 settings.remove(name);
 207                 return true;
 208         }
 209
 210         return false;
 211 }
 212
 213 bool OptionsModel::saveOptions(const OptionsModel *model, QSettings &settingsFile)
 214 {
 215         settingsFile.setValue(KEY_ENCODER_TYPE,    model->m_encoderType);
 216         settingsFile.setValue(KEY_ENCODER_ARCH,    model->m_encoderArch);
 217         settingsFile.setValue(KEY_ENCODER_VARIANT, model->m_encoderVariant);
 218         settingsFile.setValue(KEY_RATECTRL_MODE,   model->m_rcMode);
 219         settingsFile.setValue(KEY_TARGET_BITRATE,  model->m_bitrate);
 220         settingsFile.setValue(KEY_TARGET_QUANT,    model->m_quantizer);
 221         settingsFile.setValue(KEY_PRESET_NAME,     model->m_preset);
 222         settingsFile.setValue(KEY_TUNING_NAME,     model->m_tune);
 223         settingsFile.setValue(KEY_PROFILE_NAME,    model->m_profile);
 224         settingsFile.setValue(KEY_CUSTOM_ENCODER,  model->m_custom_encoder);
 225         settingsFile.setValue(KEY_CUSTOM_AVS2YUV,  model->m_custom_avs2yuv);
 226
 227         return true;
 228 }
 229
 230 bool OptionsModel::loadOptions(OptionsModel *model, QSettings &settingsFile)
 231 {
 232         fixTemplate(settingsFile); /*for backward compatibility*/
 233
 234         bool complete = true;
 235         if(!settingsFile.contains(KEY_ENCODER_TYPE))    complete = false;
 236         if(!settingsFile.contains(KEY_ENCODER_ARCH))    complete = false;
 237         if(!settingsFile.contains(KEY_ENCODER_VARIANT)) complete = false;
 238         if(!settingsFile.contains(KEY_RATECTRL_MODE))   complete = false;
 239         if(!settingsFile.contains(KEY_TARGET_BITRATE))  complete = false;
 240         if(!settingsFile.contains(KEY_TARGET_QUANT))    complete = false;
 241         if(!settingsFile.contains(KEY_PRESET_NAME))     complete = false;
 242         if(!settingsFile.contains(KEY_TUNING_NAME))     complete = false;
 243         if(!settingsFile.contains(KEY_PROFILE_NAME))    complete = false;
 244         if(!settingsFile.contains(KEY_CUSTOM_ENCODER))  complete = false;
 245         if(!settingsFile.contains(KEY_CUSTOM_AVS2YUV))  complete = false;
 246
 247         if(complete)
 248         {
 249                 model->setEncType        (static_cast<OptionsModel::EncType>   (settingsFile.value(KEY_ENCODER_TYPE,    model->m_encoderType)   .toInt()));
 250                 model->setEncArch        (static_cast<OptionsModel::EncArch>   (settingsFile.value(KEY_ENCODER_ARCH,    model->m_encoderArch)   .toInt()));
 251                 model->setEncVariant     (static_cast<OptionsModel::EncVariant>(settingsFile.value(KEY_ENCODER_VARIANT, model->m_encoderVariant).toInt()));
 252                 model->setRCMode         (static_cast<OptionsModel::RCMode>    (settingsFile.value(KEY_RATECTRL_MODE,   model->m_rcMode)        .toInt()));
 253                 model->setBitrate        (settingsFile.value(KEY_TARGET_BITRATE, model->m_bitrate)       .toUInt()  );
 254                 model->setQuantizer      (settingsFile.value(KEY_TARGET_QUANT,   model->m_quantizer)     .toDouble());
 255                 model->setPreset         (settingsFile.value(KEY_PRESET_NAME,    model->m_preset)        .toString());
 256                 model->setTune           (settingsFile.value(KEY_TUNING_NAME,    model->m_tune)          .toString());
 257                 model->setProfile        (settingsFile.value(KEY_PROFILE_NAME,   model->m_profile)       .toString());
 258                 model->setCustomEncParams(settingsFile.value(KEY_CUSTOM_ENCODER, model->m_custom_encoder).toString());
 259                 model->setCustomAvs2YUV  (settingsFile.value(KEY_CUSTOM_AVS2YUV, model->m_custom_avs2yuv).toString());
 260         }
 261
 262         return complete;
 263 }
 264
 265 void OptionsModel::fixTemplate(QSettings &settingsFile)
 266 {
 267         if(!(settingsFile.contains(KEY_ENCODER_TYPE) || settingsFile.contains(KEY_ENCODER_ARCH) || settingsFile.contains(KEY_ENCODER_VARIANT)))
 268         {
 269                 settingsFile.setValue(KEY_ENCODER_TYPE,    OptionsModel::EncType_X264);
 270                 settingsFile.setValue(KEY_ENCODER_ARCH,    OptionsModel::EncArch_x32);
 271                 settingsFile.setValue(KEY_ENCODER_VARIANT, OptionsModel::EncVariant_LoBit);
 272         }
 273
 274         static const char *legacyKey[] = { "custom_params", "custom_params_x264", NULL };
 275         for(int i = 0; legacyKey[i]; i++)
 276         {
 277                 if(settingsFile.contains(legacyKey[i]))
 278                 {
 279                         settingsFile.setValue(KEY_CUSTOM_ENCODER, settingsFile.value(legacyKey[i]));
 280                         settingsFile.remove(legacyKey[i]);
 281                 }
 282         }
 283
 284         if(settingsFile.value(KEY_PROFILE_NAME).toString().compare("auto", Qt::CaseInsensitive) == 0)
 285         {
 286                 settingsFile.setValue(KEY_PROFILE_NAME, QString::fromLatin1(OptionsModel::PROFILE_UNRESTRICTED));
 287         }
 288         if(settingsFile.value(KEY_TUNING_NAME).toString().compare("none", Qt::CaseInsensitive) == 0)
 289         {
 290                 settingsFile.setValue(KEY_TUNING_NAME, QString::fromLatin1(OptionsModel::TUNING_UNSPECIFIED));
 291         }
 292 }