src/Registry_Encoder.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2013 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 "Registry_Encoder.h"
  23
  24 #include "Global.h"
  25 #include "Model_Settings.h"
  26 #include "Encoder_AAC.h"
  27 #include "Encoder_AAC_FHG.h"
  28 #include "Encoder_AAC_QAAC.h"
  29 #include "Encoder_AC3.h"
  30 #include "Encoder_DCA.h"
  31 #include "Encoder_FLAC.h"
  32 #include "Encoder_MP3.h"
  33 #include "Encoder_Vorbis.h"
  34 #include "Encoder_Opus.h"
  35 #include "Encoder_Wave.h"
  36
  37 #define IS_VBR(RC_MODE) ((RC_MODE) == SettingsModel::VBRMode)
  38 #define IS_ABR(RC_MODE) ((RC_MODE) == SettingsModel::ABRMode)
  39 #define IS_CBR(RC_MODE) ((RC_MODE) == SettingsModel::CBRMode)
  40
  41 ////////////////////////////////////////////////////////////
  42 // Create encoder instance
  43 ////////////////////////////////////////////////////////////
  44
  45 AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling)
  46 {
  47         int rcMode = -1;
  48         AbstractEncoder *encoder =  NULL;
  49         *nativeResampling = false;
  50
  51         //Create new encoder instance and apply encoder-specific settings
  52         switch(encoderId)
  53         {
  54         /*-------- MP3Encoder /*--------*/
  55         case SettingsModel::MP3Encoder:
  56                 {
  57                         MP3Encoder *mp3Encoder = new MP3Encoder();
  58                         mp3Encoder->setAlgoQuality(settings->lameAlgoQuality());
  59                         if(settings->bitrateManagementEnabled())
  60                         {
  61                                 mp3Encoder->setBitrateLimits(settings->bitrateManagementMinRate(), settings->bitrateManagementMaxRate());
  62                         }
  63                         if(settings->samplingRate() > 0)
  64                         {
  65                                 mp3Encoder->setSamplingRate(SettingsModel::samplingRates[settings->samplingRate()]);
  66                                 *nativeResampling = true;
  67                         }
  68                         mp3Encoder->setChannelMode(settings->lameChannelMode());
  69                         encoder = mp3Encoder;
  70                 }
  71                 break;
  72         /*-------- VorbisEncoder /*--------*/
  73         case SettingsModel::VorbisEncoder:
  74                 {
  75                         VorbisEncoder *vorbisEncoder = new VorbisEncoder();
  76                         if(settings->bitrateManagementEnabled())
  77                         {
  78                                 vorbisEncoder->setBitrateLimits(settings->bitrateManagementMinRate(), settings->bitrateManagementMaxRate());
  79                         }
  80                         if(settings->samplingRate() > 0)
  81                         {
  82                                 vorbisEncoder->setSamplingRate(SettingsModel::samplingRates[settings->samplingRate()]);
  83                                 *nativeResampling = true;
  84                         }
  85                         encoder = vorbisEncoder;
  86                 }
  87                 break;
  88         /*-------- AACEncoder /*--------*/
  89         case SettingsModel::AACEncoder:
  90                 {
  91                         switch(getAacEncoder())
  92                         {
  93                         case SettingsModel::AAC_ENCODER_QAAC:
  94                                 {
  95                                         QAACEncoder *aacEncoder = new QAACEncoder();
  96                                         aacEncoder->setProfile(settings->aacEncProfile());
  97                                         encoder = aacEncoder;
  98                                 }
  99                                 break;
 100                         case SettingsModel::AAC_ENCODER_FHG:
 101                                 {
 102                                         FHGAACEncoder *aacEncoder = new FHGAACEncoder();
 103                                         aacEncoder->setProfile(settings->aacEncProfile());
 104                                         encoder = aacEncoder;
 105                                 }
 106                                 break;
 107                         case SettingsModel::AAC_ENCODER_NERO:
 108                                 {
 109                                         AACEncoder *aacEncoder = new AACEncoder();
 110                                         aacEncoder->setEnable2Pass(settings->neroAACEnable2Pass());
 111                                         aacEncoder->setProfile(settings->aacEncProfile());
 112                                         encoder = aacEncoder;
 113                                 }
 114                                 break;
 115                         default:
 116                                 throw "makeEncoder(): Unknown AAC encoder specified!";
 117                                 break;
 118                         }
 119                 }
 120                 break;
 121         /*-------- AC3Encoder /*--------*/
 122         case SettingsModel::AC3Encoder:
 123                 {
 124                         AC3Encoder *ac3Encoder = new AC3Encoder();
 125                         ac3Encoder->setAudioCodingMode(settings->aftenAudioCodingMode());
 126                         ac3Encoder->setDynamicRangeCompression(settings->aftenDynamicRangeCompression());
 127                         ac3Encoder->setExponentSearchSize(settings->aftenExponentSearchSize());
 128                         ac3Encoder->setFastBitAllocation(settings->aftenFastBitAllocation());
 129                         encoder = ac3Encoder;
 130                 }
 131                 break;
 132         /*-------- FLACEncoder /*--------*/
 133         case SettingsModel::FLACEncoder:
 134                 {
 135                         FLACEncoder *flacEncoder = new FLACEncoder();
 136                         encoder = flacEncoder;
 137                 }
 138                 break;
 139         /*-------- OpusEncoder --------*/
 140         case SettingsModel::OpusEncoder:
 141                 {
 142                         OpusEncoder *opusEncoder = new OpusEncoder();
 143                         opusEncoder->setOptimizeFor(settings->opusOptimizeFor());
 144                         opusEncoder->setEncodeComplexity(settings->opusComplexity());
 145                         opusEncoder->setFrameSize(settings->opusFramesize());
 146                         encoder = opusEncoder;
 147                 }
 148                 break;
 149         /*-------- DCAEncoder --------*/
 150         case SettingsModel::DCAEncoder:
 151                 {
 152                         DCAEncoder *dcaEncoder = new DCAEncoder();
 153                         encoder = dcaEncoder;
 154                 }
 155                 break;
 156         /*-------- PCMEncoder --------*/
 157         case SettingsModel::PCMEncoder:
 158                 {
 159                         WaveEncoder *waveEncoder = new WaveEncoder();
 160                         encoder = waveEncoder;
 161                 }
 162                 break;
 163         /*-------- default --------*/
 164         default:
 165                 throw "Unsupported encoder!";
 166         }
 167
 168         //Sanity checking
 169         if(!encoder)
 170         {
 171                 throw "No encoder instance has been assigend!";
 172         }
 173
 174         //Apply common settings
 175         encoder->setRCMode(rcMode = loadEncoderMode(settings, encoderId));
 176         encoder->setCustomParams(loadEncoderCustomParams(settings, encoderId));
 177         encoder->setBitrate(loadEncoderValue(settings, encoderId, rcMode));
 178
 179         return encoder;
 180 }
 181
 182 ////////////////////////////////////////////////////////////
 183 // Get encoder info
 184 ////////////////////////////////////////////////////////////
 185
 186 const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId)
 187 {
 188         const AbstractEncoderInfo *info = NULL;
 189
 190         switch(encoderId)
 191         {
 192                 case SettingsModel::MP3Encoder:    info = MP3Encoder::getEncoderInfo();    break;
 193                 case SettingsModel::VorbisEncoder: info = VorbisEncoder::getEncoderInfo(); break;
 194                 case SettingsModel::AC3Encoder:    info = AC3Encoder::getEncoderInfo();    break;
 195                 case SettingsModel::FLACEncoder:   info = FLACEncoder::getEncoderInfo();   break;
 196                 case SettingsModel::OpusEncoder:   info = OpusEncoder::getEncoderInfo();   break;
 197                 case SettingsModel::DCAEncoder:    info = DCAEncoder::getEncoderInfo();    break;
 198                 case SettingsModel::PCMEncoder:    info = WaveEncoder::getEncoderInfo();   break;
 199                 case SettingsModel::AACEncoder:
 200                         switch(getAacEncoder())
 201                         {
 202                                 case SettingsModel::AAC_ENCODER_QAAC: info = QAACEncoder::getEncoderInfo();   break;
 203                                 case SettingsModel::AAC_ENCODER_FHG:  info = FHGAACEncoder::getEncoderInfo(); break;
 204                                 case SettingsModel::AAC_ENCODER_NERO: info = AACEncoder::getEncoderInfo();    break;
 205                                 default: throw "Unknown AAC encoder specified!";
 206                         }
 207                         break;
 208                 default: throw "Unsupported encoder!";
 209         }
 210
 211         //Sanity checking
 212         if(!info)
 213         {
 214                 throw "No encoder instance has been assigend!";
 215         }
 216
 217         return info;
 218 }
 219
 220 ////////////////////////////////////////////////////////////
 221 // Load/store encoder RC mode
 222 ////////////////////////////////////////////////////////////
 223
 224 #define STORE_MODE(ENCODER_ID, RC_MODE) do \
 225 { \
 226         settings->compressionRCMode##ENCODER_ID(RC_MODE); \
 227 } \
 228 while(0)
 229
 230 #define LOAD_MODE(RC_MODE, ENCODER_ID) do \
 231 { \
 232         (RC_MODE) = settings->compressionRCMode##ENCODER_ID(); \
 233 } \
 234 while(0)
 235
 236 void EncoderRegistry::saveEncoderMode(SettingsModel *settings, const int encoderId, const int rcMode)
 237 {
 238         //Sanity checking
 239         if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
 240         {
 241                 throw "Unknown rate-control mode!";
 242         }
 243
 244         //Store the encoder bitrate/quality value
 245         switch(encoderId)
 246         {
 247                 case SettingsModel::MP3Encoder:    STORE_MODE(LAME,    rcMode); break;
 248                 case SettingsModel::VorbisEncoder: STORE_MODE(OggEnc,  rcMode); break;
 249                 case SettingsModel::AACEncoder:    STORE_MODE(AacEnc,  rcMode); break;
 250                 case SettingsModel::AC3Encoder:    STORE_MODE(Aften,   rcMode); break;
 251                 case SettingsModel::FLACEncoder:   STORE_MODE(FLAC,    rcMode); break;
 252                 case SettingsModel::OpusEncoder:   STORE_MODE(OpusEnc, rcMode); break;
 253                 case SettingsModel::DCAEncoder:    STORE_MODE(DcaEnc,  rcMode); break;
 254                 case SettingsModel::PCMEncoder:    STORE_MODE(Wave,    rcMode); break;
 255                 default: throw "Unsupported encoder!";
 256         }
 257 }
 258
 259 int EncoderRegistry::loadEncoderMode(const SettingsModel *settings, const int encoderId)
 260 {
 261         int rcMode = -1;
 262
 263         //Store the encoder bitrate/quality value
 264         switch(encoderId)
 265         {
 266                 case SettingsModel::MP3Encoder:    LOAD_MODE(rcMode, LAME);    break;
 267                 case SettingsModel::VorbisEncoder: LOAD_MODE(rcMode, OggEnc);  break;
 268                 case SettingsModel::AACEncoder:    LOAD_MODE(rcMode, AacEnc);  break;
 269                 case SettingsModel::AC3Encoder:    LOAD_MODE(rcMode, Aften);   break;
 270                 case SettingsModel::FLACEncoder:   LOAD_MODE(rcMode, FLAC);    break;
 271                 case SettingsModel::OpusEncoder:   LOAD_MODE(rcMode, OpusEnc); break;
 272                 case SettingsModel::DCAEncoder:    LOAD_MODE(rcMode, DcaEnc);  break;
 273                 case SettingsModel::PCMEncoder:    LOAD_MODE(rcMode, Wave);    break;
 274                 default: throw "Unsupported encoder!";
 275         }
 276
 277         return rcMode;
 278 }
 279
 280 ////////////////////////////////////////////////////////////
 281 // Load/store encoder bitrate/quality value
 282 ////////////////////////////////////////////////////////////
 283
 284 #define STORE_VALUE(ENCODER_ID, RC_MODE, VALUE) do \
 285 { \
 286         if(IS_VBR(RC_MODE)) settings->compressionVbrQuality##ENCODER_ID(VALUE); \
 287         if(IS_ABR(RC_MODE)) settings->compressionAbrBitrate##ENCODER_ID(VALUE); \
 288         if(IS_CBR(RC_MODE)) settings->compressionCbrBitrate##ENCODER_ID(VALUE); \
 289 } \
 290 while(0)
 291
 292 #define LOAD_VALUE(VALUE, ENCODER_ID, RC_MODE) do \
 293 { \
 294         if(IS_VBR(RC_MODE)) (VALUE) = settings->compressionVbrQuality##ENCODER_ID(); \
 295         if(IS_ABR(RC_MODE)) (VALUE) = settings->compressionAbrBitrate##ENCODER_ID(); \
 296         if(IS_CBR(RC_MODE)) (VALUE) = settings->compressionCbrBitrate##ENCODER_ID(); \
 297 } \
 298 while(0)
 299
 300 void EncoderRegistry::saveEncoderValue(SettingsModel *settings, const int encoderId, const int rcMode, const int value)
 301 {
 302         //Sanity checking
 303         if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
 304         {
 305                 throw "Unknown rate-control mode!";
 306         }
 307
 308         //Store the encoder bitrate/quality value
 309         switch(encoderId)
 310         {
 311                 case SettingsModel::MP3Encoder:    STORE_VALUE(LAME,    rcMode, value); break;
 312                 case SettingsModel::VorbisEncoder: STORE_VALUE(OggEnc,  rcMode, value); break;
 313                 case SettingsModel::AACEncoder:    STORE_VALUE(AacEnc,  rcMode, value); break;
 314                 case SettingsModel::AC3Encoder:    STORE_VALUE(Aften,   rcMode, value); break;
 315                 case SettingsModel::FLACEncoder:   STORE_VALUE(FLAC,    rcMode, value); break;
 316                 case SettingsModel::OpusEncoder:   STORE_VALUE(OpusEnc, rcMode, value); break;
 317                 case SettingsModel::DCAEncoder:    STORE_VALUE(DcaEnc,  rcMode, value); break;
 318                 case SettingsModel::PCMEncoder:    STORE_VALUE(Wave,    rcMode, value); break;
 319                 default: throw "Unsupported encoder!";
 320         }
 321 }
 322
 323 int EncoderRegistry::loadEncoderValue(const SettingsModel *settings, const int encoderId, const int rcMode)
 324 {
 325         int value = INT_MAX;
 326
 327         //Sanity checking
 328         if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
 329         {
 330                 throw "Unknown rate-control mode!";
 331         }
 332
 333         //Load the encoder bitrate/quality value
 334         switch(encoderId)
 335         {
 336                 case SettingsModel::MP3Encoder:    LOAD_VALUE(value, LAME,    rcMode); break;
 337                 case SettingsModel::VorbisEncoder: LOAD_VALUE(value, OggEnc,  rcMode); break;
 338                 case SettingsModel::AACEncoder:    LOAD_VALUE(value, AacEnc,  rcMode); break;
 339                 case SettingsModel::AC3Encoder:    LOAD_VALUE(value, Aften,   rcMode); break;
 340                 case SettingsModel::FLACEncoder:   LOAD_VALUE(value, FLAC,    rcMode); break;
 341                 case SettingsModel::OpusEncoder:   LOAD_VALUE(value, OpusEnc, rcMode); break;
 342                 case SettingsModel::DCAEncoder:    LOAD_VALUE(value, DcaEnc,  rcMode); break;
 343                 case SettingsModel::PCMEncoder:    LOAD_VALUE(value, Wave,    rcMode); break;
 344                 default: throw "Unsupported encoder!";
 345         }
 346
 347         return value;
 348 }
 349
 350 ////////////////////////////////////////////////////////////
 351 // Load/store encoder custom parameters
 352 ////////////////////////////////////////////////////////////
 353
 354 #define STORE_PARAMS(ENCODER_ID, PARAMS) do \
 355 { \
 356         settings->customParameters##ENCODER_ID(PARAMS); \
 357 } \
 358 while(0)
 359
 360 #define LOAD_PARAMS(PARAMS, ENCODER_ID) do \
 361 { \
 362         (PARAMS) = settings->customParameters##ENCODER_ID(); \
 363 } \
 364 while(0)
 365
 366 void EncoderRegistry::saveEncoderCustomParams(SettingsModel *settings, const int encoderId, const QString params)
 367 {
 368         //Store the encoder bitrate/quality value
 369         switch(encoderId)
 370         {
 371                 case SettingsModel::MP3Encoder:    STORE_PARAMS(LAME,    params.trimmed()); break;
 372                 case SettingsModel::VorbisEncoder: STORE_PARAMS(OggEnc,  params.trimmed()); break;
 373                 case SettingsModel::AACEncoder:    STORE_PARAMS(AacEnc,  params.trimmed()); break;
 374                 case SettingsModel::AC3Encoder:    STORE_PARAMS(Aften,   params.trimmed()); break;
 375                 case SettingsModel::FLACEncoder:   STORE_PARAMS(FLAC,    params.trimmed()); break;
 376                 case SettingsModel::OpusEncoder:   STORE_PARAMS(OpusEnc, params.trimmed()); break;
 377                 case SettingsModel::DCAEncoder:    STORE_PARAMS(DcaEnc,  params.trimmed()); break;
 378                 case SettingsModel::PCMEncoder:    STORE_PARAMS(Wave,    params.trimmed()); break;
 379                 default: throw "Unsupported encoder!";
 380         }
 381 }
 382
 383 QString EncoderRegistry::loadEncoderCustomParams(const SettingsModel *settings, const int encoderId)
 384 {
 385         QString params;
 386
 387         //Load the encoder bitrate/quality value
 388         switch(encoderId)
 389         {
 390                 case SettingsModel::MP3Encoder:    LOAD_PARAMS(params, LAME);    break;
 391                 case SettingsModel::VorbisEncoder: LOAD_PARAMS(params, OggEnc);  break;
 392                 case SettingsModel::AACEncoder:    LOAD_PARAMS(params, AacEnc);  break;
 393                 case SettingsModel::AC3Encoder:    LOAD_PARAMS(params, Aften);   break;
 394                 case SettingsModel::FLACEncoder:   LOAD_PARAMS(params, FLAC);    break;
 395                 case SettingsModel::OpusEncoder:   LOAD_PARAMS(params, OpusEnc); break;
 396                 case SettingsModel::DCAEncoder:    LOAD_PARAMS(params, DcaEnc);  break;
 397                 case SettingsModel::PCMEncoder:    LOAD_PARAMS(params, Wave);    break;
 398                 default: throw "Unsupported encoder!";
 399         }
 400
 401         return params;
 402 }
 403
 404 ////////////////////////////////////////////////////////////
 405 // Reset encoder settings
 406 ////////////////////////////////////////////////////////////
 407
 408 #define RESET_SETTING(OBJ,NAME) do \
 409 { \
 410         (OBJ)->NAME((OBJ)->NAME##Default()); \
 411 } \
 412 while(0)
 413
 414 void EncoderRegistry::resetAllEncoders(SettingsModel *settings)
 415 {
 416         RESET_SETTING(settings, compressionAbrBitrateAacEnc);
 417         RESET_SETTING(settings, compressionAbrBitrateAften);
 418         RESET_SETTING(settings, compressionAbrBitrateDcaEnc);
 419         RESET_SETTING(settings, compressionAbrBitrateFLAC);
 420         RESET_SETTING(settings, compressionAbrBitrateLAME);
 421         RESET_SETTING(settings, compressionAbrBitrateOggEnc);
 422         RESET_SETTING(settings, compressionAbrBitrateOpusEnc);
 423         RESET_SETTING(settings, compressionAbrBitrateWave);
 424
 425         RESET_SETTING(settings, compressionCbrBitrateAacEnc);
 426         RESET_SETTING(settings, compressionCbrBitrateAften);
 427         RESET_SETTING(settings, compressionCbrBitrateDcaEnc);
 428         RESET_SETTING(settings, compressionCbrBitrateFLAC);
 429         RESET_SETTING(settings, compressionCbrBitrateLAME);
 430         RESET_SETTING(settings, compressionCbrBitrateOggEnc);
 431         RESET_SETTING(settings, compressionCbrBitrateOpusEnc);
 432         RESET_SETTING(settings, compressionCbrBitrateWave);
 433
 434         RESET_SETTING(settings, compressionRCModeAacEnc);
 435         RESET_SETTING(settings, compressionRCModeAften);
 436         RESET_SETTING(settings, compressionRCModeDcaEnc);
 437         RESET_SETTING(settings, compressionRCModeFLAC);
 438         RESET_SETTING(settings, compressionRCModeLAME);
 439         RESET_SETTING(settings, compressionRCModeOggEnc);
 440         RESET_SETTING(settings, compressionRCModeOpusEnc);
 441         RESET_SETTING(settings, compressionRCModeWave);
 442
 443         RESET_SETTING(settings, compressionVbrQualityAacEnc);
 444         RESET_SETTING(settings, compressionVbrQualityAften);
 445         RESET_SETTING(settings, compressionVbrQualityDcaEnc);
 446         RESET_SETTING(settings, compressionVbrQualityFLAC);
 447         RESET_SETTING(settings, compressionVbrQualityLAME);
 448         RESET_SETTING(settings, compressionVbrQualityOggEnc);
 449         RESET_SETTING(settings, compressionVbrQualityOpusEnc);
 450         RESET_SETTING(settings, compressionVbrQualityWave);
 451 }
 452
 453 ////////////////////////////////////////////////////////////
 454 // Static Functions
 455 ////////////////////////////////////////////////////////////
 456
 457 int EncoderRegistry::getAacEncoder(void)
 458 {
 459         if(lamexp_check_tool("qaac.exe") && lamexp_check_tool("libsoxrate.dll"))
 460         {
 461                 return SettingsModel::AAC_ENCODER_QAAC;
 462         }
 463         else if(lamexp_check_tool("fhgaacenc.exe") && lamexp_check_tool("enc_fhgaac.dll") && lamexp_check_tool("nsutil.dll") && lamexp_check_tool("libmp4v2.dll"))
 464         {
 465                 return SettingsModel::AAC_ENCODER_FHG;
 466         }
 467         else if(lamexp_check_tool("neroAacEnc.exe") && lamexp_check_tool("neroAacDec.exe") && lamexp_check_tool("neroAacTag.exe"))
 468         {
 469                 return SettingsModel::AAC_ENCODER_NERO;
 470         }
 471         else
 472         {
 473                 return SettingsModel::AAC_ENCODER_NONE;
 474         }
 475 }