ziphandler.cpp

#include "ziphandler.h"
#include <QDebug>
#include <QTemporaryDir>
#include <fstream>
#include <QFile>
#include <QFileInfo>
#include <QProcess>
#include <QDirIterator>

#if defined(__GNUC__)
#ifndef _FILE_OFFSET_BITS
#define _FILE_OFFSET_BITS 64
#endif
#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE 1
#endif
#endif

void ZipHandler::resetVars()
{
    m_zipFileValid = false;
    m_compressionSupportedAudio = false;
    m_compressionSupportedCdg = false;
    m_audioFileFound = false;
    m_cdgFileFound = false;
    m_audioSize = 0;
    m_cdgSize = 0;
    m_compressionLevel = 9;
    m_compressFilesWithZipFn = true;
    m_rgMarkerFileFound = false;
}

bool ZipHandler::extractUsing7z(QString fileName, QString destDir)
{
    QTemporaryDir tmpDir;
    QString tmpZipPath = tmpDir.path() + QDir::separator() + "tmp.zip";
    if (!QFile::copy(fileName, tmpZipPath))
    {
        qWarning() << "error copying zip";
        return false;
    }
    QProcess *process = new QProcess(this);
    QString ext7zPath = "/bin/7za";
    QStringList arguments;
    arguments << "e";
    arguments << "-y";
    arguments << "-o" + destDir;
    arguments << tmpZipPath;
    process->start(settings->get7zipPath(), arguments);
    process->waitForFinished();
    qWarning() << process->readAllStandardOutput();
    qWarning() << process->readAllStandardError();
    if (process->exitCode() != 0)
        return false;
    else
        return true;
}

bool ZipHandler::reZipUnsupported(QString filePath)
{
    if (qzFile->isOpen())
    {
        qWarning() << "Releasing file handle on original zip";
        qzFile->close();
    }
    QString zipFileName = QFileInfo(filePath).fileName();
    QTemporaryDir tmpDir;
    if (!extractUsing7z(filePath, tmpDir.path()))
    {
        qWarning() << "Failed to extract files";
        return false;
    }
    QString audioFile;
    QString cdgFile;
    QDirIterator iterator(tmpDir.path(), QDirIterator::Subdirectories);
    while (iterator.hasNext()) {
        iterator.next();
        if (!iterator.fileInfo().isDir()) {
            QString fn = iterator.filePath();
            if (fn.endsWith(".cdg", Qt::CaseInsensitive))
            {
                cdgFile = fn;
            }
            else
            {
                for (int e=0; e < audioExtensions.size(); e++)
                {
                    if (fn.endsWith(audioExtensions.at(e), Qt::CaseInsensitive))
                    {
                        audioFile = fn;
                    }
                }
            }
        }
    }
    if (audioFile == "" || cdgFile == "")
    {
        qWarning() << "File missing either mp3 of cdg file, bailing out";
        return false;
    }
    createZip(tmpDir.path() + QDir::separator() + zipFileName, cdgFile, audioFile);
    QString tmpFilePath = QString(filePath + ".tmp");
    if (!QFile::rename(filePath, tmpFilePath))
    {
        qWarning() << "Unable to move original to temporary file, bailing out";
        qWarning() << "rename(" << filePath << ", " << tmpFilePath << ")";
        return false;
    }
    if (!QFile::copy(tmpDir.path() + QDir::separator() + zipFileName, filePath))
    {
        qWarning() << "Unable to move new file into place, moving original back and bailing out";
        QFile::rename(filePath + ".tmp", filePath);
        return false;
    }
    if (QFile::exists(filePath))
    {
        QFile::remove(tmpFilePath);
        return true;
    }
    return false;
}

QString ZipHandler::getAudioExt()
{
    return m_audioExt;
}

QStringList ZipHandler::getSupportedAudioExts()
{
    return audioExtensions;
}

void ZipHandler::close()
{
    if (qzFile->isOpen())
        qzFile->close();
}

void ZipHandler::loadExtensions()
{
    audioExtensions.append(".mp3");
    audioExtensions.append(".wav");
    audioExtensions.append(".ogg");
    audioExtensions.append(".mov");
    audioExtensions.append(".flac");
}

void ZipHandler::initializeZipFile()
{
    mz_zip_reader_end(m_archive);
    qzFile->close();
    qzFile->setFileName(m_zipFile);
    qzFile->open(QFile::ReadOnly);
    int fileHandle = qzFile->handle();
    czFile = fdopen(fileHandle, "rb");
    mz_zip_archive_file_stat fStat;
    if (!mz_zip_reader_init_cfile(m_archive,czFile,qzFile->size(),0))
    {
        m_zipFileValid = false;
        qWarning() << "Error opening zip file";
        return;
    }
    m_zipFileValid = true;
    unsigned int files = mz_zip_reader_get_num_files(m_archive);
    for (unsigned int i=0; i < files; i++)
    {
        if (mz_zip_reader_file_stat(m_archive, i, &fStat))
        {
            QString fileName = fStat.m_filename;
            if (fileName == "ReplayGainProcessed")
            {
                m_rgMarkerFileFound = true;
            }
            else if (fileName.endsWith(".cdg",Qt::CaseInsensitive))
            {
                m_cdgFileName = fileName;
                m_cdgSize = fStat.m_uncomp_size;
                m_compressionSupportedCdg = fStat.m_is_supported;
                m_cdgFileFound = true;
            }
            else
            {
                for (int e=0; e < audioExtensions.size(); e++)
                {
                    if (fileName.endsWith(audioExtensions.at(e), Qt::CaseInsensitive))
                    {
                        m_audioFileName = fileName;
                        m_audioExt = audioExtensions.at(e);
                        m_audioSize = fStat.m_uncomp_size;
                        m_compressionSupportedAudio = fStat.m_is_supported;
                        m_audioFileFound = true;
                    }
                }
            }
        }
        else
        {
            m_zipFileValid = false;
            return;
        }
    }
}

