Muldersoft/LameXP
Muldersoft/LameXP
1
0
Fork 0
Code Releases 2 Activity

Refactored Main window to use AbstractEncoderInfo rather than having all the encoder-specific information hardcoded in the GUI code. Also much improved EncoderReistry class and some clean-up in SettingsModel class.

Browse Source
This commit is contained in:
LoRd_MuldeR 2013-10-02 16:39:26 +02:00
parent 70a117078b
commit 6c9e3c562f
11 changed files with 544 additions and 823 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

665
src/Dialog_MainWindow.cpp
View File

@ -42,7 +42,9 @@
#include "Model_FileList.h" #include "Model_FileList.h"
#include "Model_FileSystem.h" #include "Model_FileSystem.h"
#include "WinSevenTaskbar.h" #include "WinSevenTaskbar.h"
#include "Registry_Encoder.h"
#include "Registry_Decoder.h" #include "Registry_Decoder.h"
#include "Encoder_Abstract.h"
#include "ShellIntegration.h" #include "ShellIntegration.h"
#include "CustomEventFilter.h" #include "CustomEventFilter.h"
@ -349,20 +351,22 @@ MainWindow::MainWindow(FileListModel *fileListModel, AudioFileModel *metaInfo, S
m_encoderButtonGroup->addButton(ui->radioButtonEncoderDCA, SettingsModel::DCAEncoder); m_encoderButtonGroup->addButton(ui->radioButtonEncoderDCA, SettingsModel::DCAEncoder);
m_encoderButtonGroup->addButton(ui->radioButtonEncoderPCM, SettingsModel::PCMEncoder); m_encoderButtonGroup->addButton(ui->radioButtonEncoderPCM, SettingsModel::PCMEncoder);
ui->radioButtonEncoderAAC->setEnabled(m_aacEncoder > SettingsModel::AAC_ENCODER_NONE);
m_modeButtonGroup = new QButtonGroup(this); m_modeButtonGroup = new QButtonGroup(this);
m_modeButtonGroup->addButton(ui->radioButtonModeQuality, SettingsModel::VBRMode); m_modeButtonGroup->addButton(ui->radioButtonModeQuality, SettingsModel::VBRMode);
m_modeButtonGroup->addButton(ui->radioButtonModeAverageBitrate, SettingsModel::ABRMode); m_modeButtonGroup->addButton(ui->radioButtonModeAverageBitrate, SettingsModel::ABRMode);
m_modeButtonGroup->addButton(ui->radioButtonConstBitrate, SettingsModel::CBRMode); m_modeButtonGroup->addButton(ui->radioButtonConstBitrate, SettingsModel::CBRMode);
ui->radioButtonEncoderAAC->setEnabled(m_aacEncoder > SettingsModel::AAC_ENCODER_NONE); ui->radioButtonEncoderMP3->setChecked(true);
ui->radioButtonEncoderMP3->setChecked(m_settings->compressionEncoder() == SettingsModel::MP3Encoder); foreach(QAbstractButton *currentButton, m_encoderButtonGroup->buttons())
ui->radioButtonEncoderVorbis->setChecked(m_settings->compressionEncoder() == SettingsModel::VorbisEncoder); {
ui->radioButtonEncoderAAC->setChecked((m_settings->compressionEncoder() == SettingsModel::AACEncoder) && (m_aacEncoder > SettingsModel::AAC_ENCODER_NONE)); if(currentButton->isEnabled() && (m_encoderButtonGroup->id(currentButton) == m_settings->compressionEncoder()))
ui->radioButtonEncoderAC3->setChecked(m_settings->compressionEncoder() == SettingsModel::AC3Encoder); {
ui->radioButtonEncoderFLAC->setChecked(m_settings->compressionEncoder() == SettingsModel::FLACEncoder); currentButton->setChecked(true);
ui->radioButtonEncoderOpus->setChecked(m_settings->compressionEncoder() == SettingsModel::OpusEncoder); break;
ui->radioButtonEncoderDCA->setChecked(m_settings->compressionEncoder() == SettingsModel::DCAEncoder); }
ui->radioButtonEncoderPCM->setChecked(m_settings->compressionEncoder() == SettingsModel::PCMEncoder); }
m_evenFilterCompressionTab = new CustomEventFilter(); m_evenFilterCompressionTab = new CustomEventFilter();
ui->labelCompressionHelp->installEventFilter(m_evenFilterCompressionTab); ui->labelCompressionHelp->installEventFilter(m_evenFilterCompressionTab);
@ -395,7 +399,7 @@ MainWindow::MainWindow(FileListModel *fileListModel, AudioFileModel *metaInfo, S
ui->comboBoxAACProfile->setCurrentIndex(m_settings->aacEncProfile()); ui->comboBoxAACProfile->setCurrentIndex(m_settings->aacEncProfile());
ui->comboBoxAftenCodingMode->setCurrentIndex(m_settings->aftenAudioCodingMode()); ui->comboBoxAftenCodingMode->setCurrentIndex(m_settings->aftenAudioCodingMode());
ui->comboBoxAftenDRCMode->setCurrentIndex(m_settings->aftenDynamicRangeCompression()); ui->comboBoxAftenDRCMode->setCurrentIndex(m_settings->aftenDynamicRangeCompression());
ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEqualizationMode()); ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEQMode());
//comboBoxOpusOptimize->setCurrentIndex(m_settings->opusOptimizeFor()); //comboBoxOpusOptimize->setCurrentIndex(m_settings->opusOptimizeFor());
ui->comboBoxOpusFramesize->setCurrentIndex(m_settings->opusFramesize()); ui->comboBoxOpusFramesize->setCurrentIndex(m_settings->opusFramesize());
@ -912,129 +916,6 @@ void MainWindow::initializeTranslation(void)
} }
} }
/*
* Get the current RC-Mode (for selected encoder)
*/
int MainWindow::getCurrentRCMode(int encoder)
{
int mode = -1;
switch(encoder)
{
case SettingsModel::MP3Encoder:
mode = m_settings->compressionRCModeLAME();
break;
case SettingsModel::VorbisEncoder:
mode = m_settings->compressionRCModeOggEnc();
break;
case SettingsModel::AACEncoder:
mode = m_settings->compressionRCModeAacEnc();
break;
case SettingsModel::AC3Encoder:
mode = m_settings->compressionRCModeAften();
break;
case SettingsModel::FLACEncoder:
mode = SettingsModel::VBRMode; /*FLAC has no RC modes*/
break;
case SettingsModel::OpusEncoder:
mode = m_settings->compressionRCModeOpusEnc();
break;
case SettingsModel::DCAEncoder:
mode = SettingsModel::CBRMode; /*DcaEnc has no RC modes*/
break;
case SettingsModel::PCMEncoder:
mode = SettingsModel::CBRMode; /*PCM has no RC modes*/
break;
default:
throw "getCurrentRCMode(): Unknown encoder specified!";
break;
}
return mode;
}
/*
* Get the current VBR-Level (for selected encoder)
*/
int MainWindow::getCurrentQuality(int encoder)
{
int quality = -1;
switch(encoder)
{
case SettingsModel::MP3Encoder:
quality = m_settings->compressionVbrLevelLAME();
break;
case SettingsModel::VorbisEncoder:
quality = m_settings->compressionVbrLevelOggEnc();
break;
case SettingsModel::AACEncoder:
quality = m_settings->compressionVbrLevelAacEnc();
break;
case SettingsModel::AC3Encoder:
quality = m_settings->compressionVbrLevelAften();
break;
case SettingsModel::FLACEncoder:
quality = m_settings->compressionVbrLevelFLAC();
break;
case SettingsModel::OpusEncoder:
quality = m_settings->compressionBitrateOpusEnc();
break;
case SettingsModel::DCAEncoder:
quality = 0; /*DcaEnc has no quality level*/
break;
case SettingsModel::PCMEncoder:
quality = 1; /*PCM has no quality level*/
break;
default:
throw "getCurrentVbrLevel(): Unknown encoder specified!";
break;
}
return quality;
}
/*
* Get the current Bitrate (for selected encoder)
*/
int MainWindow::getCurrentBitrate(int encoder)
{
int bitrate = -1;
switch(encoder)
{
case SettingsModel::MP3Encoder:
bitrate = m_settings->compressionBitrateLAME();
break;
case SettingsModel::VorbisEncoder:
bitrate = m_settings->compressionBitrateOggEnc();
break;
case SettingsModel::AACEncoder:
bitrate = m_settings->compressionBitrateAacEnc();
break;
case SettingsModel::AC3Encoder:
bitrate = m_settings->compressionBitrateAften();
break;
case SettingsModel::FLACEncoder:
bitrate = 0; /*FLAC has no bitrate*/
break;
case SettingsModel::OpusEncoder:
bitrate = m_settings->compressionBitrateOpusEnc();
break;
case SettingsModel::DCAEncoder:
bitrate = m_settings->compressionBitrateDcaEnc();
break;
case SettingsModel::PCMEncoder:
bitrate = 1; /*PCM has no bitrate*/
break;
default:
throw "getCurrentBitrate(): Unknown encoder specified!";
break;
}
return bitrate;
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// EVENTS // EVENTS
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -3409,81 +3290,46 @@ void MainWindow::playlistEnabledChanged(void)
void MainWindow::updateEncoder(int id) void MainWindow::updateEncoder(int id)
{ {
m_settings->compressionEncoder(id); m_settings->compressionEncoder(id);
const AbstractEncoderInfo *info = EncoderRegistry::getEncoderInfo(id);
bool bSupportsVBR = false;
bool bSupportsABR = false;;
bool bSupportsCBR = false;
bool bSliderEnabled = false;
//Set encoder-specific features
switch(m_settings->compressionEncoder())
{
case SettingsModel::MP3Encoder:
case SettingsModel::AACEncoder:
case SettingsModel::OpusEncoder:
bSupportsVBR = bSupportsABR = bSupportsCBR = bSliderEnabled = true;
break;
case SettingsModel::VorbisEncoder:
bSupportsVBR = bSupportsABR = bSliderEnabled = true;
break;
case SettingsModel::AC3Encoder:
bSupportsVBR = bSupportsCBR = bSliderEnabled = true;
break;
case SettingsModel::FLACEncoder:
bSupportsVBR = bSliderEnabled = true;
break;
case SettingsModel::DCAEncoder:
bSupportsCBR = bSliderEnabled = true;
break;
case SettingsModel::PCMEncoder:
bSupportsCBR = true;
break;
default:
throw "updateEncoder(): Unknown encoder encountered!";
break;
}
//Update UI controls //Update UI controls
ui->radioButtonModeQuality->setEnabled(bSupportsVBR); ui->radioButtonModeQuality->setEnabled(info->isModeSupported(SettingsModel::VBRMode));
ui->radioButtonModeAverageBitrate->setEnabled(bSupportsABR); ui->radioButtonModeAverageBitrate->setEnabled(info->isModeSupported(SettingsModel::ABRMode));
ui->radioButtonConstBitrate->setEnabled(bSupportsCBR); ui->radioButtonConstBitrate->setEnabled(info->isModeSupported(SettingsModel::CBRMode));
ui->sliderBitrate->setEnabled(bSliderEnabled);
//Add AAC info //Initialize checkbox state
if(m_settings->compressionEncoder() == SettingsModel::AACEncoder) if(ui->radioButtonConstBitrate->isEnabled()) ui->radioButtonConstBitrate->setChecked(true);
if(ui->radioButtonModeAverageBitrate->isEnabled()) ui->radioButtonModeAverageBitrate->setChecked(true);
if(ui->radioButtonModeQuality->isEnabled()) ui->radioButtonModeQuality->setChecked(true);
//Apply current RC mode
const int currentRCMode = EncoderRegistry::loadEncoderMode(m_settings, id);
switch(currentRCMode)
{
case SettingsModel::VBRMode:
if(ui->radioButtonModeQuality->isEnabled()) ui->radioButtonModeQuality->setChecked(true);
break;
case SettingsModel::ABRMode:
if(ui->radioButtonModeAverageBitrate->isEnabled()) ui->radioButtonModeAverageBitrate->setChecked(true);
break;
case SettingsModel::CBRMode:
if(ui->radioButtonConstBitrate->isEnabled()) ui->radioButtonConstBitrate->setChecked(true);
break;
default:
throw "updateEncoder(): Unknown rc-mode encountered!";
}
//Display encoder description
if(const char* description = info->description())
{ {
QString encoderName = tr("Not available!");
switch(m_aacEncoder)
{
case SettingsModel::AAC_ENCODER_NERO: encoderName = tr("Nero AAC"); break;
case SettingsModel::AAC_ENCODER_FHG : encoderName = tr("FHG AAC (Winamp)"); break;
case SettingsModel::AAC_ENCODER_QAAC: encoderName = tr("QAAC (Apple)"); break;
}
ui->labelEncoderInfo->setVisible(true); ui->labelEncoderInfo->setVisible(true);
ui->labelEncoderInfo->setText(tr("Current AAC Encoder: %1").arg(encoderName)); ui->labelEncoderInfo->setText(tr("Current Encoder: %1").arg(QString::fromUtf8(description)));
} }
else else
{ {
ui->labelEncoderInfo->setVisible(false); ui->labelEncoderInfo->setVisible(false);
} }
//Set current RC mode
const int currentRCMode = getCurrentRCMode(id);
switch(currentRCMode)
{
case SettingsModel::VBRMode:
ui->radioButtonModeQuality->setChecked(true);
break;
case SettingsModel::ABRMode:
ui->radioButtonModeAverageBitrate->setChecked(true);
break;
case SettingsModel::CBRMode:
ui->radioButtonConstBitrate->setChecked(true);
break;
default:
throw "updateEncoder(): Unknown rc-mode encountered!";
}
//Update RC mode! //Update RC mode!
updateRCMode(currentRCMode); updateRCMode(currentRCMode);
} }
@ -3493,195 +3339,40 @@ void MainWindow::updateEncoder(int id)
*/ */
void MainWindow::updateRCMode(int id) void MainWindow::updateRCMode(int id)
{ {
int sliderMin = INT_MIN; //Store new RC mode
int sliderMax = INT_MAX; const int currentEncoder = m_encoderButtonGroup->checkedId();
EncoderRegistry::saveEncoderMode(m_settings, currentEncoder, id);
//Update encoder-specific settings //Fetch encoder info
const int currentEncoder = m_settings->compressionEncoder(); const AbstractEncoderInfo *info = EncoderRegistry::getEncoderInfo(currentEncoder);
switch(currentEncoder) const int valueCount = info->valueCount(id);
{
/* -------- MP3Encoder -------- */
case SettingsModel::MP3Encoder:
switch(id)
{
case SettingsModel::VBRMode:
sliderMin = 0;
sliderMax = 9;
break;
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 0;
sliderMax = 13;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
m_settings->compressionRCModeLAME(id);
break;
/* -------- VorbisEncoder -------- */
case SettingsModel::VorbisEncoder:
switch(id)
{
case SettingsModel::VBRMode:
sliderMin = -2;
sliderMax = 10;
break;
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 4;
sliderMax = 63;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
m_settings->compressionRCModeOggEnc(id);
break;
/* -------- AACEncoder -------- */
case SettingsModel::AACEncoder:
switch(id)
{
case SettingsModel::VBRMode:
switch(m_aacEncoder)
{
case SettingsModel::AAC_ENCODER_QAAC:
sliderMin = 0;
sliderMax = 32;
break;
case SettingsModel::AAC_ENCODER_FHG:
sliderMin = 1;
sliderMax = 6;
break;
case SettingsModel::AAC_ENCODER_NERO:
sliderMin = 0;
sliderMax = 20;
break;
default:
throw "updateRCMode(): Unknown AAC encoder specified!";
break;
}
break;
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 4;
sliderMax = 63;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
m_settings->compressionRCModeAacEnc(id);
break;
/* -------- AC3Encoder -------- */
case SettingsModel::AC3Encoder:
switch(id)
{
case SettingsModel::VBRMode:
sliderMin = 0;
sliderMax = 16;
break;
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 0;
sliderMax = 18;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
m_settings->compressionRCModeAften(id);
break;
/* -------- FLACEncoder -------- */
case SettingsModel::FLACEncoder:
switch(id)
{
case SettingsModel::VBRMode:
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 0;
sliderMax = 8;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
break;
/* -------- OpusEncoder -------- */
case SettingsModel::OpusEncoder:
switch(id)
{
case SettingsModel::VBRMode:
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 1;
sliderMax = 32;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
m_settings->compressionRCModeOpusEnc(id);
break;
/* -------- DCAEncoder -------- */
case SettingsModel::DCAEncoder:
switch(id)
{
case SettingsModel::VBRMode:
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 1;
sliderMax = 128;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
break;
/* -------- PCMEncoder -------- */
case SettingsModel::PCMEncoder:
switch(id)
{
case SettingsModel::VBRMode:
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderMin = 0;
sliderMax = 2;
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
}
break;
/* -------- default -------- */
default:
throw "updateRCMode(): Unknown encoder specified!";
break;
}
//Update slider min/max values //Update slider min/max values
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMinimum, sliderMin); if(valueCount > 0)
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMaximum, sliderMax);
//Update slider position
int currentPosition = INT_MAX;
switch(id)
{ {
case SettingsModel::VBRMode: WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setEnabled, true);
currentPosition = getCurrentQuality(currentEncoder); WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMinimum, 0);
break; WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMaximum, valueCount-1);
case SettingsModel::ABRMode: }
case SettingsModel::CBRMode: else
currentPosition = getCurrentBitrate(currentEncoder); {
break; WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setEnabled, false);
default: WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMinimum, 0);
throw "updateRCMode(): Unknown rc-mode specified!"; WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMaximum, 2);
break;
} }
//Update bitrate/quality value! //Now update bitrate/quality value!
ui->sliderBitrate->setValue(currentPosition); if(valueCount > 0)
updateBitrate(currentPosition); {
const int currentValue = qBound(0, EncoderRegistry::loadEncoderValue(m_settings, currentEncoder, id), valueCount-1);
ui->sliderBitrate->setValue(currentValue);
updateBitrate(currentValue);
}
else
{
ui->sliderBitrate->setValue(1);
updateBitrate(0);
}
} }
/* /*
@ -3689,189 +3380,43 @@ void MainWindow::updateRCMode(int id)
*/ */
void MainWindow::updateBitrate(int value) void MainWindow::updateBitrate(int value)
{ {
//Update encoder-specific settings //Load current encoder and RC mode
const int currentEncoder = m_settings->compressionEncoder(); const int currentEncoder = m_encoderButtonGroup->checkedId();
const int currentRCMode = getCurrentRCMode(currentEncoder); const int currentRCMode = EncoderRegistry::loadEncoderMode(m_settings, currentEncoder);
QString sliderText; //Fetch encoder info
const AbstractEncoderInfo *info = EncoderRegistry::getEncoderInfo(currentEncoder);
const int valueCount = info->valueCount(currentRCMode);
switch(currentEncoder) //Store new bitrate valie
if(valueCount > 0)
{ {
/* -------- MP3Encoder -------- */ EncoderRegistry::saveEncoderValue(m_settings, currentEncoder, currentRCMode, qBound(0, value, valueCount-1));
case SettingsModel::MP3Encoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
sliderText = tr("Quality Level %1").arg(9 - value);
m_settings->compressionVbrLevelLAME(value);
break;
case SettingsModel::ABRMode:
sliderText = QString("≈ %1 kbps").arg(SettingsModel::mp3Bitrates[value]);
m_settings->compressionBitrateLAME(value);
break;
case SettingsModel::CBRMode:
sliderText = QString("%1 kbps").arg(SettingsModel::mp3Bitrates[value]);
m_settings->compressionBitrateLAME(value);
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- VorbisEncoder -------- */
case SettingsModel::VorbisEncoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
sliderText = tr("Quality Level %1").arg(value);
m_settings->compressionVbrLevelOggEnc(value);
break;
case SettingsModel::ABRMode:
sliderText = QString("≈ %1 kbps").arg(qMin(500, value * 8));
m_settings->compressionBitrateOggEnc(value);
break;
case SettingsModel::CBRMode:
sliderText = QString("%1 kbps").arg(qMin(500, value * 8));
m_settings->compressionBitrateOggEnc(value);
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- AACEncoder -------- */
case SettingsModel::AACEncoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
switch(m_aacEncoder)
{
case SettingsModel::AAC_ENCODER_QAAC:
sliderText = tr("Quality Level %1").arg(QString::number(qBound(0, value * 4 , 127)));
break;
case SettingsModel::AAC_ENCODER_FHG:
sliderText = tr("Quality Level %1").arg(QString::number(value));
break;
case SettingsModel::AAC_ENCODER_NERO:
sliderText = tr("Quality Level %1").arg(QString().sprintf("%.2f", static_cast<double>(value) / 20.0));
break;
default:
throw "updateBitrate(): Unknown AAC encoder specified!";
break;
}
m_settings->compressionVbrLevelAacEnc(value);
break;
case SettingsModel::ABRMode:
sliderText = QString("&asymp; %1 kbps").arg(qMin(500, value * 8));
m_settings->compressionBitrateAacEnc(value);
break;
case SettingsModel::CBRMode:
sliderText = QString("%1 kbps").arg(qMin(500, value * 8));
m_settings->compressionBitrateAacEnc(value);
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- AC3Encoder -------- */
case SettingsModel::AC3Encoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
sliderText = tr("Quality Level %1").arg(qMin(1024, qMax(0, value * 64)));
m_settings->compressionVbrLevelAften(value);
break;
case SettingsModel::ABRMode:
sliderText = QString("&asymp; %1 kbps").arg(SettingsModel::ac3Bitrates[value]);
m_settings->compressionBitrateAften(value);
break;
case SettingsModel::CBRMode:
sliderText = QString("%1 kbps").arg(SettingsModel::ac3Bitrates[value]);
m_settings->compressionBitrateAften(value);
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- FLACEncoder -------- */
case SettingsModel::FLACEncoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
sliderText = tr("Compression %1").arg(value);
m_settings->compressionVbrLevelFLAC(value);
break;
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
qWarning("FLAC does *not* support ABR or CBR mode!");
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- OpusEncoder -------- */
case SettingsModel::OpusEncoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
sliderText = QString("&asymp; %1 kbps").arg(qMin(500, value * 8));
m_settings->compressionBitrateOpusEnc(value);
break;
case SettingsModel::ABRMode:
sliderText = QString("&asymp; %1 kbps").arg(qMin(500, value * 8));
m_settings->compressionBitrateOpusEnc(value);
break;
case SettingsModel::CBRMode:
sliderText = QString("%1 kbps").arg(qMin(500, value * 8));
m_settings->compressionBitrateOpusEnc(value);
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- DCAEncoder -------- */
case SettingsModel::DCAEncoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
case SettingsModel::ABRMode:
qWarning("DcaEnc does *not* support VBR or ABR mode!");
break;
case SettingsModel::CBRMode:
sliderText = QString("%1 kbps").arg(value * 32);
m_settings->compressionBitrateDcaEnc(value);
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- PCMEncoder -------- */
case SettingsModel::PCMEncoder:
switch(currentRCMode)
{
case SettingsModel::VBRMode:
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
sliderText = tr("Uncompressed");
break;
default:
throw "updateBitrate(): Unknown rc-mode specified!";
break;
}
break;
/* -------- default -------- */
default:
throw "updateBitrate(): Unknown encoder specified!";
break;
} }
//Update slider text //Update bitrate value
ui->labelBitrate->setText(sliderText); const int displayValue = (valueCount > 0) ? info->valueAt(currentRCMode, qBound(0, value, valueCount-1)) : INT_MAX;
switch(info->valueType(currentRCMode))
{
case AbstractEncoderInfo::TYPE_BITRATE:
ui->labelBitrate->setText(QString("%1 kbps").arg(QString::number(displayValue)));
break;
case AbstractEncoderInfo::TYPE_APPROX_BITRATE:
ui->labelBitrate->setText(QString("&asymp; %1 kbps").arg(QString::number(displayValue)));
break;
case AbstractEncoderInfo::TYPE_QUALITY_LEVEL:
ui->labelBitrate->setText(tr("Quality Level %1").arg(QString::number(displayValue)));
break;
case AbstractEncoderInfo::TYPE_COMPRESSION_LEVEL:
ui->labelBitrate->setText(tr("Compression %1").arg(QString::number(displayValue)));
break;
case AbstractEncoderInfo::TYPE_UNCOMPRESSED:
ui->labelBitrate->setText(tr("Uncompressed"));
break;
default:
throw "Unknown display value type encountered!";
break;
}
} }
/* /*
@ -4094,7 +3639,7 @@ void MainWindow::normalizationMaxVolumeChanged(double value)
*/ */
void MainWindow::normalizationModeChanged(int mode) void MainWindow::normalizationModeChanged(int mode)
{ {
m_settings->normalizationFilterEqualizationMode(mode); m_settings->normalizationFilterEQMode(mode);
} }
/* /*
@ -4452,7 +3997,7 @@ void MainWindow::resetAdvancedOptionsButtonClicked(void)
ui->comboBoxAACProfile->setCurrentIndex(m_settings->aacEncProfileDefault()); ui->comboBoxAACProfile->setCurrentIndex(m_settings->aacEncProfileDefault());
ui->comboBoxAftenCodingMode->setCurrentIndex(m_settings->aftenAudioCodingModeDefault()); ui->comboBoxAftenCodingMode->setCurrentIndex(m_settings->aftenAudioCodingModeDefault());
ui->comboBoxAftenDRCMode->setCurrentIndex(m_settings->aftenDynamicRangeCompressionDefault()); ui->comboBoxAftenDRCMode->setCurrentIndex(m_settings->aftenDynamicRangeCompressionDefault());
ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEqualizationModeDefault()); ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEQModeDefault());
ui->comboBoxOpusFramesize->setCurrentIndex(m_settings->opusFramesizeDefault()); ui->comboBoxOpusFramesize->setCurrentIndex(m_settings->opusFramesizeDefault());
SET_CHECKBOX_STATE(ui->checkBoxBitrateManagement, m_settings->bitrateManagementEnabledDefault()); SET_CHECKBOX_STATE(ui->checkBoxBitrateManagement, m_settings->bitrateManagementEnabledDefault());

3
src/Dialog_MainWindow.h
View File

@ -186,9 +186,6 @@ private:
bool checkForUpdates(void); bool checkForUpdates(void);
void initializeTranslation(void); void initializeTranslation(void);
void refreshFavorites(void); void refreshFavorites(void);
int getCurrentRCMode(int encoder);
int getCurrentQuality(int encoder);
int getCurrentBitrate(int encoder);
bool m_accepted; bool m_accepted;
bool m_firstTimeShown; bool m_firstTimeShown;

333
src/Dialog_Processing.cpp
View File

@ -34,17 +34,8 @@
#include "Thread_RAMObserver.h" #include "Thread_RAMObserver.h"
#include "Thread_DiskObserver.h" #include "Thread_DiskObserver.h"
#include "Dialog_LogView.h" #include "Dialog_LogView.h"
#include "Encoder_AAC.h"
#include "Encoder_AAC_FHG.h"
#include "Encoder_AAC_QAAC.h"
#include "Encoder_AC3.h"
#include "Encoder_DCA.h"
#include "Encoder_FLAC.h"
#include "Encoder_MP3.h"
#include "Encoder_Vorbis.h"
#include "Encoder_Opus.h"
#include "Encoder_Wave.h"
#include "Registry_Decoder.h" #include "Registry_Decoder.h"
#include "Registry_Encoder.h"
#include "Filter_Downmix.h" #include "Filter_Downmix.h"
#include "Filter_Normalize.h" #include "Filter_Normalize.h"
#include "Filter_Resample.h" #include "Filter_Resample.h"
@ -144,7 +135,7 @@ ProcessingDialog::ProcessingDialog(FileListModel *fileListModel, AudioFileModel
: :
QDialog(parent), QDialog(parent),
ui(new Ui::ProcessingDialog), ui(new Ui::ProcessingDialog),
m_aacEncoder(SettingsModel::getAacEncoder()), //m_aacEncoder(SettingsModel::getAacEncoder()),
m_systemTray(new QSystemTrayIcon(QIcon(":/icons/cd_go.png"), this)), m_systemTray(new QSystemTrayIcon(QIcon(":/icons/cd_go.png"), this)),
m_settings(settings), m_settings(settings),
m_metaInfo(metaInfo), m_metaInfo(metaInfo),
@ -884,7 +875,7 @@ void ProcessingDialog::startNextJob(void)
bool nativeResampling = false; bool nativeResampling = false;
//Create encoder instance //Create encoder instance
AbstractEncoder *encoder = makeEncoder(&nativeResampling); AbstractEncoder *encoder = EncoderRegistry::createInstance(m_settings->compressionEncoder(), m_settings, &nativeResampling);
//Create processing thread //Create processing thread
ProcessThread *thread = new ProcessThread ProcessThread *thread = new ProcessThread
@ -914,7 +905,7 @@ void ProcessingDialog::startNextJob(void)
} }
if(m_settings->normalizationFilterEnabled()) if(m_settings->normalizationFilterEnabled())
{ {
thread->addFilter(new NormalizeFilter(m_settings->normalizationFilterMaxVolume(), m_settings->normalizationFilterEqualizationMode())); thread->addFilter(new NormalizeFilter(m_settings->normalizationFilterMaxVolume(), m_settings->normalizationFilterEQMode()));
} }
if(m_settings->renameOutputFilesEnabled() && (!m_settings->renameOutputFilesPattern().simplified().isEmpty())) if(m_settings->renameOutputFilesEnabled() && (!m_settings->renameOutputFilesPattern().simplified().isEmpty()))
{ {
@ -946,164 +937,164 @@ void ProcessingDialog::startNextJob(void)
} }
} }
AbstractEncoder *ProcessingDialog::makeEncoder(bool *nativeResampling) //AbstractEncoder *ProcessingDialog::makeEncoder(bool *nativeResampling)
{ //{
int rcMode = -1; // int rcMode = -1;
AbstractEncoder *encoder = NULL; // AbstractEncoder *encoder = NULL;
*nativeResampling = false; // *nativeResampling = false;
//
switch(m_settings->compressionEncoder()) // switch(m_settings->compressionEncoder())
{ // {
/*-------- MP3Encoder /*--------*/ // /*-------- MP3Encoder /*--------*/
case SettingsModel::MP3Encoder: // case SettingsModel::MP3Encoder:
{ // {
MP3Encoder *mp3Encoder = new MP3Encoder(); // MP3Encoder *mp3Encoder = new MP3Encoder();
mp3Encoder->setRCMode(rcMode = m_settings->compressionRCModeLAME()); // mp3Encoder->setRCMode(rcMode = m_settings->compressionRCModeLAME());
mp3Encoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelLAME() : m_settings->compressionBitrateLAME()); // mp3Encoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelLAME() : m_settings->compressionBitrateLAME());
mp3Encoder->setAlgoQuality(m_settings->lameAlgoQuality()); // mp3Encoder->setAlgoQuality(m_settings->lameAlgoQuality());
if(m_settings->bitrateManagementEnabled()) // if(m_settings->bitrateManagementEnabled())
{ // {
mp3Encoder->setBitrateLimits(m_settings->bitrateManagementMinRate(), m_settings->bitrateManagementMaxRate()); // mp3Encoder->setBitrateLimits(m_settings->bitrateManagementMinRate(), m_settings->bitrateManagementMaxRate());
} // }
if(m_settings->samplingRate() > 0) // if(m_settings->samplingRate() > 0)
{ // {
mp3Encoder->setSamplingRate(SettingsModel::samplingRates[m_settings->samplingRate()]); // mp3Encoder->setSamplingRate(SettingsModel::samplingRates[m_settings->samplingRate()]);
*nativeResampling = true; // *nativeResampling = true;
} // }
mp3Encoder->setChannelMode(m_settings->lameChannelMode()); // mp3Encoder->setChannelMode(m_settings->lameChannelMode());
mp3Encoder->setCustomParams(m_settings->customParametersLAME()); // mp3Encoder->setCustomParams(m_settings->customParametersLAME());
encoder = mp3Encoder; // encoder = mp3Encoder;
} // }
break; // break;
/*-------- VorbisEncoder /*--------*/ // /*-------- VorbisEncoder /*--------*/
case SettingsModel::VorbisEncoder: // case SettingsModel::VorbisEncoder:
{ // {
VorbisEncoder *vorbisEncoder = new VorbisEncoder(); // VorbisEncoder *vorbisEncoder = new VorbisEncoder();
vorbisEncoder->setRCMode(rcMode = m_settings->compressionRCModeOggEnc()); // vorbisEncoder->setRCMode(rcMode = m_settings->compressionRCModeOggEnc());
vorbisEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelOggEnc() : m_settings->compressionBitrateOggEnc()); // vorbisEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelOggEnc() : m_settings->compressionBitrateOggEnc());
if(m_settings->bitrateManagementEnabled()) // if(m_settings->bitrateManagementEnabled())
{ // {
vorbisEncoder->setBitrateLimits(m_settings->bitrateManagementMinRate(), m_settings->bitrateManagementMaxRate()); // vorbisEncoder->setBitrateLimits(m_settings->bitrateManagementMinRate(), m_settings->bitrateManagementMaxRate());
} // }
if(m_settings->samplingRate() > 0) // if(m_settings->samplingRate() > 0)
{ // {
vorbisEncoder->setSamplingRate(SettingsModel::samplingRates[m_settings->samplingRate()]); // vorbisEncoder->setSamplingRate(SettingsModel::samplingRates[m_settings->samplingRate()]);
*nativeResampling = true; // *nativeResampling = true;
} // }
vorbisEncoder->setCustomParams(m_settings->customParametersOggEnc()); // vorbisEncoder->setCustomParams(m_settings->customParametersOggEnc());
encoder = vorbisEncoder; // encoder = vorbisEncoder;
} // }
break; // break;
/*-------- AACEncoder /*--------*/ // /*-------- AACEncoder /*--------*/
case SettingsModel::AACEncoder: // case SettingsModel::AACEncoder:
{ // {
switch(m_aacEncoder) // switch(m_aacEncoder)
{ // {
case SettingsModel::AAC_ENCODER_QAAC: // case SettingsModel::AAC_ENCODER_QAAC:
{ // {
QAACEncoder *aacEncoder = new QAACEncoder(); // QAACEncoder *aacEncoder = new QAACEncoder();
aacEncoder->setRCMode(rcMode = m_settings->compressionRCModeAacEnc()); // aacEncoder->setRCMode(rcMode = m_settings->compressionRCModeAacEnc());
aacEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAacEnc() : m_settings->compressionBitrateAacEnc()); // aacEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAacEnc() : m_settings->compressionBitrateAacEnc());
aacEncoder->setProfile(m_settings->aacEncProfile()); // aacEncoder->setProfile(m_settings->aacEncProfile());
aacEncoder->setCustomParams(m_settings->customParametersAacEnc()); // aacEncoder->setCustomParams(m_settings->customParametersAacEnc());
encoder = aacEncoder; // encoder = aacEncoder;
} // }
break; // break;
case SettingsModel::AAC_ENCODER_FHG: // case SettingsModel::AAC_ENCODER_FHG:
{ // {
FHGAACEncoder *aacEncoder = new FHGAACEncoder(); // FHGAACEncoder *aacEncoder = new FHGAACEncoder();
aacEncoder->setRCMode(rcMode = m_settings->compressionRCModeAacEnc()); // aacEncoder->setRCMode(rcMode = m_settings->compressionRCModeAacEnc());
aacEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAacEnc() : m_settings->compressionBitrateAacEnc()); // aacEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAacEnc() : m_settings->compressionBitrateAacEnc());
aacEncoder->setProfile(m_settings->aacEncProfile()); // aacEncoder->setProfile(m_settings->aacEncProfile());
aacEncoder->setCustomParams(m_settings->customParametersAacEnc()); // aacEncoder->setCustomParams(m_settings->customParametersAacEnc());
encoder = aacEncoder; // encoder = aacEncoder;
} // }
break; // break;
case SettingsModel::AAC_ENCODER_NERO: // case SettingsModel::AAC_ENCODER_NERO:
{ // {
AACEncoder *aacEncoder = new AACEncoder(); // AACEncoder *aacEncoder = new AACEncoder();
aacEncoder->setRCMode(rcMode = m_settings->compressionRCModeAacEnc()); // aacEncoder->setRCMode(rcMode = m_settings->compressionRCModeAacEnc());
aacEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAacEnc() : m_settings->compressionBitrateAacEnc()); // aacEncoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAacEnc() : m_settings->compressionBitrateAacEnc());
aacEncoder->setEnable2Pass(m_settings->neroAACEnable2Pass()); // aacEncoder->setEnable2Pass(m_settings->neroAACEnable2Pass());
aacEncoder->setProfile(m_settings->aacEncProfile()); // aacEncoder->setProfile(m_settings->aacEncProfile());
aacEncoder->setCustomParams(m_settings->customParametersAacEnc()); // aacEncoder->setCustomParams(m_settings->customParametersAacEnc());
encoder = aacEncoder; // encoder = aacEncoder;
} // }
break; // break;
default: // default:
throw "makeEncoder(): Unknown AAC encoder specified!"; // throw "makeEncoder(): Unknown AAC encoder specified!";
break; // break;
} // }
} // }
break; // break;
/*-------- AC3Encoder /*--------*/ // /*-------- AC3Encoder /*--------*/
case SettingsModel::AC3Encoder: // case SettingsModel::AC3Encoder:
{ // {
AC3Encoder *ac3Encoder = new AC3Encoder(); // AC3Encoder *ac3Encoder = new AC3Encoder();
ac3Encoder->setRCMode(rcMode = m_settings->compressionRCModeAften()); // ac3Encoder->setRCMode(rcMode = m_settings->compressionRCModeAften());
ac3Encoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAften() : m_settings->compressionBitrateAften()); // ac3Encoder->setBitrate(IS_VBR(rcMode) ? m_settings->compressionVbrLevelAften() : m_settings->compressionBitrateAften());
ac3Encoder->setCustomParams(m_settings->customParametersAften()); // ac3Encoder->setCustomParams(m_settings->customParametersAften());
ac3Encoder->setAudioCodingMode(m_settings->aftenAudioCodingMode()); // ac3Encoder->setAudioCodingMode(m_settings->aftenAudioCodingMode());
ac3Encoder->setDynamicRangeCompression(m_settings->aftenDynamicRangeCompression()); // ac3Encoder->setDynamicRangeCompression(m_settings->aftenDynamicRangeCompression());
ac3Encoder->setExponentSearchSize(m_settings->aftenExponentSearchSize()); // ac3Encoder->setExponentSearchSize(m_settings->aftenExponentSearchSize());
ac3Encoder->setFastBitAllocation(m_settings->aftenFastBitAllocation()); // ac3Encoder->setFastBitAllocation(m_settings->aftenFastBitAllocation());
encoder = ac3Encoder; // encoder = ac3Encoder;
} // }
break; // break;
/*-------- FLACEncoder /*--------*/ // /*-------- FLACEncoder /*--------*/
case SettingsModel::FLACEncoder: // case SettingsModel::FLACEncoder:
{ // {
FLACEncoder *flacEncoder = new FLACEncoder(); // FLACEncoder *flacEncoder = new FLACEncoder();
flacEncoder->setBitrate(m_settings->compressionVbrLevelFLAC()); // flacEncoder->setBitrate(m_settings->compressionVbrLevelFLAC());
flacEncoder->setRCMode(SettingsModel::VBRMode); // flacEncoder->setRCMode(SettingsModel::VBRMode);
flacEncoder->setCustomParams(m_settings->customParametersFLAC()); // flacEncoder->setCustomParams(m_settings->customParametersFLAC());
encoder = flacEncoder; // encoder = flacEncoder;
} // }
break; // break;
/*-------- OpusEncoder --------*/ // /*-------- OpusEncoder --------*/
case SettingsModel::OpusEncoder: // case SettingsModel::OpusEncoder:
{ // {
OpusEncoder *opusEncoder = new OpusEncoder(); // OpusEncoder *opusEncoder = new OpusEncoder();
opusEncoder->setRCMode(rcMode = m_settings->compressionRCModeOpusEnc()); // opusEncoder->setRCMode(rcMode = m_settings->compressionRCModeOpusEnc());
opusEncoder->setBitrate(m_settings->compressionBitrateOpusEnc()); /*Opus always uses bitrate*/ // opusEncoder->setBitrate(m_settings->compressionBitrateOpusEnc()); /*Opus always uses bitrate*/
opusEncoder->setOptimizeFor(m_settings->opusOptimizeFor()); // opusEncoder->setOptimizeFor(m_settings->opusOptimizeFor());
opusEncoder->setEncodeComplexity(m_settings->opusComplexity()); // opusEncoder->setEncodeComplexity(m_settings->opusComplexity());
opusEncoder->setFrameSize(m_settings->opusFramesize()); // opusEncoder->setFrameSize(m_settings->opusFramesize());
opusEncoder->setCustomParams(m_settings->customParametersOpus()); // opusEncoder->setCustomParams(m_settings->customParametersOpus());
encoder = opusEncoder; // encoder = opusEncoder;
} // }
break; // break;
/*-------- DCAEncoder --------*/ // /*-------- DCAEncoder --------*/
case SettingsModel::DCAEncoder: // case SettingsModel::DCAEncoder:
{ // {
DCAEncoder *dcaEncoder = new DCAEncoder(); // DCAEncoder *dcaEncoder = new DCAEncoder();
dcaEncoder->setRCMode(SettingsModel::CBRMode); // dcaEncoder->setRCMode(SettingsModel::CBRMode);
dcaEncoder->setBitrate(IS_VBR(rcMode) ? 0 : m_settings->compressionBitrateDcaEnc()); // dcaEncoder->setBitrate(IS_VBR(rcMode) ? 0 : m_settings->compressionBitrateDcaEnc());
encoder = dcaEncoder; // encoder = dcaEncoder;
} // }
break; // break;
/*-------- PCMEncoder --------*/ // /*-------- PCMEncoder --------*/
case SettingsModel::PCMEncoder: // case SettingsModel::PCMEncoder:
{ // {
WaveEncoder *waveEncoder = new WaveEncoder(); // WaveEncoder *waveEncoder = new WaveEncoder();
waveEncoder->setBitrate(0); /*does NOT apply to PCM output*/ // waveEncoder->setBitrate(0); /*does NOT apply to PCM output*/
waveEncoder->setRCMode(0); /*does NOT apply to PCM output*/ // waveEncoder->setRCMode(0); /*does NOT apply to PCM output*/
encoder = waveEncoder; // encoder = waveEncoder;
} // }
break; // break;
/*-------- default --------*/ // /*-------- default --------*/
default: // default:
throw "Unsupported encoder!"; // throw "Unsupported encoder!";
} // }
//
//Sanity checking // //Sanity checking
if(!encoder) // if(!encoder)
{ // {
throw "No encoder instance has been assigend!"; // throw "No encoder instance has been assigend!";
} // }
//
return encoder; // return encoder;
} //}
void ProcessingDialog::writePlayList(void) void ProcessingDialog::writePlayList(void)
{ {

4
src/Dialog_Processing.h
View File

@ -95,7 +95,6 @@ private:
void setCloseButtonEnabled(bool enabled); void setCloseButtonEnabled(bool enabled);
void startNextJob(void); void startNextJob(void);
AbstractEncoder *makeEncoder(bool *nativeResampling);
AudioFileModel updateMetaInfo(const AudioFileModel &audioFile); AudioFileModel updateMetaInfo(const AudioFileModel &audioFile);
void writePlayList(void); void writePlayList(void);
bool shutdownComputer(void); bool shutdownComputer(void);
@ -129,5 +128,6 @@ private:
qint64 m_timerStart; qint64 m_timerStart;
int m_progressViewFilter; int m_progressViewFilter;
const int m_aacEncoder; //const int m_aacEncoder;
//AbstractEncoder *makeEncoder(bool *nativeResampling);
}; };

