mirror of
https://libwebsockets.org/repo/libwebsockets
synced 2024-11-24 17:46:45 +00:00
e3dca87f23
This adds optional display list support to lws_display, using DLOs (Display List Objects). DLOs for rectangle / rounded rectangle (with circle as the degenerate case), PNGs, JPEG and compressed, antialiased bitmapped fonts and text primitives are provided. Logical DLOs are instantiated on heap and listed into an lws_display_list owner, DLOs handle attributes like position, bounding box, colour + opacity, and local error diffusion backing buffer. When the display list is complete, it can be rasterized a line at a time, with scoped error diffusion resolved, such that no allocation for the framebuffer is required at any point. DLOs are freed as the rasterization moves beyond their bounding box. Adds a platform registry binding names and other metadata to lws_display fonts / PNGs / JPEGs. Provides registration, destruction and best match selection apis.
488 lines
14 KiB
C++
488 lines
14 KiB
C++
#include "datafile.hh"
|
|
#include "importtools.hh"
|
|
#include "bdf_import.hh"
|
|
#include "freetype_import.hh"
|
|
#include "export_rlefont.hh"
|
|
#include "encode_rlefont.hh"
|
|
#include "optimize_rlefont.hh"
|
|
#include "export_bwfont.hh"
|
|
#include <vector>
|
|
#include <string>
|
|
#include <set>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <cstdlib>
|
|
#include <ctime>
|
|
#include <map>
|
|
#include "ccfixes.hh"
|
|
#include "gb2312_in_ucs2.h"
|
|
|
|
using namespace mcufont;
|
|
|
|
static std::string strip_extension(std::string filename)
|
|
{
|
|
size_t pos = filename.find_last_of('.');
|
|
|
|
if (pos == std::string::npos)
|
|
{
|
|
return filename;
|
|
}
|
|
else
|
|
{
|
|
return filename.substr(0, pos);
|
|
}
|
|
}
|
|
|
|
static std::unique_ptr<DataFile> load_dat(std::string src)
|
|
{
|
|
std::ifstream infile(src);
|
|
|
|
if (!infile.good())
|
|
{
|
|
std::cerr << "Could not open " << src << std::endl;
|
|
return nullptr;
|
|
}
|
|
|
|
std::unique_ptr<DataFile> f = DataFile::Load(infile);
|
|
if (!f)
|
|
{
|
|
std::cerr << "Invalid format for .dat file: " << src << std::endl;
|
|
return nullptr;
|
|
}
|
|
|
|
return f;
|
|
}
|
|
|
|
static bool save_dat(std::string dest, DataFile *f)
|
|
{
|
|
std::ofstream outfile(dest);
|
|
|
|
if (!outfile.good())
|
|
{
|
|
std::cerr << "Could not open " << dest << std::endl;
|
|
return false;
|
|
}
|
|
|
|
f->Save(outfile);
|
|
|
|
if (!outfile.good())
|
|
{
|
|
std::cerr << "Could not write to " << dest << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
enum status_t
|
|
{
|
|
STATUS_OK = 0, // All good
|
|
STATUS_INVALID = 1, // Invalid command or args
|
|
STATUS_ERROR = 2 // Error when executing command
|
|
};
|
|
|
|
static status_t cmd_import_ttf(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 3 && args.size() != 4)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
int size = std::stoi(args.at(2));
|
|
bool bw = (args.size() == 4 && args.at(3) == "bw");
|
|
std::string dest = strip_extension(src) + std::to_string(size) + (bw ? "bw" : "") + ".dat";
|
|
std::ifstream infile(src);
|
|
|
|
if (!infile.good())
|
|
{
|
|
std::cerr << "Could not open " << src << std::endl;
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
std::cout << "Importing " << src << " to " << dest << std::endl;
|
|
|
|
std::unique_ptr<DataFile> f = LoadFreetype(infile, size, bw);
|
|
|
|
mcufont::rlefont::init_dictionary(*f);
|
|
|
|
if (!save_dat(dest, f.get()))
|
|
return STATUS_ERROR;
|
|
|
|
std::cout << "Done: " << f->GetGlyphCount() << " unique glyphs." << std::endl;
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_import_bdf(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 2)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
std::string dest = strip_extension(args.at(1)) + ".dat";
|
|
std::ifstream infile(src);
|
|
|
|
if (!infile.good())
|
|
{
|
|
std::cerr << "Could not open " << src << std::endl;
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
std::cout << "Importing " << src << " to " << dest << std::endl;
|
|
|
|
std::unique_ptr<DataFile> f = LoadBDF(infile);
|
|
|
|
mcufont::rlefont::init_dictionary(*f);
|
|
|
|
if (!save_dat(dest, f.get()))
|
|
return STATUS_ERROR;
|
|
|
|
std::cout << "Done: " << f->GetGlyphCount() << " unique glyphs." << std::endl;
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_filter(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() < 3)
|
|
return STATUS_INVALID;
|
|
|
|
std::set<int> allowed;
|
|
|
|
// Parse arguments
|
|
for (size_t i = 2; i < args.size(); i++)
|
|
{
|
|
std::string s = args.at(i);
|
|
size_t pos = s.find('-');
|
|
if (pos == std::string::npos)
|
|
{
|
|
if(s == "gb2312") {
|
|
allowed.insert(
|
|
&gb2312_in_ucs2_codetable[0],
|
|
&gb2312_in_ucs2_codetable[sizeof(gb2312_in_ucs2_codetable)/sizeof(gb2312_in_ucs2_codetable[0])]);
|
|
} else {
|
|
// Single char
|
|
allowed.insert(std::stoi(s, nullptr, 0));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Range
|
|
int start = std::stoi(s.substr(0, pos), nullptr, 0);
|
|
int end = std::stoi(s.substr(pos + 1), nullptr, 0);
|
|
|
|
for (int j = start; j <= end; j++)
|
|
{
|
|
allowed.insert(j);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string src = args.at(1);
|
|
std::unique_ptr<DataFile> f = load_dat(src);
|
|
if (!f)
|
|
return STATUS_ERROR;
|
|
|
|
std::cout << "Font originally had " << f->GetGlyphCount() << " glyphs." << std::endl;
|
|
|
|
// Filter the glyphs
|
|
std::vector<DataFile::glyphentry_t> newglyphs;
|
|
for (size_t i = 0; i < f->GetGlyphCount(); i++)
|
|
{
|
|
DataFile::glyphentry_t g = f->GetGlyphEntry(i);
|
|
|
|
for (size_t j = 0; j < g.chars.size(); j++)
|
|
{
|
|
if (!allowed.count(g.chars.at(j)))
|
|
{
|
|
g.chars.erase(g.chars.begin() + j);
|
|
j--;
|
|
}
|
|
}
|
|
|
|
if (g.chars.size())
|
|
{
|
|
newglyphs.push_back(g);
|
|
}
|
|
}
|
|
|
|
DataFile::fontinfo_t fontinfo = f->GetFontInfo();
|
|
crop_glyphs(newglyphs, fontinfo);
|
|
detect_flags(newglyphs, fontinfo);
|
|
|
|
f.reset(new DataFile(f->GetDictionary(), newglyphs, fontinfo));
|
|
std::cout << "After filtering, " << f->GetGlyphCount() << " glyphs remain." << std::endl;
|
|
|
|
if (!save_dat(src, f.get()))
|
|
return STATUS_ERROR;
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_show_glyph(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 3)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
std::unique_ptr<DataFile> f = load_dat(src);
|
|
|
|
if (!f)
|
|
return STATUS_ERROR;
|
|
|
|
size_t index = 0;
|
|
if (args.at(2) == "largest")
|
|
{
|
|
std::unique_ptr<mcufont::rlefont::encoded_font_t> e =
|
|
mcufont::rlefont::encode_font(*f, false);
|
|
size_t maxlen = 0;
|
|
size_t i = 0;
|
|
for (mcufont::rlefont::encoded_font_t::refstring_t g : e->glyphs)
|
|
{
|
|
if (g.size() > maxlen)
|
|
{
|
|
maxlen = g.size();
|
|
index = i;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
std::cout << "Index " << index << ", length " << maxlen << std::endl;
|
|
}
|
|
else
|
|
{
|
|
index = strtol(args.at(2).c_str(), nullptr, 0);
|
|
}
|
|
|
|
if (index >= f->GetGlyphCount())
|
|
{
|
|
std::cerr << "No such glyph " << index << std::endl;
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
std::cout << "Width: " << f->GetGlyphEntry(index).width << std::endl;
|
|
std::cout << "Chars: ";
|
|
for (int c: f->GetGlyphEntry(index).chars) std::cout << c << " ";
|
|
std::cout << std::endl;
|
|
|
|
std::cout << f->GlyphToText(index);
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_rlefont_export(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 2 && args.size() != 3)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
std::string dst = (args.size() == 2) ? strip_extension(src) + ".mcufont" : args.at(2);
|
|
std::unique_ptr<DataFile> f = load_dat(src);
|
|
|
|
if (!f)
|
|
return STATUS_ERROR;
|
|
|
|
{
|
|
std::ofstream source(dst);
|
|
mcufont::rlefont::write_source(source, dst, *f);
|
|
std::cout << "Wrote " << dst << std::endl;
|
|
}
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_rlefont_size(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 2)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
std::unique_ptr<DataFile> f = load_dat(src);
|
|
|
|
if (!f)
|
|
return STATUS_ERROR;
|
|
|
|
size_t size = mcufont::rlefont::get_encoded_size(*f);
|
|
|
|
std::cout << "Glyph count: " << f->GetGlyphCount() << std::endl;
|
|
std::cout << "Glyph bbox: " << f->GetFontInfo().max_width << "x"
|
|
<< f->GetFontInfo().max_height << " pixels" << std::endl;
|
|
std::cout << "Uncompressed size: " << f->GetGlyphCount() *
|
|
f->GetFontInfo().max_width * f->GetFontInfo().max_height / 2
|
|
<< " bytes" << std::endl;
|
|
std::cout << "Compressed size: " << size << " bytes" << std::endl;
|
|
std::cout << "Bytes per glyph: " << size / f->GetGlyphCount() << std::endl;
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_rlefont_optimize(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 2 && args.size() != 3)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
std::unique_ptr<DataFile> f = load_dat(src);
|
|
|
|
if (!f)
|
|
return STATUS_ERROR;
|
|
|
|
size_t oldsize = mcufont::rlefont::get_encoded_size(*f);
|
|
|
|
std::cout << "Original size is " << oldsize << " bytes" << std::endl;
|
|
std::cout << "Press ctrl-C at any time to stop." << std::endl;
|
|
std::cout << "Results are saved automatically after each iteration." << std::endl;
|
|
|
|
int limit = 100;
|
|
if (args.size() == 3)
|
|
{
|
|
limit = std::stoi(args.at(2));
|
|
}
|
|
|
|
if (limit > 0)
|
|
std::cout << "Limit is " << limit << " iterations" << std::endl;
|
|
|
|
int i = 0;
|
|
time_t oldtime = time(NULL);
|
|
while (!limit || i < limit)
|
|
{
|
|
mcufont::rlefont::optimize(*f);
|
|
|
|
size_t newsize = mcufont::rlefont::get_encoded_size(*f);
|
|
time_t newtime = time(NULL);
|
|
|
|
int bytes_per_min = (oldsize - newsize) * 60 / (newtime - oldtime + 1);
|
|
|
|
i++;
|
|
std::cout << "iteration " << i << ", size " << newsize
|
|
<< " bytes, speed " << bytes_per_min << " B/min"
|
|
<< std::endl;
|
|
|
|
{
|
|
if (!save_dat(src, f.get()))
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_rlefont_show_encoded(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 2)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
std::unique_ptr<DataFile> f = load_dat(src);
|
|
|
|
if (!f)
|
|
return STATUS_ERROR;
|
|
|
|
std::unique_ptr<mcufont::rlefont::encoded_font_t> e =
|
|
mcufont::rlefont::encode_font(*f, false);
|
|
|
|
int i = 0;
|
|
for (mcufont::rlefont::encoded_font_t::rlestring_t d : e->rle_dictionary)
|
|
{
|
|
std::cout << "Dict RLE " << 24 + i++ << ": ";
|
|
for (uint8_t v : d)
|
|
std::cout << std::setfill('0') << std::setw(2) << std::hex << (int)v << " ";
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
for (mcufont::rlefont::encoded_font_t::refstring_t d : e->ref_dictionary)
|
|
{
|
|
std::cout << "Dict Ref " << 24 + i++ << ": ";
|
|
for (uint8_t v : d)
|
|
std::cout << std::setfill('0') << std::setw(2) << std::hex << (int)v << " ";
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
i = 0;
|
|
for (mcufont::rlefont::encoded_font_t::refstring_t g : e->glyphs)
|
|
{
|
|
std::cout << "Glyph " << i++ << ": ";
|
|
for (uint8_t v : g)
|
|
std::cout << std::setfill('0') << std::setw(2) << std::hex << (int)v << " ";
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static status_t cmd_bwfont_export(const std::vector<std::string> &args)
|
|
{
|
|
if (args.size() != 2 && args.size() != 3)
|
|
return STATUS_INVALID;
|
|
|
|
std::string src = args.at(1);
|
|
std::string dst = (args.size() == 2) ? strip_extension(src) + ".c" : args.at(2);
|
|
std::unique_ptr<DataFile> f = load_dat(src);
|
|
|
|
if (!f)
|
|
return STATUS_ERROR;
|
|
|
|
if (!(f->GetFontInfo().flags & DataFile::FLAG_BW))
|
|
{
|
|
std::cout << "Warning: font is not black and white" << std::endl;
|
|
}
|
|
|
|
{
|
|
std::ofstream source(dst);
|
|
mcufont::bwfont::write_source(source, dst, *f);
|
|
std::cout << "Wrote " << dst << std::endl;
|
|
}
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
|
|
static const char *usage_msg =
|
|
"Usage: mcufont <command> [options] ...\n"
|
|
"Commands for importing:\n"
|
|
" import_ttf <ttffile> <size> [bw] Import a .ttf font into a data file.\n"
|
|
" import_bdf <bdffile> Import a .bdf font into a data file.\n"
|
|
"\n"
|
|
"Commands for inspecting and editing data files:\n"
|
|
" filter <datfile> <range> ... Remove everything except specified characters.\n"
|
|
" show_glyph <datfile> <index> Show the glyph at index.\n"
|
|
"\n"
|
|
"Commands specific to rlefont format:\n"
|
|
" rlefont_size <datfile> Check the encoded size of the data file.\n"
|
|
" rlefont_optimize <datfile> Perform an optimization pass on the data file.\n"
|
|
" rlefont_export <datfile> [outfile] Export to .c source code.\n"
|
|
" rlefont_show_encoded <datfile> Show the encoded data for debugging.\n"
|
|
"\n"
|
|
"Commands specific to bwfont format:\n"
|
|
" bwfont_export <datfile> [outfile] Export to .c source code.\n"
|
|
"";
|
|
|
|
typedef status_t (*cmd_t)(const std::vector<std::string> &args);
|
|
static const std::map<std::string, cmd_t> command_list {
|
|
{"import_ttf", cmd_import_ttf},
|
|
{"import_bdf", cmd_import_bdf},
|
|
{"filter", cmd_filter},
|
|
{"show_glyph", cmd_show_glyph},
|
|
{"rlefont_size", cmd_rlefont_size},
|
|
{"rlefont_optimize", cmd_rlefont_optimize},
|
|
{"rlefont_export", cmd_rlefont_export},
|
|
{"rlefont_show_encoded", cmd_rlefont_show_encoded},
|
|
{"bwfont_export", cmd_bwfont_export},
|
|
};
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
std::vector<std::string> args;
|
|
for (int i = 1; i < argc; i++)
|
|
args.push_back(argv[i]);
|
|
|
|
status_t status = STATUS_INVALID;
|
|
if (args.size() >= 1 && command_list.count(args.at(0)))
|
|
{
|
|
status = command_list.find(args.at(0))->second(args);
|
|
}
|
|
|
|
if (status == STATUS_INVALID)
|
|
{
|
|
std::cout << usage_msg << std::endl;
|
|
}
|
|
|
|
return status;
|
|
}
|