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_FileSystem.h"
#include "WinSevenTaskbar.h"
#include "Registry_Encoder.h"
#include "Registry_Decoder.h"
#include "Encoder_Abstract.h"
#include "ShellIntegration.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->radioButtonEncoderPCM, SettingsModel::PCMEncoder);
ui->radioButtonEncoderAAC->setEnabled(m_aacEncoder > SettingsModel::AAC_ENCODER_NONE);
m_modeButtonGroup = new QButtonGroup(this);
m_modeButtonGroup->addButton(ui->radioButtonModeQuality, SettingsModel::VBRMode);
m_modeButtonGroup->addButton(ui->radioButtonModeAverageBitrate, SettingsModel::ABRMode);
m_modeButtonGroup->addButton(ui->radioButtonConstBitrate, SettingsModel::CBRMode);
ui->radioButtonEncoderAAC->setEnabled(m_aacEncoder > SettingsModel::AAC_ENCODER_NONE);
ui->radioButtonEncoderMP3->setChecked(m_settings->compressionEncoder() == SettingsModel::MP3Encoder);
ui->radioButtonEncoderVorbis->setChecked(m_settings->compressionEncoder() == SettingsModel::VorbisEncoder);
ui->radioButtonEncoderAAC->setChecked((m_settings->compressionEncoder() == SettingsModel::AACEncoder) && (m_aacEncoder > SettingsModel::AAC_ENCODER_NONE));
ui->radioButtonEncoderAC3->setChecked(m_settings->compressionEncoder() == SettingsModel::AC3Encoder);
ui->radioButtonEncoderFLAC->setChecked(m_settings->compressionEncoder() == SettingsModel::FLACEncoder);
ui->radioButtonEncoderOpus->setChecked(m_settings->compressionEncoder() == SettingsModel::OpusEncoder);
ui->radioButtonEncoderDCA->setChecked(m_settings->compressionEncoder() == SettingsModel::DCAEncoder);
ui->radioButtonEncoderPCM->setChecked(m_settings->compressionEncoder() == SettingsModel::PCMEncoder);
ui->radioButtonEncoderMP3->setChecked(true);
foreach(QAbstractButton *currentButton, m_encoderButtonGroup->buttons())
{
if(currentButton->isEnabled() && (m_encoderButtonGroup->id(currentButton) == m_settings->compressionEncoder()))
{
currentButton->setChecked(true);
break;
}
}
m_evenFilterCompressionTab = new CustomEventFilter();
ui->labelCompressionHelp->installEventFilter(m_evenFilterCompressionTab);
@ -395,7 +399,7 @@ MainWindow::MainWindow(FileListModel *fileListModel, AudioFileModel *metaInfo, S
ui->comboBoxAACProfile->setCurrentIndex(m_settings->aacEncProfile());
ui->comboBoxAftenCodingMode->setCurrentIndex(m_settings->aftenAudioCodingMode());
ui->comboBoxAftenDRCMode->setCurrentIndex(m_settings->aftenDynamicRangeCompression());
ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEqualizationMode());
ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEQMode());
//comboBoxOpusOptimize->setCurrentIndex(m_settings->opusOptimizeFor());
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
////////////////////////////////////////////////////////////
@ -3409,81 +3290,46 @@ void MainWindow::playlistEnabledChanged(void)
void MainWindow::updateEncoder(int id)
{
m_settings->compressionEncoder(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;
}
const AbstractEncoderInfo *info = EncoderRegistry::getEncoderInfo(id);
//Update UI controls
ui->radioButtonModeQuality->setEnabled(bSupportsVBR);
ui->radioButtonModeAverageBitrate->setEnabled(bSupportsABR);
ui->radioButtonConstBitrate->setEnabled(bSupportsCBR);
ui->sliderBitrate->setEnabled(bSliderEnabled);
ui->radioButtonModeQuality->setEnabled(info->isModeSupported(SettingsModel::VBRMode));
ui->radioButtonModeAverageBitrate->setEnabled(info->isModeSupported(SettingsModel::ABRMode));
ui->radioButtonConstBitrate->setEnabled(info->isModeSupported(SettingsModel::CBRMode));
//Add AAC info
if(m_settings->compressionEncoder() == SettingsModel::AACEncoder)
//Initialize checkbox state
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->setText(tr("Current AAC Encoder: %1").arg(encoderName));
ui->labelEncoderInfo->setText(tr("Current Encoder: %1").arg(QString::fromUtf8(description)));
}
else
{
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!
updateRCMode(currentRCMode);
}
@ -3493,195 +3339,40 @@ void MainWindow::updateEncoder(int id)
*/
void MainWindow::updateRCMode(int id)
{
int sliderMin = INT_MIN;
int sliderMax = INT_MAX;
//Store new RC mode
const int currentEncoder = m_encoderButtonGroup->checkedId();
EncoderRegistry::saveEncoderMode(m_settings, currentEncoder, id);
//Update encoder-specific settings
const int currentEncoder = m_settings->compressionEncoder();
switch(currentEncoder)
{
/* -------- 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;
}
//Fetch encoder info
const AbstractEncoderInfo *info = EncoderRegistry::getEncoderInfo(currentEncoder);
const int valueCount = info->valueCount(id);
//Update slider min/max values
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMinimum, sliderMin);
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMaximum, sliderMax);
//Update slider position
int currentPosition = INT_MAX;
switch(id)
if(valueCount > 0)
{
case SettingsModel::VBRMode:
currentPosition = getCurrentQuality(currentEncoder);
break;
case SettingsModel::ABRMode:
case SettingsModel::CBRMode:
currentPosition = getCurrentBitrate(currentEncoder);
break;
default:
throw "updateRCMode(): Unknown rc-mode specified!";
break;
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setEnabled, true);
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMinimum, 0);
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMaximum, valueCount-1);
}
else
{
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setEnabled, false);
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMinimum, 0);
WITH_BLOCKED_SIGNALS(ui->sliderBitrate, setMaximum, 2);
}
//Update bitrate/quality value!
ui->sliderBitrate->setValue(currentPosition);
updateBitrate(currentPosition);
//Now update bitrate/quality value!
if(valueCount > 0)
{
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)
{
//Update encoder-specific settings
const int currentEncoder = m_settings->compressionEncoder();
const int currentRCMode = getCurrentRCMode(currentEncoder);
//Load current encoder and RC mode
const int currentEncoder = m_encoderButtonGroup->checkedId();
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 -------- */
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;
EncoderRegistry::saveEncoderValue(m_settings, currentEncoder, currentRCMode, qBound(0, value, valueCount-1));
}
//Update slider text
ui->labelBitrate->setText(sliderText);
//Update bitrate value
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)
{
m_settings->normalizationFilterEqualizationMode(mode);
m_settings->normalizationFilterEQMode(mode);
}
/*
@ -4452,7 +3997,7 @@ void MainWindow::resetAdvancedOptionsButtonClicked(void)
ui->comboBoxAACProfile->setCurrentIndex(m_settings->aacEncProfileDefault());
ui->comboBoxAftenCodingMode->setCurrentIndex(m_settings->aftenAudioCodingModeDefault());
ui->comboBoxAftenDRCMode->setCurrentIndex(m_settings->aftenDynamicRangeCompressionDefault());
ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEqualizationModeDefault());
ui->comboBoxNormalizationMode->setCurrentIndex(m_settings->normalizationFilterEQModeDefault());
ui->comboBoxOpusFramesize->setCurrentIndex(m_settings->opusFramesizeDefault());
SET_CHECKBOX_STATE(ui->checkBoxBitrateManagement, m_settings->bitrateManagementEnabledDefault());

3
src/Dialog_MainWindow.h
View File

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

333
src/Dialog_Processing.cpp
View File

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

4
src/Dialog_Processing.h
View File

@ -95,7 +95,6 @@ private:
void setCloseButtonEnabled(bool enabled);
void startNextJob(void);
AbstractEncoder *makeEncoder(bool *nativeResampling);
AudioFileModel updateMetaInfo(const AudioFileModel &audioFile);
void writePlayList(void);
bool shutdownComputer(void);
@ -129,5 +128,6 @@ private:
qint64 m_timerStart;
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 <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)
:
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)));
break;
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;
default:
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 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 const char* description(void) const = 0; //Description of the encoder that can be displayed to the user
};
class AbstractEncoder : public AbstractTool
@ -72,7 +73,7 @@ public:
//Encoder info
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;
}

12
src/Encoder_MP3.cpp
View File

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

164
src/Model_Settings.cpp
View File

@ -166,84 +166,90 @@ while(0)
////////////////////////////////////////////////////////////
//Setting ID's
LAMEXP_MAKE_ID(aacEncProfile, "AdvancedOptions/AACEnc/ForceProfile");
LAMEXP_MAKE_ID(aftenAudioCodingMode, "AdvancedOptions/Aften/AudioCodingMode");
LAMEXP_MAKE_ID(aacEncProfile, "AdvancedOptions/AACEnc/ForceProfile");
LAMEXP_MAKE_ID(aftenAudioCodingMode, "AdvancedOptions/Aften/AudioCodingMode");
LAMEXP_MAKE_ID(aftenDynamicRangeCompression, "AdvancedOptions/Aften/DynamicRangeCompression");
LAMEXP_MAKE_ID(aftenExponentSearchSize, "AdvancedOptions/Aften/ExponentSearchSize");
LAMEXP_MAKE_ID(aftenFastBitAllocation, "AdvancedOptions/Aften/FastBitAllocation");
LAMEXP_MAKE_ID(antivirNotificationsEnabled, "Flags/EnableAntivirusNotifications");
LAMEXP_MAKE_ID(autoUpdateCheckBeta, "AutoUpdate/CheckForBetaVersions");
LAMEXP_MAKE_ID(autoUpdateEnabled, "AutoUpdate/Enabled");
LAMEXP_MAKE_ID(autoUpdateLastCheck, "AutoUpdate/LastCheck");
LAMEXP_MAKE_ID(bitrateManagementEnabled, "AdvancedOptions/BitrateManagement/Enabled");
LAMEXP_MAKE_ID(bitrateManagementMaxRate, "AdvancedOptions/BitrateManagement/MaxRate");
LAMEXP_MAKE_ID(bitrateManagementMinRate, "AdvancedOptions/BitrateManagement/MinRate");
LAMEXP_MAKE_ID(compressionBitrateAacEnc, "Compression/Bitrate/AacEnc");
LAMEXP_MAKE_ID(compressionBitrateAften, "Compression/Bitrate/Aften");
LAMEXP_MAKE_ID(compressionBitrateDcaEnc, "Compression/Bitrate/DcaEnc");
LAMEXP_MAKE_ID(compressionBitrateLAME, "Compression/Bitrate/LAME");
LAMEXP_MAKE_ID(compressionBitrateOggEnc, "Compression/Bitrate/OggEnc");
LAMEXP_MAKE_ID(compressionBitrateOpusEnc, "Compression/Bitrate/OpusEnc");
LAMEXP_MAKE_ID(compressionEncoder, "Compression/Encoder");
LAMEXP_MAKE_ID(compressionRCModeAacEnc, "Compression/RCMode/AacEnc");
LAMEXP_MAKE_ID(compressionRCModeAften, "Compression/RCMode/Aften");
LAMEXP_MAKE_ID(compressionRCModeLAME, "Compression/RCMode/LAME");
LAMEXP_MAKE_ID(compressionRCModeOggEnc, "Compression/RCMode/OggEnc");
LAMEXP_MAKE_ID(compressionRCModeOpusEnc, "Compression/RCMode/OpusEnc");
LAMEXP_MAKE_ID(compressionVbrLevelAacEnc, "Compression/VbrLevel/AacEnc");
LAMEXP_MAKE_ID(compressionVbrLevelAften, "Compression/VbrLevel/Aften");
LAMEXP_MAKE_ID(compressionVbrLevelFLAC, "Compression/VbrLevel/FLAC");
LAMEXP_MAKE_ID(compressionVbrLevelLAME, "Compression/VbrLevel/LAME");
LAMEXP_MAKE_ID(compressionVbrLevelOggEnc, "Compression/VbrLevel/OggEnc");
LAMEXP_MAKE_ID(createPlaylist, "Flags/AutoCreatePlaylist");
LAMEXP_MAKE_ID(currentLanguage, "Localization/Language");
LAMEXP_MAKE_ID(currentLanguageFile, "Localization/UseQMFile");
LAMEXP_MAKE_ID(customParametersAacEnc, "AdvancedOptions/CustomParameters/AacEnc");
LAMEXP_MAKE_ID(customParametersAften, "AdvancedOptions/CustomParameters/Aften");
LAMEXP_MAKE_ID(customParametersFLAC, "AdvancedOptions/CustomParameters/FLAC");
LAMEXP_MAKE_ID(customParametersLAME, "AdvancedOptions/CustomParameters/LAME");
LAMEXP_MAKE_ID(customParametersOggEnc, "AdvancedOptions/CustomParameters/OggEnc");
LAMEXP_MAKE_ID(customParametersOpus, "AdvancedOptions/CustomParameters/OpusEnc");
LAMEXP_MAKE_ID(customTempPath, "AdvancedOptions/TempDirectory/CustomPath");
LAMEXP_MAKE_ID(customTempPathEnabled, "AdvancedOptions/TempDirectory/UseCustomPath");
LAMEXP_MAKE_ID(dropBoxWidgetEnabled, "Flags/EnableDropBoxWidget");
LAMEXP_MAKE_ID(favoriteOutputFolders, "OutputDirectory/Favorites");
LAMEXP_MAKE_ID(forceStereoDownmix, "AdvancedOptions/StereoDownmix/Force");
LAMEXP_MAKE_ID(hibernateComputer, "AdvancedOptions/HibernateComputerOnShutdown");
LAMEXP_MAKE_ID(interfaceStyle, "InterfaceStyle");
LAMEXP_MAKE_ID(lameAlgoQuality, "AdvancedOptions/LAME/AlgorithmQuality");
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(normalizationFilterEqualizationMode, "AdvancedOptions/VolumeNormalization/EqualizationMode");
LAMEXP_MAKE_ID(aftenExponentSearchSize, "AdvancedOptions/Aften/ExponentSearchSize");
LAMEXP_MAKE_ID(aftenFastBitAllocation, "AdvancedOptions/Aften/FastBitAllocation");
LAMEXP_MAKE_ID(antivirNotificationsEnabled, "Flags/EnableAntivirusNotifications");
LAMEXP_MAKE_ID(autoUpdateCheckBeta, "AutoUpdate/CheckForBetaVersions");
LAMEXP_MAKE_ID(autoUpdateEnabled, "AutoUpdate/Enabled");
LAMEXP_MAKE_ID(autoUpdateLastCheck, "AutoUpdate/LastCheck");
LAMEXP_MAKE_ID(bitrateManagementEnabled, "AdvancedOptions/BitrateManagement/Enabled");
LAMEXP_MAKE_ID(bitrateManagementMaxRate, "AdvancedOptions/BitrateManagement/MaxRate");
LAMEXP_MAKE_ID(bitrateManagementMinRate, "AdvancedOptions/BitrateManagement/MinRate");
LAMEXP_MAKE_ID(compressionBitrateAacEnc, "Compression/Bitrate/AacEnc");
LAMEXP_MAKE_ID(compressionBitrateAften, "Compression/Bitrate/Aften");
LAMEXP_MAKE_ID(compressionBitrateDcaEnc, "Compression/Bitrate/DcaEnc");
LAMEXP_MAKE_ID(compressionBitrateFLAC, "Compression/Bitrate/FLAC");
LAMEXP_MAKE_ID(compressionBitrateLAME, "Compression/Bitrate/LAME");
LAMEXP_MAKE_ID(compressionBitrateOggEnc, "Compression/Bitrate/OggEnc");
LAMEXP_MAKE_ID(compressionBitrateOpusEnc, "Compression/Bitrate/OpusEnc");
LAMEXP_MAKE_ID(compressionBitrateWave, "Compression/Bitrate/Wave");
LAMEXP_MAKE_ID(compressionEncoder, "Compression/Encoder");
LAMEXP_MAKE_ID(compressionRCModeAacEnc, "Compression/RCMode/AacEnc");
LAMEXP_MAKE_ID(compressionRCModeAften, "Compression/RCMode/Aften");
LAMEXP_MAKE_ID(compressionRCModeDcaEnc, "Compression/RCMode/DcaEnc");
LAMEXP_MAKE_ID(compressionRCModeFLAC, "Compression/RCMode/FLAC");
LAMEXP_MAKE_ID(compressionRCModeLAME, "Compression/RCMode/LAME");
LAMEXP_MAKE_ID(compressionRCModeOggEnc, "Compression/RCMode/OggEnc");
LAMEXP_MAKE_ID(compressionRCModeOpusEnc, "Compression/RCMode/OpusEnc");
LAMEXP_MAKE_ID(compressionRCModeWave, "Compression/RCMode/Wave");
LAMEXP_MAKE_ID(compressionVbrLevelAacEnc, "Compression/VbrLevel/AacEnc");
LAMEXP_MAKE_ID(compressionVbrLevelAften, "Compression/VbrLevel/Aften");
LAMEXP_MAKE_ID(compressionVbrLevelDcaEnc, "Compression/VbrLevel/DcaEnc");
LAMEXP_MAKE_ID(compressionVbrLevelFLAC, "Compression/VbrLevel/FLAC");
LAMEXP_MAKE_ID(compressionVbrLevelLAME, "Compression/VbrLevel/LAME");
LAMEXP_MAKE_ID(compressionVbrLevelOggEnc, "Compression/VbrLevel/OggEnc");
LAMEXP_MAKE_ID(compressionVbrLevelOpusEnc, "Compression/VbrLevel/OpusEnc");
LAMEXP_MAKE_ID(compressionVbrLevelWave, "Compression/VbrLevel/Wave");
LAMEXP_MAKE_ID(createPlaylist, "Flags/AutoCreatePlaylist");
LAMEXP_MAKE_ID(currentLanguage, "Localization/Language");
LAMEXP_MAKE_ID(currentLanguageFile, "Localization/UseQMFile");
LAMEXP_MAKE_ID(customParametersAacEnc, "AdvancedOptions/CustomParameters/AacEnc");
LAMEXP_MAKE_ID(customParametersAften, "AdvancedOptions/CustomParameters/Aften");
LAMEXP_MAKE_ID(customParametersFLAC, "AdvancedOptions/CustomParameters/FLAC");
LAMEXP_MAKE_ID(customParametersLAME, "AdvancedOptions/CustomParameters/LAME");
LAMEXP_MAKE_ID(customParametersOggEnc, "AdvancedOptions/CustomParameters/OggEnc");
LAMEXP_MAKE_ID(customParametersOpus, "AdvancedOptions/CustomParameters/OpusEnc");
LAMEXP_MAKE_ID(customTempPath, "AdvancedOptions/TempDirectory/CustomPath");
LAMEXP_MAKE_ID(customTempPathEnabled, "AdvancedOptions/TempDirectory/UseCustomPath");
LAMEXP_MAKE_ID(dropBoxWidgetEnabled, "Flags/EnableDropBoxWidget");
LAMEXP_MAKE_ID(favoriteOutputFolders, "OutputDirectory/Favorites");
LAMEXP_MAKE_ID(forceStereoDownmix, "AdvancedOptions/StereoDownmix/Force");
LAMEXP_MAKE_ID(hibernateComputer, "AdvancedOptions/HibernateComputerOnShutdown");
LAMEXP_MAKE_ID(interfaceStyle, "InterfaceStyle");
LAMEXP_MAKE_ID(lameAlgoQuality, "AdvancedOptions/LAME/AlgorithmQuality");
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(opusComplexity, "AdvancedOptions/Opus/EncodingComplexity");
LAMEXP_MAKE_ID(opusDisableResample, "AdvancedOptions/Opus/DisableResample");
LAMEXP_MAKE_ID(opusFramesize, "AdvancedOptions/Opus/FrameSize");
LAMEXP_MAKE_ID(opusOptimizeFor, "AdvancedOptions/Opus/OptimizeForSignalType");
LAMEXP_MAKE_ID(outputDir, "OutputDirectory/SelectedPath");
LAMEXP_MAKE_ID(outputToSourceDir, "OutputDirectory/OutputToSourceFolder");
LAMEXP_MAKE_ID(overwriteMode, "AdvancedOptions/OverwriteMode");
LAMEXP_MAKE_ID(prependRelativeSourcePath, "OutputDirectory/PrependRelativeSourcePath");
LAMEXP_MAKE_ID(renameOutputFilesEnabled, "AdvancedOptions/RenameOutputFiles/Enabled");
LAMEXP_MAKE_ID(renameOutputFilesPattern, "AdvancedOptions/RenameOutputFiles/Pattern");
LAMEXP_MAKE_ID(samplingRate, "AdvancedOptions/Common/Resampling");
LAMEXP_MAKE_ID(shellIntegrationEnabled, "Flags/EnableShellIntegration");
LAMEXP_MAKE_ID(slowStartup, "Flags/SlowStartupDetected");
LAMEXP_MAKE_ID(soundsEnabled, "Flags/EnableSounds");
LAMEXP_MAKE_ID(toneAdjustBass, "AdvancedOptions/ToneAdjustment/Bass");
LAMEXP_MAKE_ID(toneAdjustTreble, "AdvancedOptions/ToneAdjustment/Treble");
LAMEXP_MAKE_ID(versionNumber, "VersionNumber");
LAMEXP_MAKE_ID(writeMetaTags, "Flags/WriteMetaTags");
LAMEXP_MAKE_ID(opusComplexity, "AdvancedOptions/Opus/EncodingComplexity");
LAMEXP_MAKE_ID(opusDisableResample, "AdvancedOptions/Opus/DisableResample");
LAMEXP_MAKE_ID(opusFramesize, "AdvancedOptions/Opus/FrameSize");
LAMEXP_MAKE_ID(opusOptimizeFor, "AdvancedOptions/Opus/OptimizeForSignalType");
LAMEXP_MAKE_ID(outputDir, "OutputDirectory/SelectedPath");
LAMEXP_MAKE_ID(outputToSourceDir, "OutputDirectory/OutputToSourceFolder");
LAMEXP_MAKE_ID(overwriteMode, "AdvancedOptions/OverwriteMode");
LAMEXP_MAKE_ID(prependRelativeSourcePath, "OutputDirectory/PrependRelativeSourcePath");
LAMEXP_MAKE_ID(renameOutputFilesEnabled, "AdvancedOptions/RenameOutputFiles/Enabled");
LAMEXP_MAKE_ID(renameOutputFilesPattern, "AdvancedOptions/RenameOutputFiles/Pattern");
LAMEXP_MAKE_ID(samplingRate, "AdvancedOptions/Common/Resampling");
LAMEXP_MAKE_ID(shellIntegrationEnabled, "Flags/EnableShellIntegration");
LAMEXP_MAKE_ID(slowStartup, "Flags/SlowStartupDetected");
LAMEXP_MAKE_ID(soundsEnabled, "Flags/EnableSounds");
LAMEXP_MAKE_ID(toneAdjustBass, "AdvancedOptions/ToneAdjustment/Bass");
LAMEXP_MAKE_ID(toneAdjustTreble, "AdvancedOptions/ToneAdjustment/Treble");
LAMEXP_MAKE_ID(versionNumber, "VersionNumber");
LAMEXP_MAKE_ID(writeMetaTags, "Flags/WriteMetaTags");
//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};
static QReadWriteLock s_lock;
@ -574,20 +580,28 @@ LAMEXP_MAKE_OPTION_I(bitrateManagementMinRate, 32)
LAMEXP_MAKE_OPTION_I(compressionBitrateAacEnc, 20)
LAMEXP_MAKE_OPTION_I(compressionBitrateAften, 15)
LAMEXP_MAKE_OPTION_I(compressionBitrateDcaEnc, 47)
LAMEXP_MAKE_OPTION_I(compressionBitrateFLAC, 0)
LAMEXP_MAKE_OPTION_I(compressionBitrateLAME, 10)
LAMEXP_MAKE_OPTION_I(compressionBitrateOggEnc, 20)
LAMEXP_MAKE_OPTION_I(compressionBitrateOpusEnc, 16)
LAMEXP_MAKE_OPTION_I(compressionBitrateWave, 0)
LAMEXP_MAKE_OPTION_I(compressionEncoder, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeAacEnc, 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(compressionRCModeOggEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeOpusEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionRCModeWave, 0)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAacEnc, 10)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAften, 8)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelDcaEnc, 0)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelFLAC, 8)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelLAME, 7)
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_S(currentLanguage, defaultLanguage())
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(neroAacNotificationsEnabled, true)
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(opusComplexity, 10)
LAMEXP_MAKE_OPTION_B(opusDisableResample, false)

12
src/Model_Settings.h
View File

@ -92,8 +92,6 @@ public:
};
//Consts
static const int mp3Bitrates[15];
static const int ac3Bitrates[20];
static const int samplingRates[8];
//Getters & setters
@ -112,20 +110,28 @@ public:
LAMEXP_MAKE_OPTION_I(compressionBitrateAacEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateAften)
LAMEXP_MAKE_OPTION_I(compressionBitrateDcaEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateFLAC)
LAMEXP_MAKE_OPTION_I(compressionBitrateLAME)
LAMEXP_MAKE_OPTION_I(compressionBitrateOggEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateOpusEnc)
LAMEXP_MAKE_OPTION_I(compressionBitrateWave)
LAMEXP_MAKE_OPTION_I(compressionEncoder)
LAMEXP_MAKE_OPTION_I(compressionRCModeAacEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeAften)
LAMEXP_MAKE_OPTION_I(compressionRCModeDcaEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeFLAC)
LAMEXP_MAKE_OPTION_I(compressionRCModeLAME)
LAMEXP_MAKE_OPTION_I(compressionRCModeOggEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeOpusEnc)
LAMEXP_MAKE_OPTION_I(compressionRCModeWave)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAacEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelAften)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelDcaEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelFLAC)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelLAME)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelOggEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelOpusEnc)
LAMEXP_MAKE_OPTION_I(compressionVbrLevelWave)
LAMEXP_MAKE_OPTION_B(createPlaylist)
LAMEXP_MAKE_OPTION_S(currentLanguage)
LAMEXP_MAKE_OPTION_S(currentLanguageFile)
@ -151,7 +157,7 @@ public:
LAMEXP_MAKE_OPTION_B(neroAACEnable2Pass)
LAMEXP_MAKE_OPTION_B(neroAacNotificationsEnabled)
LAMEXP_MAKE_OPTION_B(normalizationFilterEnabled)
LAMEXP_MAKE_OPTION_I(normalizationFilterEqualizationMode)
LAMEXP_MAKE_OPTION_I(normalizationFilterEQMode)
LAMEXP_MAKE_OPTION_I(normalizationFilterMaxVolume)
LAMEXP_MAKE_OPTION_I(opusComplexity)
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)
////////////////////////////////////////////////////////////
// Create encoder instance
////////////////////////////////////////////////////////////
AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling)
{
int rcMode = -1;
AbstractEncoder *encoder = NULL;
*nativeResampling = false;
//Sanity checking
if((rcMode < SettingsModel::VBRMode) || (rcMode > SettingsModel::CBRMode))
{
throw "Unknown rate-control mode!";
}
//Create new encoder instance
switch(encoderId)
{
/*-------- MP3Encoder /*--------*/
@ -194,6 +205,10 @@ AbstractEncoder *EncoderRegistry::createInstance(const int encoderId, const Sett
return encoder;
}
////////////////////////////////////////////////////////////
// Get encoder info
////////////////////////////////////////////////////////////
const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId)
{
const AbstractEncoderInfo *info = NULL;
@ -261,3 +276,143 @@ const AbstractEncoderInfo *EncoderRegistry::getEncoderInfo(const int encoderId)
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:
static AbstractEncoder *createInstance(const int encoderId, const SettingsModel *settings, bool *nativeResampling);
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);
};