4
src/Encoder_AC3.cpp
View File

@ -27,6 +27,8 @@
#include <QProcess> #include <QProcess>
#include <QDir> #include <QDir>
static const int g_ac3BitratesLUT[20] = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 576, 640, -1};
AC3Encoder::AC3Encoder(void) AC3Encoder::AC3Encoder(void)
: :
m_binary(lamexp_lookup_tool("aften.exe")) m_binary(lamexp_lookup_tool("aften.exe"))
@ -57,7 +59,7 @@ bool AC3Encoder::encode(const QString &sourceFile, const AudioFileModel &metaInf
args << "-q" << QString::number(qMax(0, qMin(1023, m_configBitrate * 64))); args << "-q" << QString::number(qMax(0, qMin(1023, m_configBitrate * 64)));
break; break;
case SettingsModel::CBRMode: case SettingsModel::CBRMode:
args << "-b" << QString::number(SettingsModel::ac3Bitrates[qMax(0, qMin(18, m_configBitrate))]); args << "-b" << QString::number(g_ac3BitratesLUT[qMax(0, qMin(18, m_configBitrate))]);
break; break;
default: default:
throw "Bad rate-control mode!"; throw "Bad rate-control mode!";

3
src/Encoder_Abstract.h
View File

@ -45,6 +45,7 @@ public:
virtual int valueCount(int mode) const = 0; //The number of bitrate/quality values for current RC mode virtual int valueCount(int mode) const = 0; //The number of bitrate/quality values for current RC mode
virtual int valueAt(int mode, int index) const = 0; //The bitrate/quality value at 'index' for the current RC mode virtual int valueAt(int mode, int index) const = 0; //The bitrate/quality value at 'index' for the current RC mode
virtual int valueType(int mode) const = 0; //The display type of the values for the current RC mode virtual int valueType(int mode) const = 0; //The display type of the values for the current RC mode
virtual const char* description(void) const = 0; //Description of the encoder that can be displayed to the user
}; };
class AbstractEncoder : public AbstractTool class AbstractEncoder : public AbstractTool
@ -72,7 +73,7 @@ public:
//Encoder info //Encoder info
static const AbstractEncoderInfo *getEncoderInfo(void) static const AbstractEncoderInfo *getEncoderInfo(void)
{ {
throw "This method is supposed to be re-implemented in derived classes!"; throw "This method shall be re-implemented in derived classes!";
return NULL; return NULL;
} }