ZipHandler::ZipHandler(QString zipFile, QObject *parent) :
    QObject(parent)
{
    settings = new Settings(this);
    m_archive = new mz_zip_archive;
    mz_zip_zero_struct(m_archive);
    qzFile = new QFile(this);
    loadExtensions();
    m_zipFile = zipFile;
    resetVars();
    initializeZipFile();
}

ZipHandler::ZipHandler(QObject *parent) :
    QObject(parent)
{
    settings = new Settings(this);
    m_archive = new mz_zip_archive;
    mz_zip_zero_struct(m_archive);
    qzFile = new QFile(this);
    loadExtensions();
    m_zipFile = "";
    resetVars();
}

bool ZipHandler::extractAudio(QDir destDir)
{
    if (m_audioFileFound && m_compressionSupportedAudio)
    {
        QString outFile(destDir.path() + QDir::separator() + "tmp" + m_audioExt);
        if (mz_zip_reader_extract_file_to_file(m_archive, m_audioFileName.toLocal8Bit().data(),outFile.toLocal8Bit().data(),0))
        {
            return true;
        }
    }
    return false;
}

bool ZipHandler::extractCdg(QDir destDir)
{
    if (m_cdgFileFound && m_compressionSupportedCdg)
    {
        QString outFile(destDir.path() + QDir::separator() + "tmp.cdg");
        if (mz_zip_reader_extract_file_to_file(m_archive, m_cdgFileName.toLocal8Bit().data(),outFile.toLocal8Bit().data(),0))
        {
            return true;
        }
    }
    return false;
}

QString ZipHandler::zipFile() const
{
    return m_zipFile;
}

void ZipHandler::setZipFile(const QString &zipFile)
{
    m_zipFile = zipFile;
    resetVars();
    initializeZipFile();
}

int ZipHandler::getSongDuration()
{
    return ((m_cdgSize / 96) / 75) * 1000;
}

bool ZipHandler::createZip(QString zipFile, QString cdgFile, QString audioFile, bool addRgMarker)
{
    QString audioFileName, cdgFileName;
    if (m_compressFilesWithZipFn)
    {
        QString zipFileBaseName, audioFileExt;
        zipFileBaseName = QFileInfo(zipFile).completeBaseName();
        audioFileExt = QFileInfo(audioFile).suffix();
        cdgFileName = zipFileBaseName + ".cdg";
        audioFileName = zipFileBaseName + "." + audioFileExt;
    }
    else
    {
        audioFileName = QFileInfo(audioFile).fileName();
        cdgFileName = QFileInfo(cdgFile).fileName();
    }
    qWarning() << "Creating zip file: " << zipFile;
    qWarning() << "Adding: " << cdgFile << " as " << cdgFileName;
    qWarning() << "Adding: " << audioFile << " as " << audioFileName;
    mz_zip_archive zip_archive;
    memset(&zip_archive, 0, sizeof(zip_archive));
    if (!mz_zip_writer_init_file(&zip_archive, zipFile.toLocal8Bit().data(),0))
    {
        qWarning() << "Error initializing zip file";
    }
    const char *s_pComment = "File has been processed through ReplayGain with OpenKJ KaraokeRG";
    qWarning() << "ZipHandler::createZip(" << zipFile << ", " << cdgFile << ", " << audioFile << ")";
    qWarning() << "Adding mp3 file";
    if (!mz_zip_writer_add_file(&zip_archive, audioFileName.toLocal8Bit().data(), audioFile.toLocal8Bit().data(), NULL, 0, m_compressionLevel))
    {
        qWarning() << "Error adding mp3 file to archive";
        mz_zip_writer_finalize_archive(&zip_archive);
        mz_zip_writer_end(&zip_archive);
        return false;
    }
    qWarning() << "Adding cdg file";
    if (!mz_zip_writer_add_file(&zip_archive, cdgFileName.toLocal8Bit().data(), cdgFile.toLocal8Bit().data(), NULL, 0, m_compressionLevel))
    {
        qWarning() << "Error adding cdg file to archive";
        mz_zip_writer_finalize_archive(&zip_archive);
        mz_zip_writer_end(&zip_archive);
        return false;
    }
    if (addRgMarker)
    {
        qWarning() << "Adding marker to file";
        if (!mz_zip_writer_add_mem(&zip_archive,"ReplayGainProcessed", s_pComment, sizeof(s_pComment), m_compressionLevel))
        {
            qWarning() << "Error adding marker file to archive";
            mz_zip_writer_finalize_archive(&zip_archive);
            mz_zip_writer_end(&zip_archive);
            return false;
        }
    }
    qWarning() << "Files added to archive";
    mz_zip_writer_finalize_archive(&zip_archive);
    mz_zip_writer_end(&zip_archive);
    return true;
}

bool ZipHandler::isValidZipfile()
{
    return m_zipFileValid;
}

bool ZipHandler::containsRGMarkerFile()
{
    return m_rgMarkerFileFound;
}

bool ZipHandler::compressionSupported()
{
    if (m_compressionSupportedAudio && m_compressionSupportedCdg)
        return true;
    return false;
}

bool ZipHandler::containsAudioFile()
{
    return m_audioFileFound;
}

bool ZipHandler::containsCdgFile()
{
    return m_cdgFileFound;
}

void ZipHandler::setCompressionLevel(int level)
{
    m_compressionLevel = level;
}

void ZipHandler::setReplaceFnsWithZipFn(bool replace)
{
    m_compressFilesWithZipFn = replace;
}