skia/font_converter/src/main.cpp

#ifdef TESTING
#else

#include "font.h"
#include "font_arguments.hpp"
#include "include/core/SkData.h"
#include "include/core/SkFontMgr.h"
#include "include/core/SkStream.h"
#include "include/core/SkTypeface.h"
#include <vector>

static std::vector<char> readFile(const char path[])
{
    FILE* fp = fopen(path, "rb");

    if (fp == nullptr)
    {
        fclose(fp);
        std::ostringstream errorStream;
        errorStream << "Failed to open file " << path;
        throw std::invalid_argument(errorStream.str());
    }
    fseek(fp, 0, SEEK_END);
    size_t length = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    std::vector<char> data;
    data.resize(length);

    if (fread(data.data(), 1, length, fp) != length)
    {
        fclose(fp);
        std::ostringstream errorStream;
        errorStream << "Failed to read file into bytes array " << path;
        throw std::invalid_argument(errorStream.str());
    }

    fclose(fp);
    return data;
}

static void writeFile(const char path[], const void* bytes, size_t length)
{
    FILE* pFile = fopen(path, "wb");
    fwrite(bytes, sizeof(char), length, pFile);
    fclose(pFile);
}

static std::vector<char> build_default_charset()
{
    std::vector<char> charset;
    for (int i = 32; i < 127; ++i)
    {
        charset.push_back(i);
    }
    return charset;
}

int main(int argc, const char* argv[])
{
    try
    {
        FontArguments args(argc, argv);
        sk_sp<SkTypeface> typeface;

        auto src = readFile(args.source().c_str());
        auto srcData = SkData::MakeWithCopy(src.data(), src.size());
        typeface = SkTypeface::MakeFromData(srcData);
        if (!typeface)
        {
            fprintf(stderr, "Failed to convert file to SkTypeface\n");
            return 1;
        }

        std::vector<char> charset;
        auto charsetFile = args.charset();
        if (charsetFile.size() > 0)
        {
            charset = readFile(args.charset().c_str());
        }
        else
        {
            charset = build_default_charset();
        }

        RiveFont font;
        font.load(typeface, charset.data(), charset.size());

        auto dst = font.encode();

        writeFile(args.destination().c_str(), dst->data(), dst->size());
    }
    catch (const args::Completion& e)
    {
        return 0;
    }
    catch (const args::Help&)
    {
        return 0;
    }
    catch (const args::ParseError& e)
    {
        return 1;
    }
    catch (args::ValidationError e)
    {
        return 1;
    }

    return 0;
}

#endif