12
src/Encoder_MP3.cpp
View File

@ -99,6 +99,12 @@ class : public AbstractEncoderInfo
throw "Bad RC mode specified!"; throw "Bad RC mode specified!";
} }
} }
virtual const char *description(void) const
{
static const char* s_description = "LAME MP3 Encoder";
return s_description;
}
} }
g_mp3EncoderInfo; g_mp3EncoderInfo;
@ -339,9 +345,9 @@ int MP3Encoder::clipBitrate(int bitrate)
int minDiff = INT_MAX; int minDiff = INT_MAX;
int minIndx = -1; int minIndx = -1;
for(int i = 0; SettingsModel::mp3Bitrates[i] > 0; i++) for(int i = 0; g_mp3BitrateLUT[i] > 0; i++)
{ {
int currentDiff = abs(targetBitrate - SettingsModel::mp3Bitrates[i]); int currentDiff = abs(targetBitrate - g_mp3BitrateLUT[i]);
if(currentDiff < minDiff) if(currentDiff < minDiff)
{ {
minDiff = currentDiff; minDiff = currentDiff;
@ -351,7 +357,7 @@ int MP3Encoder::clipBitrate(int bitrate)
if(minIndx >= 0) if(minIndx >= 0)
{ {
return SettingsModel::mp3Bitrates[minIndx]; return g_mp3BitrateLUT[minIndx];
} }
return targetBitrate; return targetBitrate;

164
src/Model_Settings.cpp
View File

@ -166,84 +166,90 @@ while(0)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//Setting ID's //Setting ID's
LAMEXP_MAKE_ID(aacEncProfile, "AdvancedOptions/AACEnc/ForceProfile"); LAMEXP_MAKE_ID(aacEncProfile, "AdvancedOptions/AACEnc/ForceProfile");
LAMEXP_MAKE_ID(aftenAudioCodingMode, "AdvancedOptions/Aften/AudioCodingMode"); LAMEXP_MAKE_ID(aftenAudioCodingMode, "AdvancedOptions/Aften/AudioCodingMode");
LAMEXP_MAKE_ID(aftenDynamicRangeCompression, "AdvancedOptions/Aften/DynamicRangeCompression"); LAMEXP_MAKE_ID(aftenDynamicRangeCompression, "AdvancedOptions/Aften/DynamicRangeCompression");
LAMEXP_MAKE_ID(aftenExponentSearchSize, "AdvancedOptions/Aften/ExponentSearchSize"); LAMEXP_MAKE_ID(aftenExponentSearchSize, "AdvancedOptions/Aften/ExponentSearchSize");
LAMEXP_MAKE_ID(aftenFastBitAllocation, "AdvancedOptions/Aften/FastBitAllocation"); LAMEXP_MAKE_ID(aftenFastBitAllocation, "AdvancedOptions/Aften/FastBitAllocation");
LAMEXP_MAKE_ID(antivirNotificationsEnabled, "Flags/EnableAntivirusNotifications"); LAMEXP_MAKE_ID(antivirNotificationsEnabled, "Flags/EnableAntivirusNotifications");
LAMEXP_MAKE_ID(autoUpdateCheckBeta, "AutoUpdate/CheckForBetaVersions"); LAMEXP_MAKE_ID(autoUpdateCheckBeta, "AutoUpdate/CheckForBetaVersions");
LAMEXP_MAKE_ID(autoUpdateEnabled, "AutoUpdate/Enabled"); LAMEXP_MAKE_ID(autoUpdateEnabled, "AutoUpdate/Enabled");
LAMEXP_MAKE_ID(autoUpdateLastCheck, "AutoUpdate/LastCheck"); LAMEXP_MAKE_ID(autoUpdateLastCheck, "AutoUpdate/LastCheck");
LAMEXP_MAKE_ID(bitrateManagementEnabled, "AdvancedOptions/BitrateManagement/Enabled"); LAMEXP_MAKE_ID(bitrateManagementEnabled, "AdvancedOptions/BitrateManagement/Enabled");
LAMEXP_MAKE_ID(bitrateManagementMaxRate, "AdvancedOptions/BitrateManagement/MaxRate"); LAMEXP_MAKE_ID(bitrateManagementMaxRate, "AdvancedOptions/BitrateManagement/MaxRate");
LAMEXP_MAKE_ID(bitrateManagementMinRate, "AdvancedOptions/BitrateManagement/MinRate"); LAMEXP_MAKE_ID(bitrateManagementMinRate, "AdvancedOptions/BitrateManagement/MinRate");
LAMEXP_MAKE_ID(compressionBitrateAacEnc, "Compression/Bitrate/AacEnc"); LAMEXP_MAKE_ID(compressionBitrateAacEnc, "Compression/Bitrate/AacEnc");
LAMEXP_MAKE_ID(compressionBitrateAften, "Compression/Bitrate/Aften"); LAMEXP_MAKE_ID(compressionBitrateAften, "Compression/Bitrate/Aften");
LAMEXP_MAKE_ID(compressionBitrateDcaEnc, "Compression/Bitrate/DcaEnc"); LAMEXP_MAKE_ID(compressionBitrateDcaEnc, "Compression/Bitrate/DcaEnc");
LAMEXP_MAKE_ID(compressionBitrateLAME, "Compression/Bitrate/LAME"); LAMEXP_MAKE_ID(compressionBitrateFLAC, "Compression/Bitrate/FLAC");
LAMEXP_MAKE_ID(compressionBitrateOggEnc, "Compression/Bitrate/OggEnc"); LAMEXP_MAKE_ID(compressionBitrateLAME, "Compression/Bitrate/LAME");
LAMEXP_MAKE_ID(compressionBitrateOpusEnc, "Compression/Bitrate/OpusEnc"); LAMEXP_MAKE_ID(compressionBitrateOggEnc, "Compression/Bitrate/OggEnc");
LAMEXP_MAKE_ID(compressionEncoder, "Compression/Encoder"); LAMEXP_MAKE_ID(compressionBitrateOpusEnc, "Compression/Bitrate/OpusEnc");
LAMEXP_MAKE_ID(compressionRCModeAacEnc, "Compression/RCMode/AacEnc"); LAMEXP_MAKE_ID(compressionBitrateWave, "Compression/Bitrate/Wave");
LAMEXP_MAKE_ID(compressionRCModeAften, "Compression/RCMode/Aften"); LAMEXP_MAKE_ID(compressionEncoder, "Compression/Encoder");
LAMEXP_MAKE_ID(compressionRCModeLAME, "Compression/RCMode/LAME"); LAMEXP_MAKE_ID(compressionRCModeAacEnc, "Compression/RCMode/AacEnc");
LAMEXP_MAKE_ID(compressionRCModeOggEnc, "Compression/RCMode/OggEnc"); LAMEXP_MAKE_ID(compressionRCModeAften, "Compression/RCMode/Aften");
LAMEXP_MAKE_ID(compressionRCModeOpusEnc, "Compression/RCMode/OpusEnc"); LAMEXP_MAKE_ID(compressionRCModeDcaEnc, "Compression/RCMode/DcaEnc");
LAMEXP_MAKE_ID(compressionVbrLevelAacEnc, "Compression/VbrLevel/AacEnc"); LAMEXP_MAKE_ID(compressionRCModeFLAC, "Compression/RCMode/FLAC");
LAMEXP_MAKE_ID(compressionVbrLevelAften, "Compression/VbrLevel/Aften"); LAMEXP_MAKE_ID(compressionRCModeLAME, "Compression/RCMode/LAME");
LAMEXP_MAKE_ID(compressionVbrLevelFLAC, "Compression/VbrLevel/FLAC"); LAMEXP_MAKE_ID(compressionRCModeOggEnc, "Compression/RCMode/OggEnc");
LAMEXP_MAKE_ID(compressionVbrLevelLAME, "Compression/VbrLevel/LAME"); LAMEXP_MAKE_ID(compressionRCModeOpusEnc, "Compression/RCMode/OpusEnc");
LAMEXP_MAKE_ID(compressionVbrLevelOggEnc, "Compression/VbrLevel/OggEnc"); LAMEXP_MAKE_ID(compressionRCModeWave, "Compression/RCMode/Wave");
LAMEXP_MAKE_ID(createPlaylist, "Flags/AutoCreatePlaylist"); LAMEXP_MAKE_ID(compressionVbrLevelAacEnc, "Compression/VbrLevel/AacEnc");
LAMEXP_MAKE_ID(currentLanguage, "Localization/Language"); LAMEXP_MAKE_ID(compressionVbrLevelAften, "Compression/VbrLevel/Aften");
LAMEXP_MAKE_ID(currentLanguageFile, "Localization/UseQMFile"); LAMEXP_MAKE_ID(compressionVbrLevelDcaEnc, "Compression/VbrLevel/DcaEnc");
LAMEXP_MAKE_ID(customParametersAacEnc, "AdvancedOptions/CustomParameters/AacEnc"); LAMEXP_MAKE_ID(compressionVbrLevelFLAC, "Compression/VbrLevel/FLAC");
LAMEXP_MAKE_ID(customParametersAften, "AdvancedOptions/CustomParameters/Aften"); LAMEXP_MAKE_ID(compressionVbrLevelLAME, "Compression/VbrLevel/LAME");
LAMEXP_MAKE_ID(customParametersFLAC, "AdvancedOptions/CustomParameters/FLAC"); LAMEXP_MAKE_ID(compressionVbrLevelOggEnc, "Compression/VbrLevel/OggEnc");
LAMEXP_MAKE_ID(customParametersLAME, "AdvancedOptions/CustomParameters/LAME"); LAMEXP_MAKE_ID(compressionVbrLevelOpusEnc, "Compression/VbrLevel/OpusEnc");
LAMEXP_MAKE_ID(customParametersOggEnc, "AdvancedOptions/CustomParameters/OggEnc"); LAMEXP_MAKE_ID(compressionVbrLevelWave, "Compression/VbrLevel/Wave");
LAMEXP_MAKE_ID(customParametersOpus, "AdvancedOptions/CustomParameters/OpusEnc"); LAMEXP_MAKE_ID(createPlaylist, "Flags/AutoCreatePlaylist");
LAMEXP_MAKE_ID(customTempPath, "AdvancedOptions/TempDirectory/CustomPath"); LAMEXP_MAKE_ID(currentLanguage, "Localization/Language");
LAMEXP_MAKE_ID(customTempPathEnabled, "AdvancedOptions/TempDirectory/UseCustomPath"); LAMEXP_MAKE_ID(currentLanguageFile, "Localization/UseQMFile");
LAMEXP_MAKE_ID(dropBoxWidgetEnabled, "Flags/EnableDropBoxWidget"); LAMEXP_MAKE_ID(customParametersAacEnc, "AdvancedOptions/CustomParameters/AacEnc");
LAMEXP_MAKE_ID(favoriteOutputFolders, "OutputDirectory/Favorites"); LAMEXP_MAKE_ID(customParametersAften, "AdvancedOptions/CustomParameters/Aften");
LAMEXP_MAKE_ID(forceStereoDownmix, "AdvancedOptions/StereoDownmix/Force"); LAMEXP_MAKE_ID(customParametersFLAC, "AdvancedOptions/CustomParameters/FLAC");
LAMEXP_MAKE_ID(hibernateComputer, "AdvancedOptions/HibernateComputerOnShutdown"); LAMEXP_MAKE_ID(customParametersLAME, "AdvancedOptions/CustomParameters/LAME");
LAMEXP_MAKE_ID(interfaceStyle, "InterfaceStyle"); LAMEXP_MAKE_ID(customParametersOggEnc, "AdvancedOptions/CustomParameters/OggEnc");
LAMEXP_MAKE_ID(lameAlgoQuality, "AdvancedOptions/LAME/AlgorithmQuality"); LAMEXP_MAKE_ID(customParametersOpus, "AdvancedOptions/CustomParameters/OpusEnc");
LAMEXP_MAKE_ID(lameChannelMode, "AdvancedOptions/LAME/ChannelMode"); LAMEXP_MAKE_ID(customTempPath, "AdvancedOptions/TempDirectory/CustomPath");
LAMEXP_MAKE_ID(licenseAccepted, "LicenseAccepted"); LAMEXP_MAKE_ID(customTempPathEnabled, "AdvancedOptions/TempDirectory/UseCustomPath");
LAMEXP_MAKE_ID(maximumInstances, "AdvancedOptions/Threading/MaximumInstances"); LAMEXP_MAKE_ID(dropBoxWidgetEnabled, "Flags/EnableDropBoxWidget");
LAMEXP_MAKE_ID(metaInfoPosition, "MetaInformation/PlaylistPosition"); LAMEXP_MAKE_ID(favoriteOutputFolders, "OutputDirectory/Favorites");
LAMEXP_MAKE_ID(mostRecentInputPath, "InputDirectory/MostRecentPath"); LAMEXP_MAKE_ID(forceStereoDownmix, "AdvancedOptions/StereoDownmix/Force");
LAMEXP_MAKE_ID(neroAACEnable2Pass, "AdvancedOptions/AACEnc/Enable2Pass"); LAMEXP_MAKE_ID(hibernateComputer, "AdvancedOptions/HibernateComputerOnShutdown");
LAMEXP_MAKE_ID(neroAacNotificationsEnabled, "Flags/EnableNeroAacNotifications"); LAMEXP_MAKE_ID(interfaceStyle, "InterfaceStyle");
LAMEXP_MAKE_ID(normalizationFilterEnabled, "AdvancedOptions/VolumeNormalization/Enabled"); LAMEXP_MAKE_ID(lameAlgoQuality, "AdvancedOptions/LAME/AlgorithmQuality");
LAMEXP_MAKE_ID(normalizationFilterEqualizationMode, "AdvancedOptions/VolumeNormalization/EqualizationMode"); LAMEXP_MAKE_ID(lameChannelMode, "AdvancedOptions/LAME/ChannelMode");
LAMEXP_MAKE_ID(licenseAccepted, "LicenseAccepted");
LAMEXP_MAKE_ID(maximumInstances, "AdvancedOptions/Threading/MaximumInstances");
LAMEXP_MAKE_ID(metaInfoPosition, "MetaInformation/PlaylistPosition");
LAMEXP_MAKE_ID(mostRecentInputPath, "InputDirectory/MostRecentPath");
LAMEXP_MAKE_ID(neroAACEnable2Pass, "AdvancedOptions/AACEnc/Enable2Pass");
LAMEXP_MAKE_ID(neroAacNotificationsEnabled, "Flags/EnableNeroAacNotifications");
LAMEXP_MAKE_ID(normalizationFilterEnabled, "AdvancedOptions/VolumeNormalization/Enabled");
LAMEXP_MAKE_ID(normalizationFilterEQMode, "AdvancedOptions/VolumeNormalization/EqualizationMode");
LAMEXP_MAKE_ID(normalizationFilterMaxVolume, "AdvancedOptions/VolumeNormalization/MaxVolume"); LAMEXP_MAKE_ID(normalizationFilterMaxVolume, "AdvancedOptions/VolumeNormalization/MaxVolume");
LAMEXP_MAKE_ID(opusComplexity, "AdvancedOptions/Opus/EncodingComplexity"); LAMEXP_MAKE_ID(opusComplexity, "AdvancedOptions/Opus/EncodingComplexity");
LAMEXP_MAKE_ID(opusDisableResample, "AdvancedOptions/Opus/DisableResample"); LAMEXP_MAKE_ID(opusDisableResample, "AdvancedOptions/Opus/DisableResample");
LAMEXP_MAKE_ID(opusFramesize, "AdvancedOptions/Opus/FrameSize"); LAMEXP_MAKE_ID(opusFramesize, "AdvancedOptions/Opus/FrameSize");
LAMEXP_MAKE_ID(opusOptimizeFor, "AdvancedOptions/Opus/OptimizeForSignalType"); LAMEXP_MAKE_ID(opusOptimizeFor, "AdvancedOptions/Opus/OptimizeForSignalType");
LAMEXP_MAKE_ID(outputDir, "OutputDirectory/SelectedPath"); LAMEXP_MAKE_ID(outputDir, "OutputDirectory/SelectedPath");
LAMEXP_MAKE_ID(outputToSourceDir, "OutputDirectory/OutputToSourceFolder"); LAMEXP_MAKE_ID(outputToSourceDir, "OutputDirectory/OutputToSourceFolder");
LAMEXP_MAKE_ID(overwriteMode, "AdvancedOptions/OverwriteMode"); LAMEXP_MAKE_ID(overwriteMode, "AdvancedOptions/OverwriteMode");
LAMEXP_MAKE_ID(prependRelativeSourcePath, "OutputDirectory/PrependRelativeSourcePath"); LAMEXP_MAKE_ID(prependRelativeSourcePath, "OutputDirectory/PrependRelativeSourcePath");
LAMEXP_MAKE_ID(renameOutputFilesEnabled, "AdvancedOptions/RenameOutputFiles/Enabled"); LAMEXP_MAKE_ID(renameOutputFilesEnabled, "AdvancedOptions/RenameOutputFiles/Enabled");
LAMEXP_MAKE_ID(renameOutputFilesPattern, "AdvancedOptions/RenameOutputFiles/Pattern"); LAMEXP_MAKE_ID(renameOutputFilesPattern, "AdvancedOptions/RenameOutputFiles/Pattern");
LAMEXP_MAKE_ID(samplingRate, "AdvancedOptions/Common/Resampling"); LAMEXP_MAKE_ID(samplingRate, "AdvancedOptions/Common/Resampling");
LAMEXP_MAKE_ID(shellIntegrationEnabled, "Flags/EnableShellIntegration"); LAMEXP_MAKE_ID(shellIntegrationEnabled, "Flags/EnableShellIntegration");
LAMEXP_MAKE_ID(slowStartup, "Flags/SlowStartupDetected"); LAMEXP_MAKE_ID(slowStartup, "Flags/SlowStartupDetected");
LAMEXP_MAKE_ID(soundsEnabled, "Flags/EnableSounds"); LAMEXP_MAKE_ID(soundsEnabled, "Flags/EnableSounds");
LAMEXP_MAKE_ID(toneAdjustBass, "AdvancedOptions/ToneAdjustment/Bass"); LAMEXP_MAKE_ID(toneAdjustBass, "AdvancedOptions/ToneAdjustment/Bass");
LAMEXP_MAKE_ID(toneAdjustTreble, "AdvancedOptions/ToneAdjustment/Treble"); LAMEXP_MAKE_ID(toneAdjustTreble, "AdvancedOptions/ToneAdjustment/Treble");
LAMEXP_MAKE_ID(versionNumber, "VersionNumber"); LAMEXP_MAKE_ID(versionNumber, "VersionNumber");
LAMEXP_MAKE_ID(writeMetaTags, "Flags/WriteMetaTags"); LAMEXP_MAKE_ID(writeMetaTags, "Flags/WriteMetaTags");
//LUT //LUT
const int SettingsModel::mp3Bitrates[15] = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1};
const int SettingsModel::ac3Bitrates[20] = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 576, 640, -1};
const int SettingsModel::samplingRates[8] = {0, 16000, 22050, 24000, 32000, 44100, 48000, -1}; const int SettingsModel::samplingRates[8] = {0, 16000, 22050, 24000, 32000, 44100, 48000, -1};
static QReadWriteLock s_lock; static QReadWriteLock s_lock;
@ -574,20 +580,28 @@ LAMEXP_MAKE_OPTION_I(bitrateManagementMinRate, 32)
LAMEXP_MAKE_OPTION_I(compressionBitrateAacEnc, 20) LAMEXP_MAKE_OPTION_I(compressionBitrateAacEnc, 20)
LAMEXP_MAKE_OPTION_I(compressionBitrateAften, 15) LAMEXP_MAKE_OPTION_I(compressionBitrateAften, 15)
LAMEXP_MAKE_OPTION_I(compressionBitrateDcaEnc, 47) LAMEXP_MAKE_OPTION_I(compressionBitrateDcaEnc, 47)
LAMEXP_MAKE_OPTION_I(compressionBitrateFLAC, 0)
LAMEXP_MAKE_OPTION_I(compressionBitrateLAME, 10) LAMEXP_MAKE_OPTION_I(compressionBitrateLAME, 10)
LAMEXP_MAKE_OPTION_I(compressionBitrateOggEnc, 20) LAMEXP_MAKE_OPTION_I(compressionBitrateOggEnc, 20)
LAMEXP_MAKE_OPTION_I(compressionBitrateOpusEnc, 16) LAMEXP_MAKE_OPTION_I(compressionBitrateOpusEnc, 16)
LAMEXP_MAKE_OPTION_I(compressionBitrateWave, 0)
LAMEXP_MAKE_OPTION_I(compressionEncoder, 0) LAMEXP_MAKE_OPTION_I(compressionEncoder, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeAacEnc, 0) LAMEXP_MAKE_OPTION_I(compressionRCModeAacEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeAften, 0) LAMEXP_MAKE_OPTION_I(compressionRCModeAften, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeDcaEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeFLAC, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeLAME, 0) LAMEXP_MAKE_OPTION_I(compressionRCModeLAME, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeOggEnc, 0) LAMEXP_MAKE_OPTION_I(compressionRCModeOggEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeOpusEnc, 0) LAMEXP_MAKE_OPTION_I(compressionRCModeOpusEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeWave, 0)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAacEnc, 10) LAMEXP_MAKE_OPTION_I(compressionVbrLevelAacEnc, 10)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAften, 8) LAMEXP_MAKE_OPTION_I(compressionVbrLevelAften, 8)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelDcaEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelFLAC, 8) LAMEXP_MAKE_OPTION_I(compressionVbrLevelFLAC, 8)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelLAME, 7) LAMEXP_MAKE_OPTION_I(compressionVbrLevelLAME, 7)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelOggEnc, 5) LAMEXP_MAKE_OPTION_I(compressionVbrLevelOggEnc, 5)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelOpusEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelWave, 0)
LAMEXP_MAKE_OPTION_B(createPlaylist, true) LAMEXP_MAKE_OPTION_B(createPlaylist, true)
LAMEXP_MAKE_OPTION_S(currentLanguage, defaultLanguage()) LAMEXP_MAKE_OPTION_S(currentLanguage, defaultLanguage())
LAMEXP_MAKE_OPTION_S(currentLanguageFile, QString()) LAMEXP_MAKE_OPTION_S(currentLanguageFile, QString())
@ -613,7 +627,7 @@ LAMEXP_MAKE_OPTION_S(mostRecentInputPath, defaultDirectory())
LAMEXP_MAKE_OPTION_B(neroAACEnable2Pass, true) LAMEXP_MAKE_OPTION_B(neroAACEnable2Pass, true)
LAMEXP_MAKE_OPTION_B(neroAacNotificationsEnabled, true) LAMEXP_MAKE_OPTION_B(neroAacNotificationsEnabled, true)
LAMEXP_MAKE_OPTION_B(normalizationFilterEnabled, false) LAMEXP_MAKE_OPTION_B(normalizationFilterEnabled, false)
LAMEXP_MAKE_OPTION_I(normalizationFilterEqualizationMode, 0) LAMEXP_MAKE_OPTION_I(normalizationFilterEQMode, 0)
LAMEXP_MAKE_OPTION_I(normalizationFilterMaxVolume, -50) LAMEXP_MAKE_OPTION_I(normalizationFilterMaxVolume, -50)
LAMEXP_MAKE_OPTION_I(opusComplexity, 10) LAMEXP_MAKE_OPTION_I(opusComplexity, 10)
LAMEXP_MAKE_OPTION_B(opusDisableResample, false) LAMEXP_MAKE_OPTION_B(opusDisableResample, false)

