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 static const g_mp3EncoderInfo;
 113
 114 ///////////////////////////////////////////////////////////////////////////////
 115 // Encoder implementation
 116 ///////////////////////////////////////////////////////////////////////////////
 117
 118 MP3Encoder::MP3Encoder(void)
 119 :
 120         m_binary(lamexp_tools_lookup("lame.exe"))
 121 {
 122         if(m_binary.isEmpty())
 123         {
 124                 MUTILS_THROW("Error initializing MP3 encoder. Tool 'lame.exe' is not registred!");
 125         }
 126
 127         m_algorithmQuality = 2;
 128         m_configBitrateMaximum = 0;
 129         m_configBitrateMinimum = 0;
 130         m_configSamplingRate = 0;
 131         m_configChannelMode = 0;
 132 }
 133
 134 MP3Encoder::~MP3Encoder(void)
 135 {
 136 }
 137
 138 bool MP3Encoder::encode(const QString &sourceFile, const AudioFileModel_MetaInfo &metaInfo, const unsigned int duration, const QString &outputFile, volatile bool *abortFlag)
 139 {
 140         QProcess process;
 141         QStringList args;
 142
 143         args << "--nohist";
 144         args << "-q" << QString::number(g_lameAgorithmQualityLUT[m_algorithmQuality]);
 145
 146         switch(m_configRCMode)
 147         {
 148         case SettingsModel::VBRMode:
 149                 args << "-V" << QString::number(g_lameVBRQualityLUT[qBound(0, m_configBitrate, 9)]);
 150                 break;
 151         case SettingsModel::ABRMode:
 152                 args << "--abr" << QString::number(g_mp3BitrateLUT[qBound(0, m_configBitrate, 13)]);
 153                 break;
 154         case SettingsModel::CBRMode:
 155                 args << "--cbr";
 156                 args << "-b" << QString::number(g_mp3BitrateLUT[qBound(0, m_configBitrate, 13)]);
 157                 break;
 158         default:
 159                 MUTILS_THROW("Bad rate-control mode!");
 160                 break;
 161         }
 162
 163         if((m_configBitrateMaximum > 0) && (m_configBitrateMinimum > 0) && (m_configBitrateMinimum <= m_configBitrateMaximum))
 164         {
 165                 if(m_configRCMode != SettingsModel::CBRMode)
 166                 {
 167                         args << "-b" << QString::number(clipBitrate(m_configBitrateMinimum));
 168                         args << "-B" << QString::number(clipBitrate(m_configBitrateMaximum));
 169                 }
 170         }
 171
 172         if(m_configSamplingRate > 0)
 173         {
 174                 args << "--resample" << QString::number(m_configSamplingRate);
 175         }
 176
 177         switch(m_configChannelMode)
 178         {
 179         case 1:
 180                 args << "-m" << "j";
 181                 break;
 182         case 2:
 183                 args << "-m" << "f";
 184                 break;
 185         case 3:
 186                 args << "-m" << "s";
 187                 break;
 188         case 4:
 189                 args << "-m" << "d";
 190                 break;
 191         case 5:
 192                 args << "-m" << "m";
 193                 break;
 194         }
 195
 196         bool bUseUCS2 = false;
 197
 198         if(!metaInfo.title().isEmpty() && isUnicode(metaInfo.title())) bUseUCS2 = true;
 199         if(!metaInfo.artist().isEmpty() && isUnicode(metaInfo.artist())) bUseUCS2 = true;
 200         if(!metaInfo.album().isEmpty() && isUnicode(metaInfo.album())) bUseUCS2 = true;
 201         if(!metaInfo.genre().isEmpty() && isUnicode(metaInfo.genre())) bUseUCS2 = true;
 202         if(!metaInfo.comment().isEmpty() && isUnicode(metaInfo.comment())) bUseUCS2 = true;
 203
 204         if(bUseUCS2) args << "--id3v2-ucs2"; //Must specify this BEFORE "--tt" and friends!
 205
 206         if(!metaInfo.title().isEmpty()) args << "--tt" << cleanTag(metaInfo.title());
 207         if(!metaInfo.artist().isEmpty()) args << "--ta" << cleanTag(metaInfo.artist());
 208         if(!metaInfo.album().isEmpty()) args << "--tl" <<cleanTag( metaInfo.album());
 209         if(!metaInfo.genre().isEmpty()) args << "--tg" << cleanTag(metaInfo.genre());
 210         if(!metaInfo.comment().isEmpty()) args << "--tc" << cleanTag(metaInfo.comment());
 211         if(metaInfo.year()) args << "--ty" << QString::number(metaInfo.year());
 212         if(metaInfo.position()) args << "--tn" << QString::number(metaInfo.position());
 213         if(!metaInfo.cover().isEmpty()) args << "--ti" << QDir::toNativeSeparators(metaInfo.cover());
 214
 215         if(!m_configCustomParams.isEmpty()) args << m_configCustomParams.split(" ", QString::SkipEmptyParts);
 216
 217         args << QDir::toNativeSeparators(sourceFile);
 218         args << QDir::toNativeSeparators(outputFile);
 219
 220         if(!startProcess(process, m_binary, args))
 221         {
 222                 return false;
 223         }
 224
 225         bool bTimeout = false;
 226         bool bAborted = false;
 227         int prevProgress = -1;
 228
 229         QRegExp regExp("\\(.*(\\d+)%\\)\\|");
 230
 231         while(process.state() != QProcess::NotRunning)
 232         {
 233                 if(*abortFlag)
 234                 {
 235                         process.kill();
 236                         bAborted = true;
 237                         emit messageLogged("\nABORTED BY USER !!!");
 238                         break;
 239                 }
 240                 process.waitForReadyRead(m_processTimeoutInterval);
 241                 if(!process.bytesAvailable() && process.state() == QProcess::Running)
 242                 {
 243                         process.kill();
 244                         qWarning("LAME process timed out <-- killing!");
 245                         emit messageLogged("\nPROCESS TIMEOUT !!!");
 246                         bTimeout = true;
 247                         break;
 248                 }
 249                 while(process.bytesAvailable() > 0)
 250                 {
 251                         QByteArray line = process.readLine();
 252                         QString text = QString::fromUtf8(line.constData()).simplified();
 253                         if(regExp.lastIndexIn(text) >= 0)
 254                         {
 255                                 bool ok = false;
 256                                 int progress = regExp.cap(1).toInt(&ok);
 257                                 if(ok && (progress > prevProgress))
 258                                 {
 259                                         emit statusUpdated(progress);
 260                                         prevProgress = qMin(progress + 2, 99);
 261                                 }
 262                         }
 263                         else if(!text.isEmpty())
 264                         {
 265                                 emit messageLogged(text);
 266                         }
 267                 }
 268         }
 269
 270         process.waitForFinished();
 271         if(process.state() != QProcess::NotRunning)
 272         {
 273                 process.kill();
 274                 process.waitForFinished(-1);
 275         }
 276
 277         emit statusUpdated(100);
 278         emit messageLogged(QString().sprintf("\nExited with code: 0x%04X", process.exitCode()));
 279
 280         if(bTimeout || bAborted || process.exitCode() != EXIT_SUCCESS)
 281         {
 282                 return false;
 283         }
 284
 285         return true;
 286 }
 287
 288 QString MP3Encoder::extension(void)
 289 {
 290         return "mp3";
 291 }
 292
 293 bool MP3Encoder::isFormatSupported(const QString &containerType, const QString &containerProfile, const QString &formatType, const QString &formatProfile, const QString &formatVersion)
 294 {
 295         if(containerType.compare("Wave", Qt::CaseInsensitive) == 0)
 296         {
 297                 if(formatType.compare("PCM", Qt::CaseInsensitive) == 0)
 298                 {
 299                         return true;
 300                 }
 301         }
 302         else if(containerType.compare("MPEG Audio", Qt::CaseInsensitive) == 0)
 303         {
 304                 if(formatType.compare("MPEG Audio", Qt::CaseInsensitive) == 0)
 305                 {
 306                         if(formatProfile.compare("Layer 3", Qt::CaseInsensitive) == 0 || formatProfile.compare("Layer 2", Qt::CaseInsensitive) == 0)
 307                         {
 308                                 if(formatVersion.compare("Version 1", Qt::CaseInsensitive) == 0 || formatVersion.compare("Version 2", Qt::CaseInsensitive) == 0)
 309                                 {
 310                                         return true;
 311                                 }
 312                         }
 313                 }
 314         }
 315
 316         return false;
 317 }
 318
 319 const unsigned int *MP3Encoder::supportedChannelCount(void)
 320 {
 321         static const unsigned int supportedChannels[] = {1, 2, NULL};
 322         return supportedChannels;
 323 }
 324
 325 void MP3Encoder::setAlgoQuality(int value)
 326 {
 327         m_algorithmQuality = qBound(0, value, 3);
 328 }
 329
 330 void MP3Encoder::setBitrateLimits(int minimumBitrate, int maximumBitrate)
 331 {
 332         m_configBitrateMinimum = minimumBitrate;
 333         m_configBitrateMaximum = maximumBitrate;
 334 }
 335
 336 void MP3Encoder::setSamplingRate(int value)
 337 {
 338         m_configSamplingRate = value;
 339 }
 340
 341 void MP3Encoder::setChannelMode(int value)
 342 {
 343         m_configChannelMode = value;
 344 }
 345
 346 int MP3Encoder::clipBitrate(int bitrate)
 347 {
 348         int targetBitrate = qMin(qMax(bitrate, 32), 320);
 349
 350         int minDiff = INT_MAX;
 351         int minIndx = -1;
 352
 353         for(int i = 0; g_mp3BitrateLUT[i] > 0; i++)
 354         {
 355                 int currentDiff = abs(targetBitrate - g_mp3BitrateLUT[i]);
 356                 if(currentDiff < minDiff)
 357                 {
 358                         minDiff = currentDiff;
 359                         minIndx = i;
 360                 }
 361         }
 362
 363         if(minIndx >= 0)
 364         {
 365                 return g_mp3BitrateLUT[minIndx];
 366         }
 367
 368         return targetBitrate;
 369 }
 370
 371 const AbstractEncoderInfo *MP3Encoder::getEncoderInfo(void)
 372 {
 373         return &g_mp3EncoderInfo;
 374 }