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 //Internal
  25 #include "global.h"
  26 #include "model_sysinfo.h"
  27
  28 //Mutils
  29 #include <MUtils/Global.h>
  30
  31 //Qt
  32 #include <QDesktopServices>
  33 #include <QSettings>
  34 #include <QStringList>
  35 #include <QApplication>
  36
  37 #define COMPARE_VAL(OTHER, NAME) ((this->NAME) == (OTHER->NAME))
  38 #define COMPARE_STR(OTHER, NAME) ((this->NAME).compare((model->NAME), Qt::CaseInsensitive) == 0)
  39 #define ASSIGN_FROM(OTHER, NAME) ((this->NAME) = (OTHER.NAME))
  40
  41 //Template keys
  42 static const char *KEY_ENCODER_TYPE    = "encoder_type";
  43 static const char *KEY_ENCODER_ARCH    = "encoder_arch";
  44 static const char *KEY_ENCODER_VARIANT = "encoder_variant";
  45 static const char *KEY_RATECTRL_MODE   = "rate_control_mode";
  46 static const char *KEY_TARGET_BITRATE  = "target_bitrate";
  47 static const char *KEY_TARGET_QUANT    = "target_quantizer";
  48 static const char *KEY_PRESET_NAME     = "preset_name";
  49 static const char *KEY_TUNING_NAME     = "tuning_name";
  50 static const char *KEY_PROFILE_NAME    = "profile_name";
  51 static const char *KEY_CUSTOM_ENCODER  = "custom_params_encoder";
  52 static const char *KEY_CUSTOM_AVS2YUV  = "custom_params_avs2yuv";
  53
  54 const char *const OptionsModel::TUNING_UNSPECIFIED   = "<None>";
  55 const char *const OptionsModel::PROFILE_UNRESTRICTED = "<Unrestricted>";
  56
  57 OptionsModel::OptionsModel(const SysinfoModel *sysinfo)
  58 {
  59         m_encoderType = EncType_X264;
  60         m_encoderArch = sysinfo->hasX64Support() ? EncArch_x64 : EncArch_x32;
  61         m_encoderVariant = EncVariant_LoBit;
  62         m_rcMode = RCMode_CRF;
  63         m_bitrate = 1200;
  64         m_quantizer = 22;
  65         m_preset = "Medium";
  66         m_tune = QString::fromLatin1(OptionsModel::TUNING_UNSPECIFIED);
  67         m_profile = QString::fromLatin1(OptionsModel::PROFILE_UNRESTRICTED);
  68         m_custom_encoder = QString();
  69         m_custom_avs2yuv = QString();
  70 }
  71
  72 OptionsModel::OptionsModel(const OptionsModel &rhs)
  73 {
  74         ASSIGN_FROM(rhs, m_encoderType);
  75         ASSIGN_FROM(rhs, m_encoderArch);
  76         ASSIGN_FROM(rhs, m_encoderVariant);
  77         ASSIGN_FROM(rhs, m_rcMode);
  78         ASSIGN_FROM(rhs, m_bitrate);
  79         ASSIGN_FROM(rhs, m_quantizer);
  80         ASSIGN_FROM(rhs, m_preset);
  81         ASSIGN_FROM(rhs, m_tune);
  82         ASSIGN_FROM(rhs, m_profile);
  83         ASSIGN_FROM(rhs, m_custom_encoder);
  84         ASSIGN_FROM(rhs, m_custom_avs2yuv);
  85 }
  86
  87 OptionsModel::~OptionsModel(void)
  88 {
  89 }
  90
  91 QString OptionsModel::rcMode2String(RCMode mode)
  92 {
  93         switch(mode)
  94         {
  95         case RCMode_CRF:
  96                 return QObject::tr("CRF");
  97                 break;
  98         case RCMode_CQ:
  99                 return QObject::tr("CQ");
 100                 break;
 101         case RCMode_2Pass:
 102                 return QObject::tr("2-Pass");
 103                 break;
 104         case RCMode_ABR:
 105                 return QObject::tr("ABR");
 106                 break;
 107         default:
 108                 return QString();
 109                 break;
 110         }
 111 }
 112
 113 bool OptionsModel::equals(const OptionsModel *model)
 114 {
 115         bool equal = true;
 116
 117         equal = equal && COMPARE_VAL(model, m_encoderType);
 118         equal = equal && COMPARE_VAL(model, m_encoderArch);
 119         equal = equal && COMPARE_VAL(model, m_encoderVariant);
 120         equal = equal && COMPARE_VAL(model, m_rcMode);
 121         equal = equal && COMPARE_VAL(model, m_bitrate);
 122         equal = equal && COMPARE_VAL(model, m_quantizer);
 123         equal = equal && COMPARE_STR(model, m_preset);
 124         equal = equal && COMPARE_STR(model, m_tune);
 125         equal = equal && COMPARE_STR(model, m_profile);
 126         equal = equal && COMPARE_STR(model, m_custom_encoder);
 127         equal = equal && COMPARE_STR(model, m_custom_avs2yuv);
 128
 129         return equal;
 130 }
 131
 132 bool OptionsModel::saveTemplate(const OptionsModel *model, const QString &name)
 133 {
 134         const QString templateName = name.simplified();
 135         const QString appDir = x264_data_path();
 136
 137         if(templateName.contains('\\') || templateName.contains('/'))
 138         {
 139                 return false;
 140         }
 141
 142         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 143         settings.beginGroup(templateName);
 144
 145         const bool okay = saveOptions(model, settings);
 146
 147         settings.endGroup();
 148         settings.sync();
 149
 150         return okay;
 151 }
 152
 153 bool OptionsModel::loadTemplate(OptionsModel *model, const QString &name)
 154 {
 155         const QString appDir = x264_data_path();
 156
 157         if(name.contains('\\') || name.contains('/'))
 158         {
 159                 return false;
 160         }
 161
 162         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 163
 164         settings.beginGroup(name);
 165         const bool okay = loadOptions(model, settings);
 166         settings.endGroup();
 167
 168         return okay;
 169 }
 170
 171 QMap<QString, OptionsModel*> OptionsModel::loadAllTemplates(const SysinfoModel *sysinfo)
 172 {
 173         QMap<QString, OptionsModel*> list;
 174         const QString appDir = x264_data_path();
 175         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 176         QStringList allTemplates = settings.childGroups();
 177
 178         while(!allTemplates.isEmpty())
 179         {
 180                 QString name = allTemplates.takeFirst();
 181                 if(!(name.contains('<') || name.contains('>') || name.contains('\\') || name.contains('/')))
 182                 {
 183                         OptionsModel *options = new OptionsModel(sysinfo);
 184                         if(loadTemplate(options, name))
 185                         {
 186                                 list.insert(name, options);
 187                                 continue;
 188                         }
 189                         MUTILS_DELETE(options);
 190                 }
 191         }
 192
 193         return list;
 194 }
 195
 196 bool OptionsModel::templateExists(const QString &name)
 197 {
 198         const QString appDir = x264_data_path();
 199         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 200         QStringList allGroups = settings.childGroups();
 201         return allGroups.contains(name, Qt::CaseInsensitive);
 202 }
 203
 204 bool OptionsModel::deleteTemplate(const QString &name)
 205 {
 206         const QString appDir = x264_data_path();
 207         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 208
 209         if(settings.childGroups().contains(name, Qt::CaseInsensitive))
 210         {
 211                 settings.remove(name);
 212                 return true;
 213         }
 214
 215         return false;
 216 }
 217
 218 bool OptionsModel::saveOptions(const OptionsModel *model, QSettings &settingsFile)
 219 {
 220         settingsFile.setValue(KEY_ENCODER_TYPE,    model->m_encoderType);
 221         settingsFile.setValue(KEY_ENCODER_ARCH,    model->m_encoderArch);
 222         settingsFile.setValue(KEY_ENCODER_VARIANT, model->m_encoderVariant);
 223         settingsFile.setValue(KEY_RATECTRL_MODE,   model->m_rcMode);
 224         settingsFile.setValue(KEY_TARGET_BITRATE,  model->m_bitrate);
 225         settingsFile.setValue(KEY_TARGET_QUANT,    model->m_quantizer);
 226         settingsFile.setValue(KEY_PRESET_NAME,     model->m_preset);
 227         settingsFile.setValue(KEY_TUNING_NAME,     model->m_tune);
 228         settingsFile.setValue(KEY_PROFILE_NAME,    model->m_profile);
 229         settingsFile.setValue(KEY_CUSTOM_ENCODER,  model->m_custom_encoder);
 230         settingsFile.setValue(KEY_CUSTOM_AVS2YUV,  model->m_custom_avs2yuv);
 231
 232         return true;
 233 }
 234
 235 bool OptionsModel::loadOptions(OptionsModel *model, QSettings &settingsFile)
 236 {
 237         fixTemplate(settingsFile); /*for backward compatibility*/
 238
 239         bool complete = true;
 240         if(!settingsFile.contains(KEY_ENCODER_TYPE))    complete = false;
 241         if(!settingsFile.contains(KEY_ENCODER_ARCH))    complete = false;
 242         if(!settingsFile.contains(KEY_ENCODER_VARIANT)) complete = false;
 243         if(!settingsFile.contains(KEY_RATECTRL_MODE))   complete = false;
 244         if(!settingsFile.contains(KEY_TARGET_BITRATE))  complete = false;
 245         if(!settingsFile.contains(KEY_TARGET_QUANT))    complete = false;
 246         if(!settingsFile.contains(KEY_PRESET_NAME))     complete = false;
 247         if(!settingsFile.contains(KEY_TUNING_NAME))     complete = false;
 248         if(!settingsFile.contains(KEY_PROFILE_NAME))    complete = false;
 249         if(!settingsFile.contains(KEY_CUSTOM_ENCODER))  complete = false;
 250         if(!settingsFile.contains(KEY_CUSTOM_AVS2YUV))  complete = false;
 251
 252         if(complete)
 253         {
 254                 model->setEncType        (static_cast<OptionsModel::EncType>   (settingsFile.value(KEY_ENCODER_TYPE,    model->m_encoderType)   .toInt()));
 255                 model->setEncArch        (static_cast<OptionsModel::EncArch>   (settingsFile.value(KEY_ENCODER_ARCH,    model->m_encoderArch)   .toInt()));
 256                 model->setEncVariant     (static_cast<OptionsModel::EncVariant>(settingsFile.value(KEY_ENCODER_VARIANT, model->m_encoderVariant).toInt()));
 257                 model->setRCMode         (static_cast<OptionsModel::RCMode>    (settingsFile.value(KEY_RATECTRL_MODE,   model->m_rcMode)        .toInt()));
 258                 model->setBitrate        (settingsFile.value(KEY_TARGET_BITRATE, model->m_bitrate)       .toUInt()  );
 259                 model->setQuantizer      (settingsFile.value(KEY_TARGET_QUANT,   model->m_quantizer)     .toDouble());
 260                 model->setPreset         (settingsFile.value(KEY_PRESET_NAME,    model->m_preset)        .toString());
 261                 model->setTune           (settingsFile.value(KEY_TUNING_NAME,    model->m_tune)          .toString());
 262                 model->setProfile        (settingsFile.value(KEY_PROFILE_NAME,   model->m_profile)       .toString());
 263                 model->setCustomEncParams(settingsFile.value(KEY_CUSTOM_ENCODER, model->m_custom_encoder).toString());
 264                 model->setCustomAvs2YUV  (settingsFile.value(KEY_CUSTOM_AVS2YUV, model->m_custom_avs2yuv).toString());
 265         }
 266
 267         return complete;
 268 }
 269
 270 void OptionsModel::fixTemplate(QSettings &settingsFile)
 271 {
 272         if(!(settingsFile.contains(KEY_ENCODER_TYPE) || settingsFile.contains(KEY_ENCODER_ARCH) || settingsFile.contains(KEY_ENCODER_VARIANT)))
 273         {
 274                 settingsFile.setValue(KEY_ENCODER_TYPE,    OptionsModel::EncType_X264);
 275                 settingsFile.setValue(KEY_ENCODER_ARCH,    OptionsModel::EncArch_x32);
 276                 settingsFile.setValue(KEY_ENCODER_VARIANT, OptionsModel::EncVariant_LoBit);
 277         }
 278
 279         static const char *legacyKey[] = { "custom_params", "custom_params_x264", NULL };
 280         for(int i = 0; legacyKey[i]; i++)
 281         {
 282                 if(settingsFile.contains(legacyKey[i]))
 283                 {
 284                         settingsFile.setValue(KEY_CUSTOM_ENCODER, settingsFile.value(legacyKey[i]));
 285                         settingsFile.remove(legacyKey[i]);
 286                 }
 287         }
 288
 289         if(settingsFile.value(KEY_PROFILE_NAME).toString().compare("auto", Qt::CaseInsensitive) == 0)
 290         {
 291                 settingsFile.setValue(KEY_PROFILE_NAME, QString::fromLatin1(OptionsModel::PROFILE_UNRESTRICTED));
 292         }
 293         if(settingsFile.value(KEY_TUNING_NAME).toString().compare("none", Qt::CaseInsensitive) == 0)
 294         {
 295                 settingsFile.setValue(KEY_TUNING_NAME, QString::fromLatin1(OptionsModel::TUNING_UNSPECIFIED));
 296         }
 297 }