12
src/Model_Settings.h
View File

@ -92,8 +92,6 @@ public:
}; };
//Consts //Consts
static const int mp3Bitrates[15];
static const int ac3Bitrates[20];
static const int samplingRates[8]; static const int samplingRates[8];
//Getters & setters //Getters & setters
@ -112,20 +110,28 @@ public:
LAMEXP_MAKE_OPTION_I(compressionBitrateAacEnc) LAMEXP_MAKE_OPTION_I(compressionBitrateAacEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateAften) LAMEXP_MAKE_OPTION_I(compressionBitrateAften)
LAMEXP_MAKE_OPTION_I(compressionBitrateDcaEnc) LAMEXP_MAKE_OPTION_I(compressionBitrateDcaEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateFLAC)
LAMEXP_MAKE_OPTION_I(compressionBitrateLAME) LAMEXP_MAKE_OPTION_I(compressionBitrateLAME)
LAMEXP_MAKE_OPTION_I(compressionBitrateOggEnc) LAMEXP_MAKE_OPTION_I(compressionBitrateOggEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateOpusEnc) LAMEXP_MAKE_OPTION_I(compressionBitrateOpusEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateWave)
LAMEXP_MAKE_OPTION_I(compressionEncoder) LAMEXP_MAKE_OPTION_I(compressionEncoder)
LAMEXP_MAKE_OPTION_I(compressionRCModeAacEnc) LAMEXP_MAKE_OPTION_I(compressionRCModeAacEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeAften) LAMEXP_MAKE_OPTION_I(compressionRCModeAften)
LAMEXP_MAKE_OPTION_I(compressionRCModeDcaEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeFLAC)
LAMEXP_MAKE_OPTION_I(compressionRCModeLAME) LAMEXP_MAKE_OPTION_I(compressionRCModeLAME)
LAMEXP_MAKE_OPTION_I(compressionRCModeOggEnc) LAMEXP_MAKE_OPTION_I(compressionRCModeOggEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeOpusEnc) LAMEXP_MAKE_OPTION_I(compressionRCModeOpusEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeWave)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAacEnc) LAMEXP_MAKE_OPTION_I(compressionVbrLevelAacEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAften) LAMEXP_MAKE_OPTION_I(compressionVbrLevelAften)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelDcaEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelFLAC) LAMEXP_MAKE_OPTION_I(compressionVbrLevelFLAC)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelLAME) LAMEXP_MAKE_OPTION_I(compressionVbrLevelLAME)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelOggEnc) LAMEXP_MAKE_OPTION_I(compressionVbrLevelOggEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelOpusEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelWave)
LAMEXP_MAKE_OPTION_B(createPlaylist) LAMEXP_MAKE_OPTION_B(createPlaylist)
LAMEXP_MAKE_OPTION_S(currentLanguage) LAMEXP_MAKE_OPTION_S(currentLanguage)
LAMEXP_MAKE_OPTION_S(currentLanguageFile) LAMEXP_MAKE_OPTION_S(currentLanguageFile)
@ -151,7 +157,7 @@ public:
LAMEXP_MAKE_OPTION_B(neroAACEnable2Pass) LAMEXP_MAKE_OPTION_B(neroAACEnable2Pass)
LAMEXP_MAKE_OPTION_B(neroAacNotificationsEnabled) LAMEXP_MAKE_OPTION_B(neroAacNotificationsEnabled)
LAMEXP_MAKE_OPTION_B(normalizationFilterEnabled) LAMEXP_MAKE_OPTION_B(normalizationFilterEnabled)
LAMEXP_MAKE_OPTION_I(normalizationFilterEqualizationMode) LAMEXP_MAKE_OPTION_I(normalizationFilterEQMode)
LAMEXP_MAKE_OPTION_I(normalizationFilterMaxVolume) LAMEXP_MAKE_OPTION_I(normalizationFilterMaxVolume)
LAMEXP_MAKE_OPTION_I(opusComplexity) LAMEXP_MAKE_OPTION_I(opusComplexity)
LAMEXP_MAKE_OPTION_B(opusDisableResample) LAMEXP_MAKE_OPTION_B(opusDisableResample)

