src/Encoder_AC3.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2013 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License along
  16 // with this program; if not, write to the Free Software Foundation, Inc.,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // http://www.gnu.org/licenses/gpl-2.0.txt
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 #include "Encoder_AC3.h"
  23
  24 #include "Global.h"
  25 #include "Model_Settings.h"
  26
  27 #include <QProcess>
  28 #include <QDir>
  29
  30 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};
  31
  32 ///////////////////////////////////////////////////////////////////////////////
  33 // Encoder Info
  34 ///////////////////////////////////////////////////////////////////////////////
  35
  36 class AC3EncoderInfo : public AbstractEncoderInfo
  37 {
  38         virtual bool isModeSupported(int mode) const
  39         {
  40                 switch(mode)
  41                 {
  42                 case SettingsModel::VBRMode:
  43                 case SettingsModel::CBRMode:
  44                         return true;
  45                         break;
  46                 case SettingsModel::ABRMode:
  47                         return false;
  48                         break;
  49                 default:
  50                         throw "Bad RC mode specified!";
  51                 }
  52         }
  53
  54         virtual int valueCount(int mode) const
  55         {
  56                 switch(mode)
  57                 {
  58                 case SettingsModel::VBRMode:
  59                         return 65;
  60                         break;
  61                 case SettingsModel::ABRMode:
  62                         return 0;
  63                         break;
  64                 case SettingsModel::CBRMode:
  65                         return 19;
  66                         break;
  67                 default:
  68                         throw "Bad RC mode specified!";
  69                 }
  70         }
  71
  72         virtual int valueAt(int mode, int index) const
  73         {
  74                 switch(mode)
  75                 {
  76                 case SettingsModel::VBRMode:
  77                         return qBound(0, index * 16, 1023);
  78                         break;
  79                 case SettingsModel::ABRMode:
  80                 case SettingsModel::CBRMode:
  81                         return g_ac3BitratesLUT[qBound(0, index, 18)];
  82                         break;
  83                 default:
  84                         throw "Bad RC mode specified!";
  85                 }
  86         }
  87
  88         virtual int valueType(int mode) const
  89         {
  90                 switch(mode)
  91                 {
  92                 case SettingsModel::VBRMode:
  93                         return TYPE_QUALITY_LEVEL_INT;
  94                         break;
  95                 case SettingsModel::ABRMode:
  96                 case SettingsModel::CBRMode:
  97                         return TYPE_BITRATE;
  98                         break;
  99                 default:
 100                         throw "Bad RC mode specified!";
 101                 }
 102         }
 103
 104         virtual const char *description(void) const
 105         {
 106                 static const char* s_description = "Aften: A/52 Audio Encoder";
 107                 return s_description;
 108         }
 109 }
 110 static const g_aftenEncoderInfo;
 111
 112 ///////////////////////////////////////////////////////////////////////////////
 113 // Encoder implementation
 114 ///////////////////////////////////////////////////////////////////////////////
 115
 116 AC3Encoder::AC3Encoder(void)
 117 :
 118         m_binary(lamexp_lookup_tool("aften.exe"))
 119 {
 120         if(m_binary.isEmpty())
 121         {
 122                 throw "Error initializing FLAC encoder. Tool 'aften.exe' is not registred!";
 123         }
 124
 125         m_configAudioCodingMode = 0;
 126         m_configDynamicRangeCompression = 5;
 127         m_configExponentSearchSize = 8;
 128         m_configFastBitAllocation = false;
 129 }
 130
 131 AC3Encoder::~AC3Encoder(void)
 132 {
 133 }
 134
 135 bool AC3Encoder::encode(const QString &sourceFile, const AudioFileModel_MetaInfo &metaInfo, const unsigned int duration, const QString &outputFile, volatile bool *abortFlag)
 136 {
 137         QProcess process;
 138         QStringList args;
 139
 140         switch(m_configRCMode)
 141         {
 142         case SettingsModel::VBRMode:
 143                 args << "-q" << QString::number(qBound(0, m_configBitrate * 16, 1023));
 144                 break;
 145         case SettingsModel::CBRMode:
 146                 args << "-b" << QString::number(g_ac3BitratesLUT[qBound(0, m_configBitrate, 18)]);
 147                 break;
 148         default:
 149                 throw "Bad rate-control mode!";
 150                 break;
 151         }
 152
 153         if(m_configAudioCodingMode >= 1)
 154         {
 155                 args << "-acmod" << QString::number(m_configAudioCodingMode - 1);
 156         }
 157         if(m_configDynamicRangeCompression != 5)
 158         {
 159                 args << "-dynrng" << QString::number(m_configDynamicRangeCompression);
 160         }
 161         if(m_configExponentSearchSize != 8)
 162         {
 163                 args << "-exps" << QString::number(m_configExponentSearchSize);
 164         }
 165         if(m_configFastBitAllocation)
 166         {
 167                 args << "-fba" << QString::number(1);
 168         }
 169
 170         if(!m_configCustomParams.isEmpty()) args << m_configCustomParams.split(" ", QString::SkipEmptyParts);
 171
 172         args << QDir::toNativeSeparators(sourceFile);
 173         args << QDir::toNativeSeparators(outputFile);
 174
 175         if(!startProcess(process, m_binary, args))
 176         {
 177                 return false;
 178         }
 179
 180         bool bTimeout = false;
 181         bool bAborted = false;
 182         int prevProgress = -1;
 183
 184         QRegExp regExp("progress:(\\s+)(\\d+)%(\\s+)\\|");
 185
 186         while(process.state() != QProcess::NotRunning)
 187         {
 188                 if(*abortFlag)
 189                 {
 190                         process.kill();
 191                         bAborted = true;
 192                         emit messageLogged("\nABORTED BY USER !!!");
 193                         break;
 194                 }
 195                 process.waitForReadyRead(m_processTimeoutInterval);
 196                 if(!process.bytesAvailable() && process.state() == QProcess::Running)
 197                 {
 198                         process.kill();
 199                         qWarning("Aften process timed out <-- killing!");
 200                         emit messageLogged("\nPROCESS TIMEOUT !!!");
 201                         bTimeout = true;
 202                         break;
 203                 }
 204                 while(process.bytesAvailable() > 0)
 205                 {
 206                         QByteArray line = process.readLine();
 207                         QString text = QString::fromUtf8(line.constData()).simplified();
 208                         if(regExp.lastIndexIn(text) >= 0)
 209                         {
 210                                 bool ok = false;
 211                                 int progress = regExp.cap(2).toInt(&ok);
 212                                 if(ok && (progress > prevProgress))
 213                                 {
 214                                         emit statusUpdated(progress);
 215                                         prevProgress = qMin(progress + 2, 99);
 216                                 }
 217                         }
 218                         else if(!text.isEmpty())
 219                         {
 220                                 emit messageLogged(text);
 221                         }
 222                 }
 223         }
 224
 225         process.waitForFinished();
 226         if(process.state() != QProcess::NotRunning)
 227         {
 228                 process.kill();
 229                 process.waitForFinished(-1);
 230         }
 231
 232         emit statusUpdated(100);
 233         emit messageLogged(QString().sprintf("\nExited with code: 0x%04X", process.exitCode()));
 234
 235         if(bTimeout || bAborted || process.exitCode() != EXIT_SUCCESS)
 236         {
 237                 return false;
 238         }
 239
 240         return true;
 241 }
 242
 243 void AC3Encoder::setAudioCodingMode(int value)
 244 {
 245         m_configAudioCodingMode = qMin(8, qMax(0, value));
 246 }
 247
 248 void AC3Encoder::setDynamicRangeCompression(int value)
 249 {
 250         m_configDynamicRangeCompression = qMin(5, qMax(0, value));
 251 }
 252
 253 void AC3Encoder::setExponentSearchSize(int value)
 254 {
 255         m_configExponentSearchSize = qMin(32, qMax(1, value));
 256 }
 257
 258 void AC3Encoder::setFastBitAllocation(bool value)
 259 {
 260         m_configFastBitAllocation = value;
 261 }
 262
 263 QString AC3Encoder::extension(void)
 264 {
 265         return "ac3";
 266 }
 267
 268 const unsigned int *AC3Encoder::supportedChannelCount(void)
 269 {
 270         static const unsigned int supportedChannels[] = {1, 2, 3, 4, 5, 6, NULL};
 271         return supportedChannels;
 272 }
 273
 274 const unsigned int *AC3Encoder::supportedSamplerates(void)
 275 {
 276         static const unsigned int supportedRates[] = {48000, 44100, 32000, NULL};
 277         return supportedRates;
 278 }
 279
 280 bool AC3Encoder::isFormatSupported(const QString &containerType, const QString &containerProfile, const QString &formatType, const QString &formatProfile, const QString &formatVersion)
 281 {
 282         if(containerType.compare("Wave", Qt::CaseInsensitive) == 0)
 283         {
 284                 if(formatType.compare("PCM", Qt::CaseInsensitive) == 0)
 285                 {
 286                         return true;
 287                 }
 288         }
 289
 290         return false;
 291 }
 292
 293 const AbstractEncoderInfo *AC3Encoder::getEncoderInfo(void)
 294 {
 295         return &g_aftenEncoderInfo;
 296 }