src/Encoder_MP3.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version, but always including the *additional*
   9 // restrictions defined in the "License.txt" file.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this program; if not, write to the Free Software Foundation, Inc.,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 // http://www.gnu.org/licenses/gpl-2.0.txt
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #include "Encoder_MP3.h"
  24
  25 #include "Global.h"
  26 #include "Model_Settings.h"
  27
  28 #include <QProcess>
  29 #include <QDir>
  30 #include <limits.h>
  31
  32 static const int g_lameAgorithmQualityLUT[5] = {7, 5, 2, 0, INT_MAX};
  33 static const int g_mp3BitrateLUT[15] = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1};
  34 static const int g_lameVBRQualityLUT[11] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, INT_MAX};
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37 // Encoder Info
  38 ///////////////////////////////////////////////////////////////////////////////
  39
  40 class MP3EncoderInfo : public AbstractEncoderInfo
  41 {
  42         virtual bool isModeSupported(int mode) const
  43         {
  44                 switch(mode)
  45                 {
  46                 case SettingsModel::VBRMode:
  47                 case SettingsModel::ABRMode:
  48                 case SettingsModel::CBRMode:
  49                         return true;
  50                         break;
  51                 default:
  52                         MUTILS_THROW("Bad RC mode specified!");
  53                 }
  54         }
  55
  56         virtual int valueCount(int mode) const
  57         {
  58                 switch(mode)
  59                 {
  60                 case SettingsModel::VBRMode:
  61                         return 10;
  62                         break;
  63                 case SettingsModel::ABRMode:
  64                 case SettingsModel::CBRMode:
  65                         return 14;
  66                         break;
  67                 default:
  68                         MUTILS_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 g_lameVBRQualityLUT[qBound(0, index, 9)];
  78                         break;
  79                 case SettingsModel::ABRMode:
  80                 case SettingsModel::CBRMode:
  81                         return g_mp3BitrateLUT[qBound(0, index, 13)];
  82                         break;
  83                 default:
  84                         MUTILS_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                         return TYPE_APPROX_BITRATE;
  97                         break;
  98                 case SettingsModel::CBRMode:
  99                         return TYPE_BITRATE;
 100                         break;
 101                 default:
 102                         MUTILS_THROW("Bad RC mode specified!");
 103                 }
 104         }
 105
 106         virtual const char *description(void) const
 107         {
 108                 static const char* s_description = "LAME MP3 Encoder";
 109                 return s_description;
 110         }
 111
 112         virtual const char *extension(void) const
 113         {
 114                 static const char* s_extension = "mp3";
 115                 return s_extension;
 116         }
 117 }
 118 static const g_mp3EncoderInfo;
 119
 120 ///////////////////////////////////////////////////////////////////////////////
 121 // Encoder implementation
 122 ///////////////////////////////////////////////////////////////////////////////
 123
 124 MP3Encoder::MP3Encoder(void)
 125 :
 126         m_binary(lamexp_tools_lookup("lame.exe"))
 127 {
 128         if(m_binary.isEmpty())
 129         {
 130                 MUTILS_THROW("Error initializing MP3 encoder. Tool 'lame.exe' is not registred!");
 131         }
 132
 133         m_algorithmQuality = 2;
 134         m_configBitrateMaximum = 0;
 135         m_configBitrateMinimum = 0;
 136         m_configSamplingRate = 0;
 137         m_configChannelMode = 0;
 138 }
 139
 140 MP3Encoder::~MP3Encoder(void)
 141 {
 142 }
 143
 144 bool MP3Encoder::encode(const QString &sourceFile, const AudioFileModel_MetaInfo &metaInfo, const unsigned int duration, const QString &outputFile, volatile bool *abortFlag)
 145 {
 146         QProcess process;
 147         QStringList args;
 148
 149         args << "--nohist";
 150         args << "-q" << QString::number(g_lameAgorithmQualityLUT[m_algorithmQuality]);
 151
 152         switch(m_configRCMode)
 153         {
 154         case SettingsModel::VBRMode:
 155                 args << "-V" << QString::number(g_lameVBRQualityLUT[qBound(0, m_configBitrate, 9)]);
 156                 break;
 157         case SettingsModel::ABRMode:
 158                 args << "--abr" << QString::number(g_mp3BitrateLUT[qBound(0, m_configBitrate, 13)]);
 159                 break;
 160         case SettingsModel::CBRMode:
 161                 args << "--cbr";
 162                 args << "-b" << QString::number(g_mp3BitrateLUT[qBound(0, m_configBitrate, 13)]);
 163                 break;
 164         default:
 165                 MUTILS_THROW("Bad rate-control mode!");
 166                 break;
 167         }
 168
 169         if((m_configBitrateMaximum > 0) && (m_configBitrateMinimum > 0) && (m_configBitrateMinimum <= m_configBitrateMaximum))
 170         {
 171                 if(m_configRCMode != SettingsModel::CBRMode)
 172                 {
 173                         args << "-b" << QString::number(clipBitrate(m_configBitrateMinimum));
 174                         args << "-B" << QString::number(clipBitrate(m_configBitrateMaximum));
 175                 }
 176         }
 177
 178         if(m_configSamplingRate > 0)
 179         {
 180                 args << "--resample" << QString::number(m_configSamplingRate);
 181         }
 182
 183         switch(m_configChannelMode)
 184         {
 185         case 1:
 186                 args << "-m" << "j";
 187                 break;
 188         case 2:
 189                 args << "-m" << "f";
 190                 break;
 191         case 3:
 192                 args << "-m" << "s";
 193                 break;
 194         case 4:
 195                 args << "-m" << "d";
 196                 break;
 197         case 5:
 198                 args << "-m" << "m";
 199                 break;
 200         }
 201
 202         bool bUseUCS2 = false;
 203
 204         if(isUnicode(metaInfo.title()))   bUseUCS2 = true;
 205         if(isUnicode(metaInfo.artist()))  bUseUCS2 = true;
 206         if(isUnicode(metaInfo.album()))   bUseUCS2 = true;
 207         if(isUnicode(metaInfo.genre()))   bUseUCS2 = true;
 208         if(isUnicode(metaInfo.comment())) bUseUCS2 = true;
 209
 210         if(bUseUCS2) args << "--id3v2-ucs2"; //Must specify this BEFORE "--tt" and friends!
 211
 212         if(!metaInfo.title().isEmpty())   args << "--tt" << cleanTag(metaInfo.title());
 213         if(!metaInfo.artist().isEmpty())  args << "--ta" << cleanTag(metaInfo.artist());
 214         if(!metaInfo.album().isEmpty())   args << "--tl" << cleanTag( metaInfo.album());
 215         if(!metaInfo.genre().isEmpty())   args << "--tg" << cleanTag(metaInfo.genre());
 216         if(!metaInfo.comment().isEmpty()) args << "--tc" << cleanTag(metaInfo.comment());
 217         if(metaInfo.year())               args << "--ty" << QString::number(metaInfo.year());
 218         if(metaInfo.position())           args << "--tn" << QString::number(metaInfo.position());
 219         if(!metaInfo.cover().isEmpty())   args << "--ti" << QDir::toNativeSeparators(metaInfo.cover());
 220
 221         if(!m_configCustomParams.isEmpty()) args << m_configCustomParams.split(" ", QString::SkipEmptyParts);
 222
 223         args << QDir::toNativeSeparators(sourceFile);
 224         args << QDir::toNativeSeparators(outputFile);
 225
 226         if(!startProcess(process, m_binary, args))
 227         {
 228                 return false;
 229         }
 230
 231         bool bTimeout = false;
 232         bool bAborted = false;
 233         int prevProgress = -1;
 234
 235         QRegExp regExp("\\(.*(\\d+)%\\)\\|");
 236
 237         while(process.state() != QProcess::NotRunning)
 238         {
 239                 if(*abortFlag)
 240                 {
 241                         process.kill();
 242                         bAborted = true;
 243                         emit messageLogged("\nABORTED BY USER !!!");
 244                         break;
 245                 }
 246                 process.waitForReadyRead(m_processTimeoutInterval);
 247                 if(!process.bytesAvailable() && process.state() == QProcess::Running)
 248                 {
 249                         process.kill();
 250                         qWarning("LAME process timed out <-- killing!");
 251                         emit messageLogged("\nPROCESS TIMEOUT !!!");
 252                         bTimeout = true;
 253                         break;
 254                 }
 255                 while(process.bytesAvailable() > 0)
 256                 {
 257                         QByteArray line = process.readLine();
 258                         QString text = QString::fromUtf8(line.constData()).simplified();
 259                         if(regExp.lastIndexIn(text) >= 0)
 260                         {
 261                                 bool ok = false;
 262                                 int progress = regExp.cap(1).toInt(&ok);
 263                                 if(ok && (progress > prevProgress))
 264                                 {
 265                                         emit statusUpdated(progress);
 266                                         prevProgress = qMin(progress + 2, 99);
 267                                 }
 268                         }
 269                         else if(!text.isEmpty())
 270                         {
 271                                 emit messageLogged(text);
 272                         }
 273                 }
 274         }
 275
 276         process.waitForFinished();
 277         if(process.state() != QProcess::NotRunning)
 278         {
 279                 process.kill();
 280                 process.waitForFinished(-1);
 281         }
 282
 283         emit statusUpdated(100);
 284         emit messageLogged(QString().sprintf("\nExited with code: 0x%04X", process.exitCode()));
 285
 286         if(bTimeout || bAborted || process.exitCode() != EXIT_SUCCESS)
 287         {
 288                 return false;
 289         }
 290
 291         return true;
 292 }
 293
 294 bool MP3Encoder::isFormatSupported(const QString &containerType, const QString &containerProfile, const QString &formatType, const QString &formatProfile, const QString &formatVersion)
 295 {
 296         if(containerType.compare("Wave", Qt::CaseInsensitive) == 0)
 297         {
 298                 if(formatType.compare("PCM", Qt::CaseInsensitive) == 0)
 299                 {
 300                         return true;
 301                 }
 302         }
 303         else if(containerType.compare("MPEG Audio", Qt::CaseInsensitive) == 0)
 304         {
 305                 if(formatType.compare("MPEG Audio", Qt::CaseInsensitive) == 0)
 306                 {
 307                         if(formatProfile.compare("Layer 3", Qt::CaseInsensitive) == 0 || formatProfile.compare("Layer 2", Qt::CaseInsensitive) == 0)
 308                         {
 309                                 if(formatVersion.compare("Version 1", Qt::CaseInsensitive) == 0 || formatVersion.compare("Version 2", Qt::CaseInsensitive) == 0)
 310                                 {
 311                                         return true;
 312                                 }
 313                         }
 314                 }
 315         }
 316
 317         return false;
 318 }
 319
 320 const unsigned int *MP3Encoder::supportedChannelCount(void)
 321 {
 322         static const unsigned int supportedChannels[] = {1, 2, NULL};
 323         return supportedChannels;
 324 }
 325
 326 void MP3Encoder::setAlgoQuality(int value)
 327 {
 328         m_algorithmQuality = qBound(0, value, 3);
 329 }
 330
 331 void MP3Encoder::setBitrateLimits(int minimumBitrate, int maximumBitrate)
 332 {
 333         m_configBitrateMinimum = minimumBitrate;
 334         m_configBitrateMaximum = maximumBitrate;
 335 }
 336
 337 void MP3Encoder::setSamplingRate(int value)
 338 {
 339         m_configSamplingRate = value;
 340 }
 341
 342 void MP3Encoder::setChannelMode(int value)
 343 {
 344         m_configChannelMode = value;
 345 }
 346
 347 int MP3Encoder::clipBitrate(int bitrate)
 348 {
 349         int targetBitrate = qMin(qMax(bitrate, 32), 320);
 350
 351         int minDiff = INT_MAX;
 352         int minIndx = -1;
 353
 354         for(int i = 0; g_mp3BitrateLUT[i] > 0; i++)
 355         {
 356                 int currentDiff = abs(targetBitrate - g_mp3BitrateLUT[i]);
 357                 if(currentDiff < minDiff)
 358                 {
 359                         minDiff = currentDiff;
 360                         minIndx = i;
 361                 }
 362         }
 363
 364         if(minIndx >= 0)
 365         {
 366                 return g_mp3BitrateLUT[minIndx];
 367         }
 368
 369         return targetBitrate;
 370 }
 371
 372 const AbstractEncoderInfo *MP3Encoder::getEncoderInfo(void)
 373 {
 374         return &g_mp3EncoderInfo;
 375 }