path: root/src/encoder/encoderfdkaac.cpp

#include "encoder/encoderfdkaac.h"

#ifdef __APPLE__
#include <QCoreApplication>
#endif
#include <QDir>
#include <QStandardPaths>
#include <QString>
#include <QStringList>

#include "engine/sidechain/enginesidechain.h"
#include "recording/defs_recording.h"
#include "util/logger.h"
#include "util/sample.h"

namespace {
// recommended in encoder documentation, section 2.4.1
constexpr int kOutBufferBits = 6144;
const mixxx::Logger kLogger("EncoderFdkAac");
} // namespace

EncoderFdkAac::EncoderFdkAac(EncoderCallback* pCallback)
        : aacEncOpen(nullptr),
          aacEncClose(nullptr),
          aacEncEncode(nullptr),
          aacEncInfo(nullptr),
          aacEncoder_SetParam(nullptr),
          m_aacAot(AOT_AAC_LC),
          m_bitrate(0),
          m_channels(0),
          m_pCallback(pCallback),
          m_pLibrary(nullptr),
          m_pInputFifo(nullptr),
          m_readRequired(0),
          m_aacEnc(),
          m_aacInfo(),
          m_hasSbr(false) {
    // Load the shared library
    //
    // Libraries from external sources take priority because they may include HE-AAC support,
    // but we do not risk shipping that with Mixxx because of patents and GPL compatibility.
    //
    // From https://bugzilla.redhat.com/show_bug.cgi?id=1501522#c112 :
    // The Fedora Project is aware that the Free Software Foundation
    // has stated that the Fraunhofer FDK AAC license is GPL
    // incompatible, specifically, because of Clause 3.
    //
    // We believe that the fdk-aac software codec implementation that we
    // wish to include in Fedora [which is shipped with Mixxx on Windows and macOS]
    // is no longer encumbered by AAC patents.
    // This fact means that Clause 3 in the FDK AAC license is a "no op",
    // or to put it plainly, if no patents are in play, there are no
    // patent licenses to disclaim. For this (and only this) specific
    // implementation of fdk-aac, we believe that the FDK AAC license is
    // GPL compatible.
    QStringList libnames;
#if defined(__WINDOWS__)
    // Search for library from B.U.T.T.
    QString buttFdkAacPath = buttWindowsFdkAac();
    if (!buttFdkAacPath.isEmpty()) {
        kLogger.debug() << "Found libfdk-aac at" << buttFdkAacPath;
        libnames << buttFdkAacPath;
    }
#elif defined(__APPLE__)
    // Homebrew
    libnames << QStringLiteral("/usr/local/lib/libfdk-aac");
    // MacPorts
    libnames << QStringLiteral("/opt/local/lib/libfdk-aac");

    // Mixxx application bundle
    QFileInfo bundlePath(QCoreApplication::applicationDirPath() +
            QStringLiteral("/../Frameworks/libfdk-aac"));
    libnames << bundlePath.absoluteFilePath();
#endif
    libnames << QStringLiteral("fdk-aac");
    // Although the line above should suffice, detection of the fdk-aac library
    // does not work on Ubuntu 20.04 LTS:
    //
    //     $ dpkg -L libfdk-aac1 | grep so
    //     /usr/lib/x86_64-linux-gnu/libfdk-aac.so.1.0.0
    //     /usr/lib/x86_64-linux-gnu/libfdk-aac.so.1
    //
    // As a workaround, we have to hardcode the filenames here.
    libnames << QStringLiteral("libfdk-aac.so.1")
             << QStringLiteral("libfdk-aac.so.2");

    QStringList errorMessages;
    for (const auto& libname : qAsConst(libnames)) {
        m_pLibrary = std::make_unique<QLibrary>(libname, 2);
        if (m_pLibrary->load()) {
            kLogger.debug() << "Successfully loaded encoder library" << m_pLibrary->fileName();
            break;
        }
        // The APIs this class uses did not change between library versions 1 and 2.
        // Ubuntu 20.04 LTS has version 1.
        m_pLibrary = std::make_unique<QLibrary>(libname, 1);
        if (m_pLibrary->load()) {
            kLogger.debug() << "Successfully loaded encoder library" << m_pLibrary->fileName();
            break;
        }
        // collect error messages for the case we have no success
        errorMessages.append(m_pLibrary->errorString());
        m_pLibrary = nullptr;
    }

    if (!m_pLibrary || !m_pLibrary->isLoaded()) {
        for (const auto& errorMessage : qAsConst(errorMessages)) {
            kLogger.warning() << "Failed to load AAC encoder library:" << errorMessage;
        }
        return;
    }

    aacEncGetLibInfo = (aacEncGetLibInfo_)m_pLibrary->resolve("aacEncGetLibInfo");
    aacEncOpen = (aacEncOpen_)m_pLibrary->resolve("aacEncOpen");
    aacEncClose = (aacEncClose_)m_pLibrary->resolve("aacEncClose");
    aacEncEncode = (aacEncEncode_)m_pLibrary->resolve("aacEncEncode");
    aacEncInfo = (aacEncInfo_)m_pLibrary->resolve("aacEncInfo");
    aacEncoder_SetParam = (aacEncoder_SetParam_)m_pLibrary->resolve("aacEncoder_SetParam");

    // Check if all function pointers aren't null.
    // Otherwise, the version of libfdk-aac loaded doesn't comply with the official distribution
    if (!aacEncGetLibInfo ||
            !aacEncOpen ||
            !aacEncClose ||
            !aacEncEncode ||
            !aacEncInfo ||
            !aacEncoder_SetParam) {
        m_pLibrary->unload();
        m_pLibrary = nullptr;

        kLogger.warning() << "Failed to load AAC encoder library: Interface of"
                          << m_pLibrary->fileName() << "is not as expected";

        kLogger.debug() << "aacEncGetLibInfo:" << reinterpret_cast<void*>(aacEncGetLibInfo);
        kLogger.debug() << "aacEncOpen:" << reinterpret_cast<void*>(aacEncOpen);
        kLogger.debug() << "aacEncClose:" << reinterpret_cast<void*>(aacEncClose);
        kLogger.debug() << "aacEncEncode:" << reinterpret_cast<void*>(aacEncEncode);
        kLogger.debug() << "aacEncInfo:" << reinterpret_cast<void*>(aacEncInfo);
        kLogger.debug() << "aacEncoder_SetParam:" << reinterpret_cast<void*>(aacEncoder_SetParam);
        return;
    }

    LIB_INFO libinfo[FDK_MODULE_LAST] = {};
    aacEncGetLibInfo(libinfo);
    for (const auto& li : libinfo) {
        if (li.module_id == FDK_NONE) {
            break;
        }
        qDebug() << li.title << li.versionStr;
        if (li.module_id == FDK_SBRENC) {
            m_hasSbr = true;
        }
    }
}

