src/model_options.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Simple x264 Launcher
   3 // Copyright (C) 2004-2014 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::PROFILE_UNRESTRICTED = "<Unrestricted>";
  50
  51 OptionsModel::OptionsModel(const SysinfoModel *sysinfo)
  52 {
  53         m_encoderType = EncType_X264;
  54         m_encoderArch = sysinfo->hasX64Support() ? EncArch_x64 : EncArch_x32;
  55         m_encoderVariant = EncVariant_LoBit;
  56         m_rcMode = RCMode_CRF;
  57         m_bitrate = 1200;
  58         m_quantizer = 22;
  59         m_preset = "Medium";
  60         m_tune = "None";
  61         m_profile = QString::fromLatin1(OptionsModel::PROFILE_UNRESTRICTED);
  62         m_custom_encoder = QString();
  63         m_custom_avs2yuv = QString();
  64 }
  65
  66 OptionsModel::OptionsModel(const OptionsModel &rhs)
  67 {
  68         ASSIGN_FROM(rhs, m_encoderType);
  69         ASSIGN_FROM(rhs, m_encoderArch);
  70         ASSIGN_FROM(rhs, m_encoderVariant);
  71         ASSIGN_FROM(rhs, m_rcMode);
  72         ASSIGN_FROM(rhs, m_bitrate);
  73         ASSIGN_FROM(rhs, m_quantizer);
  74         ASSIGN_FROM(rhs, m_preset);
  75         ASSIGN_FROM(rhs, m_tune);
  76         ASSIGN_FROM(rhs, m_profile);
  77         ASSIGN_FROM(rhs, m_custom_encoder);
  78         ASSIGN_FROM(rhs, m_custom_avs2yuv);
  79 }
  80
  81 OptionsModel::~OptionsModel(void)
  82 {
  83 }
  84
  85 QString OptionsModel::rcMode2String(RCMode mode)
  86 {
  87         switch(mode)
  88         {
  89         case RCMode_CRF:
  90                 return QObject::tr("CRF");
  91                 break;
  92         case RCMode_CQ:
  93                 return QObject::tr("CQ");
  94                 break;
  95         case RCMode_2Pass:
  96                 return QObject::tr("2-Pass");
  97                 break;
  98         case RCMode_ABR:
  99                 return QObject::tr("ABR");
 100                 break;
 101         default:
 102                 return QString();
 103                 break;
 104         }
 105 }
 106
 107 bool OptionsModel::equals(const OptionsModel *model)
 108 {
 109         bool equal = true;
 110
 111         equal = equal && COMPARE_VAL(model, m_encoderType);
 112         equal = equal && COMPARE_VAL(model, m_encoderArch);
 113         equal = equal && COMPARE_VAL(model, m_encoderVariant);
 114         equal = equal && COMPARE_VAL(model, m_rcMode);
 115         equal = equal && COMPARE_VAL(model, m_bitrate);
 116         equal = equal && COMPARE_VAL(model, m_quantizer);
 117         equal = equal && COMPARE_STR(model, m_preset);
 118         equal = equal && COMPARE_STR(model, m_tune);
 119         equal = equal && COMPARE_STR(model, m_profile);
 120         equal = equal && COMPARE_STR(model, m_custom_encoder);
 121         equal = equal && COMPARE_STR(model, m_custom_avs2yuv);
 122
 123         return equal;
 124 }
 125
 126 bool OptionsModel::saveTemplate(OptionsModel *model, const QString &name)
 127 {
 128         const QString templateName = name.simplified();
 129         const QString appDir = x264_data_path();
 130
 131         if(templateName.contains('\\') || templateName.contains('/'))
 132         {
 133                 return false;
 134         }
 135
 136         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 137         settings.beginGroup(templateName);
 138
 139         settings.setValue(KEY_ENCODER_TYPE,    model->m_encoderType);
 140         settings.setValue(KEY_ENCODER_ARCH,    model->m_encoderArch);
 141         settings.setValue(KEY_ENCODER_VARIANT, model->m_encoderVariant);
 142         settings.setValue(KEY_RATECTRL_MODE,   model->m_rcMode);
 143         settings.setValue(KEY_TARGET_BITRATE,  model->m_bitrate);
 144         settings.setValue(KEY_TARGET_QUANT,    model->m_quantizer);
 145         settings.setValue(KEY_PRESET_NAME,     model->m_preset);
 146         settings.setValue(KEY_TUNING_NAME,     model->m_tune);
 147         settings.setValue(KEY_PROFILE_NAME,    model->m_profile);
 148         settings.setValue(KEY_CUSTOM_ENCODER,  model->m_custom_encoder);
 149         settings.setValue(KEY_CUSTOM_AVS2YUV,  model->m_custom_avs2yuv);
 150
 151         settings.endGroup();
 152         settings.sync();
 153
 154         return true;
 155 }
 156
 157 bool OptionsModel::loadTemplate(OptionsModel *model, const QString &name)
 158 {
 159         const QString appDir = x264_data_path();
 160
 161         if(name.contains('\\') || name.contains('/'))
 162         {
 163                 return false;
 164         }
 165
 166         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 167         settings.beginGroup(name);
 168
 169         //For backward-compatibility
 170         static const char *legacyKey[] = { "custom_params", "custom_params_x264", NULL };
 171         for(int i = 0; legacyKey[i]; i++)
 172         {
 173                 if(settings.contains(legacyKey[i]))
 174                 {
 175                         settings.setValue(KEY_CUSTOM_ENCODER, settings.value(legacyKey[i]));
 176                         settings.remove(legacyKey[i]);
 177                         settings.sync();
 178                 }
 179         }
 180
 181         bool complete = true;
 182
 183         if(!settings.contains(KEY_ENCODER_TYPE))    complete = false;
 184         if(!settings.contains(KEY_ENCODER_ARCH))    complete = false;
 185         if(!settings.contains(KEY_ENCODER_VARIANT)) complete = false;
 186         if(!settings.contains(KEY_RATECTRL_MODE))   complete = false;
 187         if(!settings.contains(KEY_TARGET_BITRATE))  complete = false;
 188         if(!settings.contains(KEY_TARGET_QUANT))    complete = false;
 189         if(!settings.contains(KEY_PRESET_NAME))     complete = false;
 190         if(!settings.contains(KEY_TUNING_NAME))     complete = false;
 191         if(!settings.contains(KEY_PROFILE_NAME))    complete = false;
 192         if(!settings.contains(KEY_CUSTOM_ENCODER))  complete = false;
 193         if(!settings.contains(KEY_CUSTOM_AVS2YUV))  complete = false;
 194
 195         if(complete)
 196         {
 197                 model->setEncType        (static_cast<OptionsModel::EncType>   (settings.value(KEY_ENCODER_TYPE,    model->m_encoderType)   .toInt()));
 198                 model->setEncArch        (static_cast<OptionsModel::EncArch>   (settings.value(KEY_ENCODER_ARCH,    model->m_encoderArch)   .toInt()));
 199                 model->setEncVariant     (static_cast<OptionsModel::EncVariant>(settings.value(KEY_ENCODER_VARIANT, model->m_encoderVariant).toInt()));
 200                 model->setRCMode         (static_cast<OptionsModel::RCMode>    (settings.value(KEY_RATECTRL_MODE,   model->m_rcMode)        .toInt()));
 201                 model->setBitrate        (settings.value(KEY_TARGET_BITRATE, model->m_bitrate).toUInt()         );
 202                 model->setQuantizer      (settings.value(KEY_TARGET_QUANT,   model->m_quantizer).toDouble()     );
 203                 model->setPreset         (settings.value(KEY_PRESET_NAME,    model->m_preset).toString()        );
 204                 model->setTune           (settings.value(KEY_TUNING_NAME,    model->m_tune).toString()          );
 205                 model->setProfile        (settings.value(KEY_PROFILE_NAME,   model->m_profile).toString()       );
 206                 model->setCustomEncParams(settings.value(KEY_CUSTOM_ENCODER, model->m_custom_encoder).toString());
 207                 model->setCustomAvs2YUV  (settings.value(KEY_CUSTOM_AVS2YUV, model->m_custom_avs2yuv).toString());
 208         }
 209
 210         settings.endGroup();
 211         return complete;
 212 }
 213
 214 QMap<QString, OptionsModel*> OptionsModel::loadAllTemplates(const SysinfoModel *sysinfo)
 215 {
 216         QMap<QString, OptionsModel*> list;
 217         const QString appDir = x264_data_path();
 218         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 219         QStringList allTemplates = settings.childGroups();
 220
 221         while(!allTemplates.isEmpty())
 222         {
 223                 QString name = allTemplates.takeFirst();
 224                 if(!(name.contains('<') || name.contains('>') || name.contains('\\') || name.contains('/')))
 225                 {
 226                         OptionsModel *options = new OptionsModel(sysinfo);
 227                         if(loadTemplate(options, name))
 228                         {
 229                                 list.insert(name, options);
 230                                 continue;
 231                         }
 232                         X264_DELETE(options);
 233                 }
 234         }
 235
 236         return list;
 237 }
 238
 239 bool OptionsModel::templateExists(const QString &name)
 240 {
 241         const QString appDir = x264_data_path();
 242         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 243         QStringList allGroups = settings.childGroups();
 244         return allGroups.contains(name, Qt::CaseInsensitive);
 245 }
 246
 247 bool OptionsModel::deleteTemplate(const QString &name)
 248 {
 249         const QString appDir = x264_data_path();
 250         QSettings settings(QString("%1/templates.ini").arg(appDir), QSettings::IniFormat);
 251
 252         if(settings.childGroups().contains(name, Qt::CaseInsensitive))
 253         {
 254                 settings.remove(name);
 255                 return true;
 256         }
 257
 258         return false;
 259 }