mirror of
https://libwebsockets.org/repo/libwebsockets
synced 2024-11-22 00:57:52 +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.
127 lines
3.9 KiB
C++
127 lines
3.9 KiB
C++
// Given a dictionary and glyphs, encode the data for all the glyphs.
|
|
|
|
#pragma once
|
|
|
|
#include "datafile.hh"
|
|
#include <vector>
|
|
#include <memory>
|
|
|
|
namespace mcufont {
|
|
namespace rlefont {
|
|
|
|
struct encoded_font_t
|
|
{
|
|
// RLE-encoded format for storing the dictionary entries.
|
|
// Each item is a byte. Top bit means the value in the original bitstream,
|
|
// and the bottom 7 bits store the repetition count.
|
|
typedef std::vector<uint8_t> rlestring_t;
|
|
|
|
// Reference encoded format for storing the glyphs.
|
|
// Each item is a reference to the dictionary.
|
|
// Values 0 and 1 are hardcoded to mean 0 and 1.
|
|
// All other values mean dictionary entry at (i-2).
|
|
typedef std::vector<uint8_t> refstring_t;
|
|
|
|
std::vector<rlestring_t> rle_dictionary;
|
|
std::vector<refstring_t> ref_dictionary;
|
|
std::vector<refstring_t> glyphs;
|
|
};
|
|
|
|
// Encode all the glyphs.
|
|
std::unique_ptr<encoded_font_t> encode_font(const DataFile &datafile,
|
|
bool fast = true);
|
|
|
|
// Sum up the total size of the encoded glyphs + dictionary.
|
|
size_t get_encoded_size(const encoded_font_t &encoded);
|
|
|
|
inline size_t get_encoded_size(const DataFile &datafile, bool fast = true)
|
|
{
|
|
std::unique_ptr<encoded_font_t> e = encode_font(datafile, fast);
|
|
return get_encoded_size(*e);
|
|
}
|
|
|
|
// Decode a single glyph (for verification).
|
|
std::unique_ptr<DataFile::pixels_t> decode_glyph(
|
|
const encoded_font_t &encoded,
|
|
const encoded_font_t::refstring_t &refstring,
|
|
const DataFile::fontinfo_t &fontinfo);
|
|
|
|
// Decode a single glyph (for verification).
|
|
std::unique_ptr<DataFile::pixels_t> decode_glyph(
|
|
const encoded_font_t &encoded, size_t index,
|
|
const DataFile::fontinfo_t &fontinfo);
|
|
|
|
}}
|
|
|
|
|
|
#ifdef CXXTEST_RUNNING
|
|
#include <cxxtest/TestSuite.h>
|
|
|
|
using namespace mcufont;
|
|
using namespace mcufont::rlefont;
|
|
|
|
class RLEFontEncodeTests: public CxxTest::TestSuite
|
|
{
|
|
public:
|
|
void testEncode()
|
|
{
|
|
std::istringstream s(testfile);
|
|
std::unique_ptr<DataFile> f = DataFile::Load(s);
|
|
std::unique_ptr<encoded_font_t> e = encode_font(*f, false);
|
|
|
|
TS_ASSERT_EQUALS(e->glyphs.size(), 3);
|
|
|
|
// Expected values for dictionary
|
|
encoded_font_t::rlestring_t dict0 = {0x01, 0xCE, 0x01, 0xCE};
|
|
encoded_font_t::rlestring_t dict1 = {0x0C};
|
|
encoded_font_t::rlestring_t dict2 = {0xFE};
|
|
encoded_font_t::refstring_t dict3 = {24, 24};
|
|
|
|
TS_ASSERT(e->rle_dictionary.at(0) == dict0);
|
|
TS_ASSERT(e->rle_dictionary.at(1) == dict1);
|
|
TS_ASSERT(e->rle_dictionary.at(2) == dict2);
|
|
TS_ASSERT(e->ref_dictionary.at(0) == dict3);
|
|
|
|
// Expected values for glyphs
|
|
encoded_font_t::refstring_t glyph0 = {27, 27, 27};
|
|
encoded_font_t::refstring_t glyph1 = {24, 0, 132, 25, 14};
|
|
encoded_font_t::refstring_t glyph2 = {228, 26, 244, 14, 14, 14, 228, 26, 16};
|
|
|
|
TS_ASSERT_EQUALS(e->glyphs.at(0), glyph0);
|
|
TS_ASSERT_EQUALS(e->glyphs.at(1), glyph1);
|
|
TS_ASSERT_EQUALS(e->glyphs.at(2), glyph2);
|
|
}
|
|
|
|
void testDecode()
|
|
{
|
|
std::istringstream s(testfile);
|
|
std::unique_ptr<DataFile> f = DataFile::Load(s);
|
|
std::unique_ptr<encoded_font_t> e = encode_font(*f, false);
|
|
|
|
for (size_t i = 0; i < 3; i++)
|
|
{
|
|
std::unique_ptr<DataFile::pixels_t> dec;
|
|
dec = decode_glyph(*e, i, f->GetFontInfo());
|
|
|
|
TS_ASSERT_EQUALS(*dec, f->GetGlyphEntry(i).data);
|
|
}
|
|
}
|
|
|
|
private:
|
|
static constexpr const char *testfile =
|
|
"Version 1\n"
|
|
"FontName Sans Serif\n"
|
|
"MaxWidth 4\n"
|
|
"MaxHeight 6\n"
|
|
"BaselineX 1\n"
|
|
"BaselineY 1\n"
|
|
"DictEntry 1 0 0E0E\n"
|
|
"DictEntry 1 0 000000000000\n"
|
|
"DictEntry 1 0 EEEE\n"
|
|
"DictEntry 1 1 0E0E0E0E\n"
|
|
"Glyph 0 4 0E0E0E0E0E0E0E0E0E0E0E0E\n"
|
|
"Glyph 1 4 0E0E0000000000000000000E\n"
|
|
"Glyph 2 4 0000EEEE000EEE0000EEEE00\n";
|
|
};
|
|
#endif
|