src/Registry_Encoder.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   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, but always including the *additional*
   9 // restrictions defined in the "License.txt" file.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this program; if not, write to the Free Software Foundation, Inc.,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 // http://www.gnu.org/licenses/gpl-2.0.txt
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #include "Registry_Encoder.h"
  24
  25 #include "Global.h"
  26 #include "Model_Settings.h"
  27 #include "Encoder_AAC.h"
  28 #include "Encoder_AAC_FHG.h"
  29 #include "Encoder_AAC_FDK.h"
  30 #include "Encoder_AAC_QAAC.h"
  31 #include "Encoder_AC3.h"
  32 #include "Encoder_DCA.h"
  33 #include "Encoder_FLAC.h"
  34 #include "Encoder_MP3.h"
  35 #include "Encoder_Vorbis.h"
  36 #include "Encoder_Opus.h"
  37 #include "Encoder_MAC.h"
  38 #include "Encoder_Wave.h"
  39
  40 #define IS_VBR(RC_MODE) ((RC_MODE) == SettingsModel::VBRMode)
  41 #define IS_ABR(RC_MODE) ((RC_MODE) == SettingsModel::ABRMode)
  42 #define IS_CBR(RC_MODE) ((RC_MODE) == SettingsModel::CBRMode)
  43
  44 ////////////////////////////////////////////////////////////
  45 // Create encoder instance
  46 ////////////////////////////////////////////////////////////
  47
  48 AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling)
  49 {
  50         int rcMode = -1;
  51         AbstractEncoder *encoder =  NULL;
  52         *nativeResampling = false;
  53
  54         //Create new encoder instance and apply encoder-specific settings
  55         switch(encoderId)
  56         {
  57         /*-------- MP3Encoder /*--------*/
  58         case SettingsModel::MP3Encoder:
  59                 {
  60                         MP3Encoder *mp3Encoder = new MP3Encoder();
  61                         mp3Encoder->setAlgoQuality(settings->lameAlgoQuality());
  62                         if(settings->bitrateManagementEnabled())
  63                         {
  64                                 mp3Encoder->setBitrateLimits(settings->bitrateManagementMinRate(), settings->bitrateManagementMaxRate());
  65                         }
  66                         if(settings->samplingRate() > 0)
  67                         {
  68                                 mp3Encoder->setSamplingRate(SettingsModel::samplingRates[settings->samplingRate()]);
  69                                 *nativeResampling = true;
  70                         }
  71                         mp3Encoder->setChannelMode(settings->lameChannelMode());
  72                         encoder = mp3Encoder;
  73                 }
  74                 break;
  75         /*-------- VorbisEncoder /*--------*/
  76         case SettingsModel::VorbisEncoder:
  77                 {
  78                         VorbisEncoder *vorbisEncoder = new VorbisEncoder();
  79                         if(settings->bitrateManagementEnabled())
  80                         {
  81                                 vorbisEncoder->setBitrateLimits(settings->bitrateManagementMinRate(), settings->bitrateManagementMaxRate());
  82                         }
  83                         if(settings->samplingRate() > 0)
  84                         {
  85                                 vorbisEncoder->setSamplingRate(SettingsModel::samplingRates[settings->samplingRate()]);
  86                                 *nativeResampling = true;
  87                         }
  88                         encoder = vorbisEncoder;
  89                 }
  90                 break;
  91         /*-------- AACEncoder /*--------*/
  92         case SettingsModel::AACEncoder:
  93                 {
  94                         switch(getAacEncoder())
  95                         {
  96                         case SettingsModel::AAC_ENCODER_QAAC:
  97                                 {
  98                                         QAACEncoder *aacEncoder = new QAACEncoder();
  99                                         aacEncoder->setProfile(settings->aacEncProfile());
 100                                         encoder = aacEncoder;
 101                                 }
 102                                 break;
 103                         case SettingsModel::AAC_ENCODER_FHG:
 104                                 {
 105                                         FHGAACEncoder *aacEncoder = new FHGAACEncoder();
 106                                         aacEncoder->setProfile(settings->aacEncProfile());
 107                                         encoder = aacEncoder;
 108                                 }
 109                                 break;
 110                         case SettingsModel::AAC_ENCODER_FDK:
 111                                 {
 112                                         FDKAACEncoder *aacEncoder = new FDKAACEncoder();
 113                                         aacEncoder->setProfile(settings->aacEncProfile());
 114                                         encoder = aacEncoder;
 115                                 }
 116                                 break;
 117                         case SettingsModel::AAC_ENCODER_NERO:
 118                                 {
 119                                         AACEncoder *aacEncoder = new AACEncoder();
 120                                         aacEncoder->setEnable2Pass(settings->neroAACEnable2Pass());
 121                                         aacEncoder->setProfile(settings->aacEncProfile());
 122                                         encoder = aacEncoder;
 123                                 }
 124                                 break;
 125                         default:
 126                                 MUTILS_THROW("makeEncoder(): Unknown AAC encoder specified!");
 127                                 break;
 128                         }
 129                 }
 130                 break;
 131         /*-------- AC3Encoder /*--------*/
 132         case SettingsModel::AC3Encoder:
 133                 {
 134                         AC3Encoder *ac3Encoder = new AC3Encoder();
 135                         ac3Encoder->setAudioCodingMode(settings->aftenAudioCodingMode());
 136                         ac3Encoder->setDynamicRangeCompression(settings->aftenDynamicRangeCompression());
 137                         ac3Encoder->setExponentSearchSize(settings->aftenExponentSearchSize());
 138                         ac3Encoder->setFastBitAllocation(settings->aftenFastBitAllocation());
 139                         encoder = ac3Encoder;
 140                 }
 141                 break;
 142         /*-------- FLACEncoder /*--------*/
 143         case SettingsModel::FLACEncoder:
 144                 {
 145                         FLACEncoder *flacEncoder = new FLACEncoder();
 146                         encoder = flacEncoder;
 147                 }
 148                 break;
 149         /*-------- OpusEncoder --------*/
 150         case SettingsModel::OpusEncoder:
 151                 {
 152                         OpusEncoder *opusEncoder = new OpusEncoder();
 153                         opusEncoder->setOptimizeFor(settings->opusOptimizeFor());
 154                         opusEncoder->setEncodeComplexity(settings->opusComplexity());
 155                         opusEncoder->setFrameSize(settings->opusFramesize());
 156                         encoder = opusEncoder;
 157                 }
 158                 break;
 159         /*-------- DCAEncoder --------*/
 160         case SettingsModel::DCAEncoder:
 161                 {
 162                         DCAEncoder *dcaEncoder = new DCAEncoder();
 163                         encoder = dcaEncoder;
 164                 }
 165                 break;
 166         /*-------- MACEncoder --------*/
 167         case SettingsModel::MACEncoder:
 168                 {
 169                         MACEncoder *macEncoder = new MACEncoder();
 170                         encoder = macEncoder;
 171                 }
 172                 break;
 173         /*-------- PCMEncoder --------*/
 174         case SettingsModel::PCMEncoder:
 175                 {
 176                         WaveEncoder *waveEncoder = new WaveEncoder();
 177                         encoder = waveEncoder;
 178                 }
 179                 break;
 180         /*-------- default --------*/
 181         default:
 182                 MUTILS_THROW("Unsupported encoder!");
 183         }
 184
 185         //Sanity checking
 186         if(!encoder)
 187         {
 188                 MUTILS_THROW("No encoder instance has been assigend!");
 189         }
 190
 191         //Apply common settings
 192         encoder->setRCMode(rcMode = loadEncoderMode(settings, encoderId));
 193         encoder->setCustomParams(loadEncoderCustomParams(settings, encoderId));
 194         encoder->setBitrate(loadEncoderValue(settings, encoderId, rcMode));
 195
 196         return encoder;
 197 }
 198
 199 ////////////////////////////////////////////////////////////
 200 // Get encoder info
 201 ////////////////////////////////////////////////////////////
 202
 203 const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId)
 204 {
 205         const AbstractEncoderInfo *info = NULL;
 206
 207         switch(encoderId)
 208         {
 209                 case SettingsModel::MP3Encoder:    info = MP3Encoder   ::getEncoderInfo(); break;
 210                 case SettingsModel::VorbisEncoder: info = VorbisEncoder::getEncoderInfo(); break;
 211                 case SettingsModel::AC3Encoder:    info = AC3Encoder   ::getEncoderInfo(); break;
 212                 case SettingsModel::FLACEncoder:   info = FLACEncoder  ::getEncoderInfo(); break;
 213                 case SettingsModel::OpusEncoder:   info = OpusEncoder  ::getEncoderInfo(); break;
 214                 case SettingsModel::DCAEncoder:    info = DCAEncoder   ::getEncoderInfo(); break;
 215                 case SettingsModel::MACEncoder:    info = MACEncoder   ::getEncoderInfo(); break;
 216                 case SettingsModel::PCMEncoder:    info = WaveEncoder  ::getEncoderInfo(); break;
 217                 case SettingsModel::AACEncoder:
 218                         switch(getAacEncoder())
 219                         {
 220                                 case SettingsModel::AAC_ENCODER_QAAC: info = QAACEncoder  ::getEncoderInfo(); break;
 221                                 case SettingsModel::AAC_ENCODER_FHG:  info = FHGAACEncoder::getEncoderInfo(); break;
 222                                 case SettingsModel::AAC_ENCODER_FDK:  info = FDKAACEncoder::getEncoderInfo(); break;
 223                                 case SettingsModel::AAC_ENCODER_NERO: info = AACEncoder   ::getEncoderInfo(); break;
 224                                 default: MUTILS_THROW("Unknown AAC encoder specified!");
 225                         }
 226                         break;
 227                 default: MUTILS_THROW("Unsupported encoder!");
 228         }
 229
 230         //Sanity checking
 231         if(!info)
 232         {
 233                 MUTILS_THROW("No encoder instance has been assigend!");
 234         }
 235
 236         return info;
 237 }
 238
 239 ////////////////////////////////////////////////////////////
 240 // Load/store encoder RC mode
 241 ////////////////////////////////////////////////////////////
 242
 243 #define STORE_MODE(ENCODER_ID, RC_MODE) do \
 244 { \
 245         settings->compressionRCMode##ENCODER_ID(RC_MODE); \
 246 } \
 247 while(0)
 248
 249 #define LOAD_MODE(RC_MODE, ENCODER_ID) do \
 250 { \
 251         (RC_MODE) = settings->compressionRCMode##ENCODER_ID(); \
 252 } \
 253 while(0)
 254
 255 void EncoderRegistry::saveEncoderMode(SettingsModel *settings, const int encoderId, const int rcMode)
 256 {
 257         //Sanity checking
 258         if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
 259         {
 260                 MUTILS_THROW("Unknown rate-control mode!");
 261         }
 262
 263         //Store the encoder bitrate/quality value
 264         switch(encoderId)
 265         {
 266                 case SettingsModel::MP3Encoder:    STORE_MODE(LAME,    rcMode); break;
 267                 case SettingsModel::VorbisEncoder: STORE_MODE(OggEnc,  rcMode); break;
 268                 case SettingsModel::AACEncoder:    STORE_MODE(AacEnc,  rcMode); break;
 269                 case SettingsModel::AC3Encoder:    STORE_MODE(Aften,   rcMode); break;
 270                 case SettingsModel::FLACEncoder:   STORE_MODE(FLAC,    rcMode); break;
 271                 case SettingsModel::OpusEncoder:   STORE_MODE(OpusEnc, rcMode); break;
 272                 case SettingsModel::DCAEncoder:    STORE_MODE(DcaEnc,  rcMode); break;
 273                 case SettingsModel::MACEncoder:    STORE_MODE(MacEnc,  rcMode); break;
 274                 case SettingsModel::PCMEncoder:    STORE_MODE(Wave,    rcMode); break;
 275                 default: MUTILS_THROW("Unsupported encoder!");
 276         }
 277 }
 278
 279 int EncoderRegistry::loadEncoderMode(const SettingsModel *settings, const int encoderId)
 280 {
 281         int rcMode = -1;
 282
 283         //Store the encoder bitrate/quality value
 284         switch(encoderId)
 285         {
 286                 case SettingsModel::MP3Encoder:    LOAD_MODE(rcMode, LAME);    break;
 287                 case SettingsModel::VorbisEncoder: LOAD_MODE(rcMode, OggEnc);  break;
 288                 case SettingsModel::AACEncoder:    LOAD_MODE(rcMode, AacEnc);  break;
 289                 case SettingsModel::AC3Encoder:    LOAD_MODE(rcMode, Aften);   break;
 290                 case SettingsModel::FLACEncoder:   LOAD_MODE(rcMode, FLAC);    break;
 291                 case SettingsModel::OpusEncoder:   LOAD_MODE(rcMode, OpusEnc); break;
 292                 case SettingsModel::DCAEncoder:    LOAD_MODE(rcMode, DcaEnc);  break;
 293                 case SettingsModel::MACEncoder:    LOAD_MODE(rcMode, MacEnc);  break;
 294                 case SettingsModel::PCMEncoder:    LOAD_MODE(rcMode, Wave);    break;
 295                 default: MUTILS_THROW("Unsupported encoder!");
 296         }
 297
 298         return rcMode;
 299 }
 300
 301 ////////////////////////////////////////////////////////////
 302 // Load/store encoder bitrate/quality value
 303 ////////////////////////////////////////////////////////////
 304
 305 #define STORE_VALUE(ENCODER_ID, RC_MODE, VALUE) do \
 306 { \
 307         if(IS_VBR(RC_MODE)) settings->compressionVbrQuality##ENCODER_ID(VALUE); \
 308         if(IS_ABR(RC_MODE)) settings->compressionAbrBitrate##ENCODER_ID(VALUE); \
 309         if(IS_CBR(RC_MODE)) settings->compressionCbrBitrate##ENCODER_ID(VALUE); \
 310 } \
 311 while(0)
 312
 313 #define LOAD_VALUE(VALUE, ENCODER_ID, RC_MODE) do \
 314 { \
 315         if(IS_VBR(RC_MODE)) (VALUE) = settings->compressionVbrQuality##ENCODER_ID(); \
 316         if(IS_ABR(RC_MODE)) (VALUE) = settings->compressionAbrBitrate##ENCODER_ID(); \
 317         if(IS_CBR(RC_MODE)) (VALUE) = settings->compressionCbrBitrate##ENCODER_ID(); \
 318 } \
 319 while(0)
 320
 321 void EncoderRegistry::saveEncoderValue(SettingsModel *settings, const int encoderId, const int rcMode, const int value)
 322 {
 323         //Sanity checking
 324         if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
 325         {
 326                 MUTILS_THROW("Unknown rate-control mode!");
 327         }
 328
 329         //Store the encoder bitrate/quality value
 330         switch(encoderId)
 331         {
 332                 case SettingsModel::MP3Encoder:    STORE_VALUE(LAME,    rcMode, value); break;
 333                 case SettingsModel::VorbisEncoder: STORE_VALUE(OggEnc,  rcMode, value); break;
 334                 case SettingsModel::AACEncoder:    STORE_VALUE(AacEnc,  rcMode, value); break;
 335                 case SettingsModel::AC3Encoder:    STORE_VALUE(Aften,   rcMode, value); break;
 336                 case SettingsModel::FLACEncoder:   STORE_VALUE(FLAC,    rcMode, value); break;
 337                 case SettingsModel::OpusEncoder:   STORE_VALUE(OpusEnc, rcMode, value); break;
 338                 case SettingsModel::DCAEncoder:    STORE_VALUE(DcaEnc,  rcMode, value); break;
 339                 case SettingsModel::MACEncoder:    STORE_VALUE(MacEnc,  rcMode, value); break;
 340                 case SettingsModel::PCMEncoder:    STORE_VALUE(Wave,    rcMode, value); break;
 341                 default: MUTILS_THROW("Unsupported encoder!");
 342         }
 343 }
 344
 345 int EncoderRegistry::loadEncoderValue(const SettingsModel *settings, const int encoderId, const int rcMode)
 346 {
 347         int value = INT_MAX;
 348
 349         //Sanity checking
 350         if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
 351         {
 352                 MUTILS_THROW("Unknown rate-control mode!");
 353         }
 354
 355         //Load the encoder bitrate/quality value
 356         switch(encoderId)
 357         {
 358                 case SettingsModel::MP3Encoder:    LOAD_VALUE(value, LAME,    rcMode); break;
 359                 case SettingsModel::VorbisEncoder: LOAD_VALUE(value, OggEnc,  rcMode); break;
 360                 case SettingsModel::AACEncoder:    LOAD_VALUE(value, AacEnc,  rcMode); break;
 361                 case SettingsModel::AC3Encoder:    LOAD_VALUE(value, Aften,   rcMode); break;
 362                 case SettingsModel::FLACEncoder:   LOAD_VALUE(value, FLAC,    rcMode); break;
 363                 case SettingsModel::OpusEncoder:   LOAD_VALUE(value, OpusEnc, rcMode); break;
 364                 case SettingsModel::DCAEncoder:    LOAD_VALUE(value, DcaEnc,  rcMode); break;
 365                 case SettingsModel::MACEncoder:    LOAD_VALUE(value, MacEnc,  rcMode); break;
 366                 case SettingsModel::PCMEncoder:    LOAD_VALUE(value, Wave,    rcMode); break;
 367                 default: MUTILS_THROW("Unsupported encoder!");
 368         }
 369
 370         return value;
 371 }
 372
 373 ////////////////////////////////////////////////////////////
 374 // Load/store encoder custom parameters
 375 ////////////////////////////////////////////////////////////
 376
 377 #define STORE_PARAMS(ENCODER_ID, PARAMS) do \
 378 { \
 379         settings->customParameters##ENCODER_ID(PARAMS); \
 380 } \
 381 while(0)
 382
 383 #define LOAD_PARAMS(PARAMS, ENCODER_ID) do \
 384 { \
 385         (PARAMS) = settings->customParameters##ENCODER_ID(); \
 386 } \
 387 while(0)
 388
 389 void EncoderRegistry::saveEncoderCustomParams(SettingsModel *settings, const int encoderId, const QString &params)
 390 {
 391         //Store the encoder bitrate/quality value
 392         switch(encoderId)
 393         {
 394                 case SettingsModel::MP3Encoder:    STORE_PARAMS(LAME,    params.trimmed()); break;
 395                 case SettingsModel::VorbisEncoder: STORE_PARAMS(OggEnc,  params.trimmed()); break;
 396                 case SettingsModel::AACEncoder:    STORE_PARAMS(AacEnc,  params.trimmed()); break;
 397                 case SettingsModel::AC3Encoder:    STORE_PARAMS(Aften,   params.trimmed()); break;
 398                 case SettingsModel::FLACEncoder:   STORE_PARAMS(FLAC,    params.trimmed()); break;
 399                 case SettingsModel::OpusEncoder:   STORE_PARAMS(OpusEnc, params.trimmed()); break;
 400                 case SettingsModel::DCAEncoder:    STORE_PARAMS(DcaEnc,  params.trimmed()); break;
 401                 case SettingsModel::MACEncoder:    STORE_PARAMS(MacEnc,  params.trimmed()); break;
 402                 case SettingsModel::PCMEncoder:    STORE_PARAMS(Wave,    params.trimmed()); break;
 403                 default: MUTILS_THROW("Unsupported encoder!");
 404         }
 405 }
 406
 407 QString EncoderRegistry::loadEncoderCustomParams(const SettingsModel *settings, const int encoderId)
 408 {
 409         QString params;
 410
 411         //Load the encoder bitrate/quality value
 412         switch(encoderId)
 413         {
 414                 case SettingsModel::MP3Encoder:    LOAD_PARAMS(params, LAME);    break;
 415                 case SettingsModel::VorbisEncoder: LOAD_PARAMS(params, OggEnc);  break;
 416                 case SettingsModel::AACEncoder:    LOAD_PARAMS(params, AacEnc);  break;
 417                 case SettingsModel::AC3Encoder:    LOAD_PARAMS(params, Aften);   break;
 418                 case SettingsModel::FLACEncoder:   LOAD_PARAMS(params, FLAC);    break;
 419                 case SettingsModel::OpusEncoder:   LOAD_PARAMS(params, OpusEnc); break;
 420                 case SettingsModel::DCAEncoder:    LOAD_PARAMS(params, DcaEnc);  break;
 421                 case SettingsModel::MACEncoder:    LOAD_PARAMS(params, MacEnc);  break;
 422                 case SettingsModel::PCMEncoder:    LOAD_PARAMS(params, Wave);    break;
 423                 default: MUTILS_THROW("Unsupported encoder!");
 424         }
 425
 426         return params;
 427 }
 428
 429 ////////////////////////////////////////////////////////////
 430 // Reset encoder settings
 431 ////////////////////////////////////////////////////////////
 432
 433 #define RESET_SETTING(OBJ,NAME) do \
 434 { \
 435         (OBJ)->NAME((OBJ)->NAME##Default()); \
 436 } \
 437 while(0)
 438
 439 void EncoderRegistry::resetAllEncoders(SettingsModel *settings)
 440 {
 441         RESET_SETTING(settings, compressionAbrBitrateAacEnc);
 442         RESET_SETTING(settings, compressionAbrBitrateAften);
 443         RESET_SETTING(settings, compressionAbrBitrateDcaEnc);
 444         RESET_SETTING(settings, compressionAbrBitrateFLAC);
 445         RESET_SETTING(settings, compressionAbrBitrateLAME);
 446         RESET_SETTING(settings, compressionAbrBitrateMacEnc);
 447         RESET_SETTING(settings, compressionAbrBitrateOggEnc);
 448         RESET_SETTING(settings, compressionAbrBitrateOpusEnc);
 449         RESET_SETTING(settings, compressionAbrBitrateWave);
 450
 451         RESET_SETTING(settings, compressionCbrBitrateAacEnc);
 452         RESET_SETTING(settings, compressionCbrBitrateAften);
 453         RESET_SETTING(settings, compressionCbrBitrateDcaEnc);
 454         RESET_SETTING(settings, compressionCbrBitrateFLAC);
 455         RESET_SETTING(settings, compressionCbrBitrateLAME);
 456         RESET_SETTING(settings, compressionCbrBitrateMacEnc);
 457         RESET_SETTING(settings, compressionCbrBitrateOggEnc);
 458         RESET_SETTING(settings, compressionCbrBitrateOpusEnc);
 459         RESET_SETTING(settings, compressionCbrBitrateWave);
 460
 461         RESET_SETTING(settings, compressionRCModeAacEnc);
 462         RESET_SETTING(settings, compressionRCModeAften);
 463         RESET_SETTING(settings, compressionRCModeDcaEnc);
 464         RESET_SETTING(settings, compressionRCModeFLAC);
 465         RESET_SETTING(settings, compressionRCModeLAME);
 466         RESET_SETTING(settings, compressionRCModeMacEnc);
 467         RESET_SETTING(settings, compressionRCModeOggEnc);
 468         RESET_SETTING(settings, compressionRCModeOpusEnc);
 469         RESET_SETTING(settings, compressionRCModeWave);
 470
 471         RESET_SETTING(settings, compressionVbrQualityAacEnc);
 472         RESET_SETTING(settings, compressionVbrQualityAften);
 473         RESET_SETTING(settings, compressionVbrQualityDcaEnc);
 474         RESET_SETTING(settings, compressionVbrQualityFLAC);
 475         RESET_SETTING(settings, compressionVbrQualityLAME);
 476         RESET_SETTING(settings, compressionVbrQualityMacEnc);
 477         RESET_SETTING(settings, compressionVbrQualityOggEnc);
 478         RESET_SETTING(settings, compressionVbrQualityOpusEnc);
 479         RESET_SETTING(settings, compressionVbrQualityWave);
 480 }
 481
 482 ////////////////////////////////////////////////////////////
 483 // Get File Extensions
 484 ////////////////////////////////////////////////////////////
 485
 486 QStringList EncoderRegistry::getOutputFileExtensions(void)
 487 {
 488         QStringList list;
 489         for(int encoderId = SettingsModel::MP3Encoder; encoderId < SettingsModel::ENCODER_COUNT; encoderId++)
 490         {
 491                 if((encoderId == SettingsModel::AACEncoder) && (getAacEncoder() == SettingsModel::AAC_ENCODER_NONE))
 492                 {
 493                         continue;
 494                 }
 495                 list << QString::fromLatin1(getEncoderInfo(encoderId)->extension());
 496         }
 497         return list;
 498 }
 499
 500 ////////////////////////////////////////////////////////////
 501 // Static Functions
 502 ////////////////////////////////////////////////////////////
 503
 504 int EncoderRegistry::getAacEncoder(void)
 505 {
 506         if(lamexp_tools_check("qaac.exe") && lamexp_tools_check("libsoxr.dll") && lamexp_tools_check("libsoxconvolver.dll"))
 507         {
 508                 return SettingsModel::AAC_ENCODER_QAAC;
 509         }
 510         else if(lamexp_tools_check("qaac64.exe") && lamexp_tools_check("libsoxr64.dll") && lamexp_tools_check("libsoxconvolver64.dll"))
 511         {
 512                 return SettingsModel::AAC_ENCODER_QAAC;
 513         }
 514         else if(lamexp_tools_check("fdkaac.exe"))
 515         {
 516                 return SettingsModel::AAC_ENCODER_FDK;
 517         }
 518         else if(lamexp_tools_check("fhgaacenc.exe") && lamexp_tools_check("enc_fhgaac.dll") && lamexp_tools_check("nsutil.dll") && lamexp_tools_check("libmp4v2.dll"))
 519         {
 520                 return SettingsModel::AAC_ENCODER_FHG;
 521         }
 522         else if(lamexp_tools_check("neroAacEnc.exe") && lamexp_tools_check("neroAacDec.exe") && lamexp_tools_check("neroAacTag.exe"))
 523         {
 524                 return SettingsModel::AAC_ENCODER_NERO;
 525         }
 526         else
 527         {
 528                 return SettingsModel::AAC_ENCODER_NONE;
 529         }
 530 }