///////////////////////////////////////////////////////////////////////////////
// LameXP - Audio Encoder Front-End
-// Copyright (C) 2004-2013 LoRd_MuldeR <MuldeR2@GMX.de>
+// Copyright (C) 2004-2014 LoRd_MuldeR <MuldeR2@GMX.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
+// (at your option) any later version, but always including the *additional*
+// restrictions defined in the "License.txt" file.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "Registry_Encoder.h"
+#include "Global.h"
#include "Model_Settings.h"
#include "Encoder_AAC.h"
#include "Encoder_AAC_FHG.h"
#include "Encoder_MP3.h"
#include "Encoder_Vorbis.h"
#include "Encoder_Opus.h"
+#include "Encoder_MAC.h"
#include "Encoder_Wave.h"
#define IS_VBR(RC_MODE) ((RC_MODE) == SettingsModel::VBRMode)
+#define IS_ABR(RC_MODE) ((RC_MODE) == SettingsModel::ABRMode)
+#define IS_CBR(RC_MODE) ((RC_MODE) == SettingsModel::CBRMode)
+
+////////////////////////////////////////////////////////////
+// Create encoder instance
+////////////////////////////////////////////////////////////
AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling)
{
AbstractEncoder *encoder = NULL;
*nativeResampling = false;
+ //Create new encoder instance and apply encoder-specific settings
switch(encoderId)
{
/*-------- MP3Encoder /*--------*/
case SettingsModel::MP3Encoder:
{
MP3Encoder *mp3Encoder = new MP3Encoder();
- mp3Encoder->setRCMode(rcMode = settings->compressionRCModeLAME());
- mp3Encoder->setBitrate(IS_VBR(rcMode) ? settings->compressionVbrLevelLAME() : settings->compressionBitrateLAME());
mp3Encoder->setAlgoQuality(settings->lameAlgoQuality());
if(settings->bitrateManagementEnabled())
{
*nativeResampling = true;
}
mp3Encoder->setChannelMode(settings->lameChannelMode());
- mp3Encoder->setCustomParams(settings->customParametersLAME());
encoder = mp3Encoder;
}
break;
case SettingsModel::VorbisEncoder:
{
VorbisEncoder *vorbisEncoder = new VorbisEncoder();
- vorbisEncoder->setRCMode(rcMode = settings->compressionRCModeOggEnc());
- vorbisEncoder->setBitrate(IS_VBR(rcMode) ? settings->compressionVbrLevelOggEnc() : settings->compressionBitrateOggEnc());
if(settings->bitrateManagementEnabled())
{
vorbisEncoder->setBitrateLimits(settings->bitrateManagementMinRate(), settings->bitrateManagementMaxRate());
vorbisEncoder->setSamplingRate(SettingsModel::samplingRates[settings->samplingRate()]);
*nativeResampling = true;
}
- vorbisEncoder->setCustomParams(settings->customParametersOggEnc());
encoder = vorbisEncoder;
}
break;
/*-------- AACEncoder /*--------*/
case SettingsModel::AACEncoder:
{
- switch(SettingsModel::getAacEncoder())
+ switch(getAacEncoder())
{
case SettingsModel::AAC_ENCODER_QAAC:
{
QAACEncoder *aacEncoder = new QAACEncoder();
- aacEncoder->setRCMode(rcMode = settings->compressionRCModeAacEnc());
- aacEncoder->setBitrate(IS_VBR(rcMode) ? settings->compressionVbrLevelAacEnc() : settings->compressionBitrateAacEnc());
aacEncoder->setProfile(settings->aacEncProfile());
- aacEncoder->setCustomParams(settings->customParametersAacEnc());
encoder = aacEncoder;
}
break;
case SettingsModel::AAC_ENCODER_FHG:
{
FHGAACEncoder *aacEncoder = new FHGAACEncoder();
- aacEncoder->setRCMode(rcMode = settings->compressionRCModeAacEnc());
- aacEncoder->setBitrate(IS_VBR(rcMode) ? settings->compressionVbrLevelAacEnc() : settings->compressionBitrateAacEnc());
aacEncoder->setProfile(settings->aacEncProfile());
- aacEncoder->setCustomParams(settings->customParametersAacEnc());
encoder = aacEncoder;
}
break;
case SettingsModel::AAC_ENCODER_NERO:
{
AACEncoder *aacEncoder = new AACEncoder();
- aacEncoder->setRCMode(rcMode = settings->compressionRCModeAacEnc());
- aacEncoder->setBitrate(IS_VBR(rcMode) ? settings->compressionVbrLevelAacEnc() : settings->compressionBitrateAacEnc());
aacEncoder->setEnable2Pass(settings->neroAACEnable2Pass());
aacEncoder->setProfile(settings->aacEncProfile());
- aacEncoder->setCustomParams(settings->customParametersAacEnc());
encoder = aacEncoder;
}
break;
default:
- throw "makeEncoder(): Unknown AAC encoder specified!";
+ MUTILS_THROW("makeEncoder(): Unknown AAC encoder specified!");
break;
}
}
case SettingsModel::AC3Encoder:
{
AC3Encoder *ac3Encoder = new AC3Encoder();
- ac3Encoder->setRCMode(rcMode = settings->compressionRCModeAften());
- ac3Encoder->setBitrate(IS_VBR(rcMode) ? settings->compressionVbrLevelAften() : settings->compressionBitrateAften());
- ac3Encoder->setCustomParams(settings->customParametersAften());
ac3Encoder->setAudioCodingMode(settings->aftenAudioCodingMode());
ac3Encoder->setDynamicRangeCompression(settings->aftenDynamicRangeCompression());
ac3Encoder->setExponentSearchSize(settings->aftenExponentSearchSize());
case SettingsModel::FLACEncoder:
{
FLACEncoder *flacEncoder = new FLACEncoder();
- flacEncoder->setBitrate(settings->compressionVbrLevelFLAC());
- flacEncoder->setRCMode(SettingsModel::VBRMode);
- flacEncoder->setCustomParams(settings->customParametersFLAC());
encoder = flacEncoder;
}
break;
case SettingsModel::OpusEncoder:
{
OpusEncoder *opusEncoder = new OpusEncoder();
- opusEncoder->setRCMode(rcMode = settings->compressionRCModeOpusEnc());
- opusEncoder->setBitrate(settings->compressionBitrateOpusEnc()); /*Opus always uses bitrate*/
opusEncoder->setOptimizeFor(settings->opusOptimizeFor());
opusEncoder->setEncodeComplexity(settings->opusComplexity());
opusEncoder->setFrameSize(settings->opusFramesize());
- opusEncoder->setCustomParams(settings->customParametersOpus());
encoder = opusEncoder;
}
break;
case SettingsModel::DCAEncoder:
{
DCAEncoder *dcaEncoder = new DCAEncoder();
- dcaEncoder->setRCMode(SettingsModel::CBRMode);
- dcaEncoder->setBitrate(IS_VBR(rcMode) ? 0 : settings->compressionBitrateDcaEnc());
encoder = dcaEncoder;
}
break;
+ /*-------- MACEncoder --------*/
+ case SettingsModel::MACEncoder:
+ {
+ MACEncoder *macEncoder = new MACEncoder();
+ encoder = macEncoder;
+ }
+ break;
/*-------- PCMEncoder --------*/
case SettingsModel::PCMEncoder:
{
WaveEncoder *waveEncoder = new WaveEncoder();
- waveEncoder->setBitrate(0); /*does NOT apply to PCM output*/
- waveEncoder->setRCMode(0); /*does NOT apply to PCM output*/
encoder = waveEncoder;
}
break;
/*-------- default --------*/
default:
- throw "Unsupported encoder!";
+ MUTILS_THROW("Unsupported encoder!");
}
//Sanity checking
if(!encoder)
{
- throw "No encoder instance has been assigend!";
+ MUTILS_THROW("No encoder instance has been assigend!");
}
+ //Apply common settings
+ encoder->setRCMode(rcMode = loadEncoderMode(settings, encoderId));
+ encoder->setCustomParams(loadEncoderCustomParams(settings, encoderId));
+ encoder->setBitrate(loadEncoderValue(settings, encoderId, rcMode));
+
return encoder;
}
+////////////////////////////////////////////////////////////
+// Get encoder info
+////////////////////////////////////////////////////////////
+
const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId)
{
const AbstractEncoderInfo *info = NULL;
switch(encoderId)
{
- /*-------- MP3Encoder /*--------*/
- case SettingsModel::MP3Encoder:
- info = MP3Encoder::getEncoderInfo();
- break;
- /*-------- VorbisEncoder /*--------*/
- case SettingsModel::VorbisEncoder:
- info = VorbisEncoder::getEncoderInfo();
- break;
- /*-------- AACEncoder /*--------*/
- case SettingsModel::AACEncoder:
- {
- switch(SettingsModel::getAacEncoder())
+ case SettingsModel::MP3Encoder: info = MP3Encoder::getEncoderInfo(); break;
+ case SettingsModel::VorbisEncoder: info = VorbisEncoder::getEncoderInfo(); break;
+ case SettingsModel::AC3Encoder: info = AC3Encoder::getEncoderInfo(); break;
+ case SettingsModel::FLACEncoder: info = FLACEncoder::getEncoderInfo(); break;
+ case SettingsModel::OpusEncoder: info = OpusEncoder::getEncoderInfo(); break;
+ case SettingsModel::DCAEncoder: info = DCAEncoder::getEncoderInfo(); break;
+ case SettingsModel::MACEncoder: info = MACEncoder::getEncoderInfo(); break;
+ case SettingsModel::PCMEncoder: info = WaveEncoder::getEncoderInfo(); break;
+ case SettingsModel::AACEncoder:
+ switch(getAacEncoder())
{
- case SettingsModel::AAC_ENCODER_QAAC:
- info = QAACEncoder::getEncoderInfo();
- break;
- case SettingsModel::AAC_ENCODER_FHG:
- info = FHGAACEncoder::getEncoderInfo();
- break;
- case SettingsModel::AAC_ENCODER_NERO:
- info = AACEncoder::getEncoderInfo();
- break;
- default:
- throw "Unknown AAC encoder specified!";
- break;
+ case SettingsModel::AAC_ENCODER_QAAC: info = QAACEncoder::getEncoderInfo(); break;
+ case SettingsModel::AAC_ENCODER_FHG: info = FHGAACEncoder::getEncoderInfo(); break;
+ case SettingsModel::AAC_ENCODER_NERO: info = AACEncoder::getEncoderInfo(); break;
+ default: MUTILS_THROW("Unknown AAC encoder specified!");
}
- }
- break;
- /*-------- AC3Encoder /*--------*/
- case SettingsModel::AC3Encoder:
- info = AC3Encoder::getEncoderInfo();
- break;
- /*-------- FLACEncoder /*--------*/
- case SettingsModel::FLACEncoder:
- info = FLACEncoder::getEncoderInfo();
- break;
- /*-------- OpusEncoder --------*/
- case SettingsModel::OpusEncoder:
- info = OpusEncoder::getEncoderInfo();
- break;
- /*-------- DCAEncoder --------*/
- case SettingsModel::DCAEncoder:
- info = DCAEncoder::getEncoderInfo();
- break;
- /*-------- PCMEncoder --------*/
- case SettingsModel::PCMEncoder:
- info = WaveEncoder::getEncoderInfo();
- break;
- /*-------- default --------*/
- default:
- throw "Unsupported encoder!";
+ break;
+ default: MUTILS_THROW("Unsupported encoder!");
}
//Sanity checking
if(!info)
{
- throw "No encoder instance has been assigend!";
+ MUTILS_THROW("No encoder instance has been assigend!");
}
return info;
}
+
+////////////////////////////////////////////////////////////
+// Load/store encoder RC mode
+////////////////////////////////////////////////////////////
+
+#define STORE_MODE(ENCODER_ID, RC_MODE) do \
+{ \
+ settings->compressionRCMode##ENCODER_ID(RC_MODE); \
+} \
+while(0)
+
+#define LOAD_MODE(RC_MODE, ENCODER_ID) do \
+{ \
+ (RC_MODE) = settings->compressionRCMode##ENCODER_ID(); \
+} \
+while(0)
+
+void EncoderRegistry::saveEncoderMode(SettingsModel *settings, const int encoderId, const int rcMode)
+{
+ //Sanity checking
+ if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
+ {
+ MUTILS_THROW("Unknown rate-control mode!");
+ }
+
+ //Store the encoder bitrate/quality value
+ switch(encoderId)
+ {
+ case SettingsModel::MP3Encoder: STORE_MODE(LAME, rcMode); break;
+ case SettingsModel::VorbisEncoder: STORE_MODE(OggEnc, rcMode); break;
+ case SettingsModel::AACEncoder: STORE_MODE(AacEnc, rcMode); break;
+ case SettingsModel::AC3Encoder: STORE_MODE(Aften, rcMode); break;
+ case SettingsModel::FLACEncoder: STORE_MODE(FLAC, rcMode); break;
+ case SettingsModel::OpusEncoder: STORE_MODE(OpusEnc, rcMode); break;
+ case SettingsModel::DCAEncoder: STORE_MODE(DcaEnc, rcMode); break;
+ case SettingsModel::MACEncoder: STORE_MODE(MacEnc, rcMode); break;
+ case SettingsModel::PCMEncoder: STORE_MODE(Wave, rcMode); break;
+ default: MUTILS_THROW("Unsupported encoder!");
+ }
+}
+
+int EncoderRegistry::loadEncoderMode(const SettingsModel *settings, const int encoderId)
+{
+ int rcMode = -1;
+
+ //Store the encoder bitrate/quality value
+ switch(encoderId)
+ {
+ case SettingsModel::MP3Encoder: LOAD_MODE(rcMode, LAME); break;
+ case SettingsModel::VorbisEncoder: LOAD_MODE(rcMode, OggEnc); break;
+ case SettingsModel::AACEncoder: LOAD_MODE(rcMode, AacEnc); break;
+ case SettingsModel::AC3Encoder: LOAD_MODE(rcMode, Aften); break;
+ case SettingsModel::FLACEncoder: LOAD_MODE(rcMode, FLAC); break;
+ case SettingsModel::OpusEncoder: LOAD_MODE(rcMode, OpusEnc); break;
+ case SettingsModel::DCAEncoder: LOAD_MODE(rcMode, DcaEnc); break;
+ case SettingsModel::MACEncoder: LOAD_MODE(rcMode, MacEnc); break;
+ case SettingsModel::PCMEncoder: LOAD_MODE(rcMode, Wave); break;
+ default: MUTILS_THROW("Unsupported encoder!");
+ }
+
+ return rcMode;
+}
+
+////////////////////////////////////////////////////////////
+// Load/store encoder bitrate/quality value
+////////////////////////////////////////////////////////////
+
+#define STORE_VALUE(ENCODER_ID, RC_MODE, VALUE) do \
+{ \
+ if(IS_VBR(RC_MODE)) settings->compressionVbrQuality##ENCODER_ID(VALUE); \
+ if(IS_ABR(RC_MODE)) settings->compressionAbrBitrate##ENCODER_ID(VALUE); \
+ if(IS_CBR(RC_MODE)) settings->compressionCbrBitrate##ENCODER_ID(VALUE); \
+} \
+while(0)
+
+#define LOAD_VALUE(VALUE, ENCODER_ID, RC_MODE) do \
+{ \
+ if(IS_VBR(RC_MODE)) (VALUE) = settings->compressionVbrQuality##ENCODER_ID(); \
+ if(IS_ABR(RC_MODE)) (VALUE) = settings->compressionAbrBitrate##ENCODER_ID(); \
+ if(IS_CBR(RC_MODE)) (VALUE) = settings->compressionCbrBitrate##ENCODER_ID(); \
+} \
+while(0)
+
+void EncoderRegistry::saveEncoderValue(SettingsModel *settings, const int encoderId, const int rcMode, const int value)
+{
+ //Sanity checking
+ if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
+ {
+ MUTILS_THROW("Unknown rate-control mode!");
+ }
+
+ //Store the encoder bitrate/quality value
+ switch(encoderId)
+ {
+ case SettingsModel::MP3Encoder: STORE_VALUE(LAME, rcMode, value); break;
+ case SettingsModel::VorbisEncoder: STORE_VALUE(OggEnc, rcMode, value); break;
+ case SettingsModel::AACEncoder: STORE_VALUE(AacEnc, rcMode, value); break;
+ case SettingsModel::AC3Encoder: STORE_VALUE(Aften, rcMode, value); break;
+ case SettingsModel::FLACEncoder: STORE_VALUE(FLAC, rcMode, value); break;
+ case SettingsModel::OpusEncoder: STORE_VALUE(OpusEnc, rcMode, value); break;
+ case SettingsModel::DCAEncoder: STORE_VALUE(DcaEnc, rcMode, value); break;
+ case SettingsModel::MACEncoder: STORE_VALUE(MacEnc, rcMode, value); break;
+ case SettingsModel::PCMEncoder: STORE_VALUE(Wave, rcMode, value); break;
+ default: MUTILS_THROW("Unsupported encoder!");
+ }
+}
+
+int EncoderRegistry::loadEncoderValue(const SettingsModel *settings, const int encoderId, const int rcMode)
+{
+ int value = INT_MAX;
+
+ //Sanity checking
+ if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
+ {
+ MUTILS_THROW("Unknown rate-control mode!");
+ }
+
+ //Load the encoder bitrate/quality value
+ switch(encoderId)
+ {
+ case SettingsModel::MP3Encoder: LOAD_VALUE(value, LAME, rcMode); break;
+ case SettingsModel::VorbisEncoder: LOAD_VALUE(value, OggEnc, rcMode); break;
+ case SettingsModel::AACEncoder: LOAD_VALUE(value, AacEnc, rcMode); break;
+ case SettingsModel::AC3Encoder: LOAD_VALUE(value, Aften, rcMode); break;
+ case SettingsModel::FLACEncoder: LOAD_VALUE(value, FLAC, rcMode); break;
+ case SettingsModel::OpusEncoder: LOAD_VALUE(value, OpusEnc, rcMode); break;
+ case SettingsModel::DCAEncoder: LOAD_VALUE(value, DcaEnc, rcMode); break;
+ case SettingsModel::MACEncoder: LOAD_VALUE(value, MacEnc, rcMode); break;
+ case SettingsModel::PCMEncoder: LOAD_VALUE(value, Wave, rcMode); break;
+ default: MUTILS_THROW("Unsupported encoder!");
+ }
+
+ return value;
+}
+
+////////////////////////////////////////////////////////////
+// Load/store encoder custom parameters
+////////////////////////////////////////////////////////////
+
+#define STORE_PARAMS(ENCODER_ID, PARAMS) do \
+{ \
+ settings->customParameters##ENCODER_ID(PARAMS); \
+} \
+while(0)
+
+#define LOAD_PARAMS(PARAMS, ENCODER_ID) do \
+{ \
+ (PARAMS) = settings->customParameters##ENCODER_ID(); \
+} \
+while(0)
+
+void EncoderRegistry::saveEncoderCustomParams(SettingsModel *settings, const int encoderId, const QString params)
+{
+ //Store the encoder bitrate/quality value
+ switch(encoderId)
+ {
+ case SettingsModel::MP3Encoder: STORE_PARAMS(LAME, params.trimmed()); break;
+ case SettingsModel::VorbisEncoder: STORE_PARAMS(OggEnc, params.trimmed()); break;
+ case SettingsModel::AACEncoder: STORE_PARAMS(AacEnc, params.trimmed()); break;
+ case SettingsModel::AC3Encoder: STORE_PARAMS(Aften, params.trimmed()); break;
+ case SettingsModel::FLACEncoder: STORE_PARAMS(FLAC, params.trimmed()); break;
+ case SettingsModel::OpusEncoder: STORE_PARAMS(OpusEnc, params.trimmed()); break;
+ case SettingsModel::DCAEncoder: STORE_PARAMS(DcaEnc, params.trimmed()); break;
+ case SettingsModel::MACEncoder: STORE_PARAMS(MacEnc, params.trimmed()); break;
+ case SettingsModel::PCMEncoder: STORE_PARAMS(Wave, params.trimmed()); break;
+ default: MUTILS_THROW("Unsupported encoder!");
+ }
+}
+
+QString EncoderRegistry::loadEncoderCustomParams(const SettingsModel *settings, const int encoderId)
+{
+ QString params;
+
+ //Load the encoder bitrate/quality value
+ switch(encoderId)
+ {
+ case SettingsModel::MP3Encoder: LOAD_PARAMS(params, LAME); break;
+ case SettingsModel::VorbisEncoder: LOAD_PARAMS(params, OggEnc); break;
+ case SettingsModel::AACEncoder: LOAD_PARAMS(params, AacEnc); break;
+ case SettingsModel::AC3Encoder: LOAD_PARAMS(params, Aften); break;
+ case SettingsModel::FLACEncoder: LOAD_PARAMS(params, FLAC); break;
+ case SettingsModel::OpusEncoder: LOAD_PARAMS(params, OpusEnc); break;
+ case SettingsModel::DCAEncoder: LOAD_PARAMS(params, DcaEnc); break;
+ case SettingsModel::MACEncoder: LOAD_PARAMS(params, MacEnc); break;
+ case SettingsModel::PCMEncoder: LOAD_PARAMS(params, Wave); break;
+ default: MUTILS_THROW("Unsupported encoder!");
+ }
+
+ return params;
+}
+
+////////////////////////////////////////////////////////////
+// Reset encoder settings
+////////////////////////////////////////////////////////////
+
+#define RESET_SETTING(OBJ,NAME) do \
+{ \
+ (OBJ)->NAME((OBJ)->NAME##Default()); \
+} \
+while(0)
+
+void EncoderRegistry::resetAllEncoders(SettingsModel *settings)
+{
+ RESET_SETTING(settings, compressionAbrBitrateAacEnc);
+ RESET_SETTING(settings, compressionAbrBitrateAften);
+ RESET_SETTING(settings, compressionAbrBitrateDcaEnc);
+ RESET_SETTING(settings, compressionAbrBitrateFLAC);
+ RESET_SETTING(settings, compressionAbrBitrateLAME);
+ RESET_SETTING(settings, compressionAbrBitrateMacEnc);
+ RESET_SETTING(settings, compressionAbrBitrateOggEnc);
+ RESET_SETTING(settings, compressionAbrBitrateOpusEnc);
+ RESET_SETTING(settings, compressionAbrBitrateWave);
+
+ RESET_SETTING(settings, compressionCbrBitrateAacEnc);
+ RESET_SETTING(settings, compressionCbrBitrateAften);
+ RESET_SETTING(settings, compressionCbrBitrateDcaEnc);
+ RESET_SETTING(settings, compressionCbrBitrateFLAC);
+ RESET_SETTING(settings, compressionCbrBitrateLAME);
+ RESET_SETTING(settings, compressionCbrBitrateMacEnc);
+ RESET_SETTING(settings, compressionCbrBitrateOggEnc);
+ RESET_SETTING(settings, compressionCbrBitrateOpusEnc);
+ RESET_SETTING(settings, compressionCbrBitrateWave);
+
+ RESET_SETTING(settings, compressionRCModeAacEnc);
+ RESET_SETTING(settings, compressionRCModeAften);
+ RESET_SETTING(settings, compressionRCModeDcaEnc);
+ RESET_SETTING(settings, compressionRCModeFLAC);
+ RESET_SETTING(settings, compressionRCModeLAME);
+ RESET_SETTING(settings, compressionRCModeMacEnc);
+ RESET_SETTING(settings, compressionRCModeOggEnc);
+ RESET_SETTING(settings, compressionRCModeOpusEnc);
+ RESET_SETTING(settings, compressionRCModeWave);
+
+ RESET_SETTING(settings, compressionVbrQualityAacEnc);
+ RESET_SETTING(settings, compressionVbrQualityAften);
+ RESET_SETTING(settings, compressionVbrQualityDcaEnc);
+ RESET_SETTING(settings, compressionVbrQualityFLAC);
+ RESET_SETTING(settings, compressionVbrQualityLAME);
+ RESET_SETTING(settings, compressionVbrQualityMacEnc);
+ RESET_SETTING(settings, compressionVbrQualityOggEnc);
+ RESET_SETTING(settings, compressionVbrQualityOpusEnc);
+ RESET_SETTING(settings, compressionVbrQualityWave);
+}
+
+////////////////////////////////////////////////////////////
+// Static Functions
+////////////////////////////////////////////////////////////
+
+int EncoderRegistry::getAacEncoder(void)
+{
+ if(lamexp_tool_check("qaac.exe") && lamexp_tool_check("libsoxr.dll") && lamexp_tool_check("libsoxconvolver.dll"))
+ {
+ return SettingsModel::AAC_ENCODER_QAAC;
+ }
+ else if(lamexp_tool_check("fhgaacenc.exe") && lamexp_tool_check("enc_fhgaac.dll") && lamexp_tool_check("nsutil.dll") && lamexp_tool_check("libmp4v2.dll"))
+ {
+ return SettingsModel::AAC_ENCODER_FHG;
+ }
+ else if(lamexp_tool_check("neroAacEnc.exe") && lamexp_tool_check("neroAacDec.exe") && lamexp_tool_check("neroAacTag.exe"))
+ {
+ return SettingsModel::AAC_ENCODER_NERO;
+ }
+ else
+ {
+ return SettingsModel::AAC_ENCODER_NONE;
+ }
+}
OSDN Git Service