EncoderFdkAac::~EncoderFdkAac() {
    if (m_pLibrary && m_pLibrary->isLoaded()) {
        aacEncClose(&m_aacEnc);

        flush();
        m_pLibrary->unload();
        kLogger.debug() << "Unloaded libfdk-aac";
    }

    delete m_pInputFifo;
}

QString EncoderFdkAac::buttWindowsFdkAac() {
    // Return %APPDATA%/Local path
    QString appData = QStandardPaths::writableLocation(
            QStandardPaths::AppLocalDataLocation);
    appData = QFileInfo(appData).absolutePath() + "/..";

    // Candidate paths for a butt installation
    QStringList searchPaths;
    searchPaths << "C:/Program Files";
    searchPaths << "C:/Program Files (x86)";
    searchPaths << appData;

    // Try to find a butt installation in one of the
    // potential paths above
    for (const auto& topPath : qAsConst(searchPaths)) {
        QDir folder(topPath);
        if (!folder.exists()) {
            continue;
        }

        // Typical name for a butt installation folder
        // is "butt-x.x.x" so list subfolders beginning with "butt"
        QStringList nameFilters("butt*");
        QStringList subfolders =
                folder.entryList(nameFilters, QDir::Dirs, QDir::Name);

        // If a butt installation is found, try
        // to find libfdk-aac in it
        for (const auto& subName : qAsConst(subfolders)) {
            if (!folder.cd(subName)) {
                continue;
            }

            kLogger.debug()
                    << "Found potential B.U.T.T installation at"
                    << (topPath + "/" + subName);

            QString libFile = "libfdk-aac-2.dll";
            if (folder.exists(libFile)) {
                // Found a libfdk-aac here.
                // Return the full path of the .dll file.
                return folder.absoluteFilePath(libFile);
            }

            folder.cdUp();
        }
    }

    return QString();
}

void EncoderFdkAac::setEncoderSettings(const EncoderSettings& settings) {
    if (settings.getFormat() == ENCODING_AAC) {
        // MPEG-4 AAC-LC
        m_aacAot = AOT_AAC_LC;
    } else if (settings.getFormat() == ENCODING_HEAAC) {
        // MPEG-4 HE-AAC
        m_aacAot = AOT_SBR;
    } else if (settings.getFormat() == ENCODING_HEAACV2) {
        // MPEG-4 HE-AACv2
        m_aacAot = AOT_PS;
    } else {
        // Fallback to AAC-LC in case
        // of unknown value
        m_aacAot = AOT_AAC_LC;
    }

    // TODO(Palakis): support more bitrate configurations
    m_bitrate = settings.getQuality();
    switch (settings.getChannelMode()) {
    case EncoderSettings::ChannelMode::MONO