155
src/Registry_Encoder.cpp
View File

@ -35,12 +35,23 @@
#define IS_VBR(RC_MODE) ((RC_MODE) == SettingsModel::VBRMode) #define IS_VBR(RC_MODE) ((RC_MODE) == SettingsModel::VBRMode)
////////////////////////////////////////////////////////////
// Create encoder instance
////////////////////////////////////////////////////////////
AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling) AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling)
{ {
int rcMode = -1; int rcMode = -1;
AbstractEncoder *encoder = NULL; AbstractEncoder *encoder = NULL;
*nativeResampling = false; *nativeResampling = false;
//Sanity checking
if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
{
throw "Unknown rate-control mode!";
}
//Create new encoder instance
switch(encoderId) switch(encoderId)
{ {
/*-------- MP3Encoder /*--------*/ /*-------- MP3Encoder /*--------*/
@ -194,6 +205,10 @@ AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const Sett
return encoder; return encoder;
} }
////////////////////////////////////////////////////////////
// Get encoder info
////////////////////////////////////////////////////////////
const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId) const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId)
{ {
const AbstractEncoderInfo *info = NULL; const AbstractEncoderInfo *info = NULL;
@ -261,3 +276,143 @@ const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId)
return info; 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))
{
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::PCMEncoder: STORE_MODE(Wave, rcMode); break;
default: throw "Unsupported encoder!";
}
}
int EncoderRegistry::loadEncoderMode(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::PCMEncoder: LOAD_MODE(rcMode, Wave); break;
default: 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->compressionVbrLevel##ENCODER_ID(VALUE); \
} \
else \
{ \
settings->compressionBitrate##ENCODER_ID(VALUE); \
} \
} \
while(0)
#define LOAD_VALUE(VALUE, ENCODER_ID, RC_MODE) do \
{ \
if(IS_VBR(RC_MODE)) \
{ \
(VALUE) = settings->compressionVbrLevel##ENCODER_ID(); \
} \
else \
{ \
(VALUE) = settings->compressionBitrate##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))
{
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::PCMEncoder: STORE_VALUE(Wave, rcMode, value); break;
default: 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))
{
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::PCMEncoder: LOAD_VALUE(value, Wave, rcMode); break;
default: throw "Unsupported encoder!";
}
return value;
}

8
src/Registry_Encoder.h
View File

@ -34,6 +34,10 @@ class EncoderRegistry : public QObject
public: public:
static AbstractEncoder *createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling); static AbstractEncoder *createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling);
static const AbstractEncoderInfo *getEncoderInfo(const int encoderId); static const AbstractEncoderInfo *getEncoderInfo(const int encoderId);
static void saveEncoderConfig(SettingsModel *settings, const int encoderId, const int rcMode, const int value);
static int loadEncoderConfig(const SettingsModel *settings, const int encoderId, const int rcMode); static void saveEncoderMode(SettingsModel *settings, const int encoderId, const int rcMode);
static int loadEncoderMode(SettingsModel *settings, const int encoderId);
static void saveEncoderValue(SettingsModel *settings, const int encoderId, const int rcMode, const int value);
static int loadEncoderValue(const SettingsModel *settings, const int encoderId, const int rcMode);
}; };