amuse/driver/amuseconv.cpp

#include "amuse/amuse.hpp"
#include "athena/FileReader.hpp"
#include "athena/DNAYaml.hpp"
#include "logvisor/logvisor.hpp"
#include <stdio.h>
#include <string.h>

static logvisor::Module Log(_S("amuseconv"));

static bool BuildAudioGroup(const amuse::SystemString& groupBase, const amuse::SystemString& targetPath)
{
    return true;
}

static bool ExtractAudioGroup(const amuse::SystemString& inPath, const amuse::SystemString& targetPath)
{
    amuse::ContainerRegistry::Type type;
    auto groups = amuse::ContainerRegistry::LoadContainer(inPath.c_str(), type);

    if (groups.size())
    {
        Log.report(logvisor::Info, _S("Found '%s'"), amuse::ContainerRegistry::TypeToName(type));

        amuse::Mkdir(targetPath.c_str(), 0755);
        Log.report(logvisor::Info, _S("Established directory at %s"), targetPath.c_str());

        for (auto& group : groups)
        {
            Log.report(logvisor::Info, _S("Extracting %s"), group.first.c_str());
        }

    }

    auto songs = amuse::ContainerRegistry::LoadSongs(inPath.c_str());
    amuse::SystemString songsDir = targetPath + _S("/midifiles");
    bool madeDir = false;
    for (auto& pair : songs)
    {
        if (!madeDir)
        {
            amuse::Mkdir(songsDir.c_str(), 0755);
            madeDir = true;
        }

        amuse::SystemString songPath = songsDir + _S('/') + pair.first + _S(".mid");
        FILE* fp = amuse::FOpen(songPath.c_str(), _S("wb"));
        if (fp)
        {
            Log.report(logvisor::Info, _S("Extracting %s"), pair.first.c_str());
            amuse::SongConverter::Target extractedTarget;
            std::vector<uint8_t> mid = amuse::SongConverter::SongToMIDI(pair.second.m_data.get(), extractedTarget);
            fwrite(mid.data(), 1, mid.size(), fp);
            fclose(fp);
        }
    }

    return true;
}

static bool BuildN64SNG(const amuse::SystemString& inPath, const amuse::SystemString& targetPath, bool bigEndian)
{
    return true;
}

static bool BuildGCNSNG(const amuse::SystemString& inPath, const amuse::SystemString& targetPath)
{
    return true;
}

static bool ExtractSNG(const amuse::SystemString& inPath, const amuse::SystemString& targetPath)
{
    return true;
}

enum ConvType
{
    ConvN64,
    ConvGCN,
    ConvPC
};

static void ReportConvType(ConvType tp)
{
    switch (tp)
    {
    case ConvN64:
        Log.report(logvisor::Info, _S("using N64 format"));
        break;
    case ConvPC:
        Log.report(logvisor::Info, _S("using PC format"));
        break;
    case ConvGCN:
    default:
        Log.report(logvisor::Info, _S("using GameCube format"));
        break;
    }
}

#if _WIN32
int wmain(int argc, const amuse::SystemChar** argv)
#else
int main(int argc, const amuse::SystemChar** argv)
#endif
{
    logvisor::RegisterConsoleLogger();

    if (argc < 3)
    {
        printf("Usage: amuseconv <in-file> <out-file> [n64|pc|gcn]\n");
        return 0;
    }

    ConvType type = ConvGCN;
    if (argc >= 4)
    {
        if (!amuse::CompareCaseInsensitive(argv[3], _S("n64")))
            type = ConvN64;
        else if (!amuse::CompareCaseInsensitive(argv[3], _S("gcn")))
            type = ConvGCN;
        else if (!amuse::CompareCaseInsensitive(argv[3], _S("pc")))
            type = ConvPC;
        else
        {
            Log.report(logvisor::Error, _S("unrecognized format: %s"), argv[3]);
            return 1;
        }
    }

    bool good = false;
    FILE* fin = amuse::FOpen(argv[1], _S("rb"));
    if (fin)
    {
        fclose(fin);
        amuse::SystemString barePath(argv[1]);
        size_t dotPos = barePath.rfind(_S('.'));
        const amuse::SystemChar* dot = barePath.c_str() + dotPos;
        if (dotPos != amuse::SystemString::npos)
        {
            if (!amuse::CompareCaseInsensitive(dot, _S(".mid")) ||
                !amuse::CompareCaseInsensitive(dot, _S(".midi")))
            {
                ReportConvType(type);
                switch (type)
                {
                case ConvN64:
                    good = BuildN64SNG(amuse::SystemString(barePath.begin(), barePath.begin() + dotPos), argv[2], true);
                    break;
                case ConvPC:
                    good = BuildN64SNG(amuse::SystemString(barePath.begin(), barePath.begin() + dotPos), argv[2], false);
                    break;
                case ConvGCN:
                default:
                    good = BuildGCNSNG(amuse::SystemString(barePath.begin(), barePath.begin() + dotPos), argv[2]);
                    break;
                }
            }
            else if (!amuse::CompareCaseInsensitive(dot, _S(".son")) ||
                     !amuse::CompareCaseInsensitive(dot, _S(".sng")))
            {
                good = ExtractSNG(argv[1], argv[2]);
            }
            else
            {
                good = ExtractAudioGroup(argv[1], argv[2]);
            }
        }
    }
    else
    {
        amuse::Sstat theStat;
        if (!amuse::Stat(argv[1], &theStat) && S_ISDIR(theStat.st_mode))
        {
            amuse::SystemString projectPath(argv[1]);
            projectPath += _S("/project.yaml");
            fin = amuse::FOpen(projectPath.c_str(), _S("rb"));
            if (fin)
            {
                fclose(fin);
                ReportConvType(type);
                good = BuildAudioGroup(argv[1], argv[2]);
            }
        }
    }

    if (!good)
    {
        Log.report(logvisor::Error, _S("unable to convert %s to %s"), argv[1], argv[2]);
        return 1;
    }

    return 0;
}