coretext: implement GetFallbackFunc

fontselect: add bounds checking for memory font stream reads

font: fix double frees if opening memory font fails

Apparently, libfreetype calls close_stream_font through the
FT_Stream.close callback.

fontselect: fix a memory leak

The result of the subst_font callback was not freed.

fontselect: reimplement ass_set_fonts_dir() functionality

ass_set_fonts_dir() is supposed to enable all fonts in a specific
directory. The implementation for it was dropped with the commit
introducing the new fontselect code. Some users were relying on it, so
we need it back.

It used to be implemented using a single fontconfig call. But since this
has to work even if fontconfig support is not even compiled, a new
implementation is needed.

This commit adds very simple and low-effort support for it. It loads all
files into memory, and then lets the memory font code do the rest. A
more efficient implementation would be possible, for example by
implementing a new font provider, which serves get_data requests from
open file handles. Anyone who wants to do this is welcome to try, and
this commit is just the minimum to restore the lost feature.

render_api: fix crash when calling ass_set_fonts() after rendering

The caches may reference data which belongs to the font provider. If the
font selector and the font provider are destroyed, it can leave dangling
pointers in the renderer cache. (At least that's what it looks like.)

For some reason, this didn't even trigger valgrind warnings with the
fontconfig font provider. Possibly the dangling pointers were FT_Face
pointers, and fontconfig might cache these process-wide.

font: fix broken charmap fallback handling

An earlier commit added this code to avoid adding font faces multiple
times. In this form, it breaks the "Trying all charmaps" fallback case,
which can lead to text being rendered as boxes.

Return the font that is going to contain the missing glyph instead. The
calling code will check again, and run the fallback if necessary.

fontselect: fix fallbacks

I broke it.

configure: proper configure switches for DirectWrite and CoreText

Also, remove the ass_coretext.c conditional compilation hack, and fix
Makefile.am instead.

ass: make font_provider API private

We were discussing whether this should be public or private. It could be
public, because the API is potentially useful, and is relatively simple.
On the other hand, the API is not necessarily final, and making it
public would prevent us from improving/fixing it.

Make it private for now - making it public later is much easier than
having to break the public API later.

ass: ass_fonts_update() is a stub

ass: restore ABI compatibility with older versions (more or less)

While enums normally are ints on most systems, it isn't guaranteed. This
might also make C++ code fail to compile, since C++ doesn't allow
implicit conversion of ints to enums.

If the API user ever passed anything other than 0 or 1, compatibility
will still break, but I guess we have to live with this.

Also extend the doxygen.

fontconfig: fix error checking

FcInitLoadConfig() could faul, leaving rc=1 and fc->config=NULL, making
FcConfigBuildFonts() potentially crash.

Also, the FcConfigBuildFonts() return value was not checked.

fontselect: minor cleanup

Use a pointer to the selected font info, instead of an index. Makes the
code a bit more readable.

fontselect: correctly match list of font substitutions

This code prioritized fonts by scanning order, but the scanning order is
essentially arbitrary. This resulted in suboptimal and indeterministic
font selection by family name.

Prefer the order as returned by the substitution callback. This requires
some restructuring. The core algorithm is still exactly the same though;
only the order of comparisons changes.

If the font backend has no subtitution callback, nothing should change.

fontselect: deal with potential ASS_FontProvider.subst_font failure

Don't assume it sets all fields. If it doesn't return any font names at
all, go with the default.

fontconfig: implement substitutions

Signed-off-by: wm4 <wm4@nowhere>

fontselect: check fontprovider constructors for failure

Should fix the DirectWrite to Fontconfig fallback.

Rename dwrite.h, minor cleanups

Rename dwrite.h to dwrite_c.h to make the difference between the
official header and ours clearer. Also apply minor cleanups to it.

Remove the patch against upstream MinGW; it's pointless now.

Fix typedefs

configure: remove some unneeded checks

directwrite: don't crash on unknown DWRITE_FONT_STRETCH

The existing code doesn't even handle all currently defined values
for it, and nothing says no new values are ever going to be added.

directwrite: convert to C

Unfortunately, nobody ever tested the MinGW dwrite.h header in C. There
are multiple glaring mistakes, and the header doesn't even compile by
itself. The main issues are overloaded functions (which doesn't work
in C), and broken COBJMACROS defines.

dwrite.diff contains changes to dwrite.h which make libass work.
Warning: the patch lacks a required change to the DrawInlineObject
method of IDWriteTextRenderer (missing THIS_).

Additionally, these definitions would ideally be provided by dwrite.h:

DEFINE_GUID(IID_IDWriteFactory, 0xb859ee5a,0xd838,0x4b5b,0xa2,0xe8,0x1a,0xdc,0x7d,0x93,0xdb,0x48);
DEFINE_GUID(IID_IDWritePixelSnapping, 0xeaf3a2da,0xecf4,0x4d24,0xb6,0x44,0xb3,0x4f,0x68,0x42,0x02,0x4b);
DEFINE_GUID(IID_IDWriteTextRenderer, 0xef8a8135,0x5cc6,0x45fe,0x88,0x25,0xc5,0xa0,0x72,0x4e,0xb8,0x19);

Also, in order to make libass compile out of the box with current
MinGW/msys installations, a very stripped down in-tree copy of dwrite.h
is provided.

directwrite: dynamically load dwrite.dll

directwrite: compile only on Windows

fontselect: prefer platform font providers

Prefer DirectWrite before the cross-platform fontconfig, so that
DirectWrite is used by default if both are compiled into libass.

directwrite: add font fallback callback

This uses a faux rendering with a high-level interface of DirectWrite
to determine a suitable fallback. Choices are different from GDI,
but reasonable.

fontconfig: add font fallback callback

This creates a sorted list of fallback fonts and reuses it, for speed.
Font sorting is very slow.

fontselect: add fallback handling with callback

If we can't find a matching font face (with glyph coverage), ask the
default font provider for a fallback family. The callback is optional.

fontselect: improved face selection among a family

We want the best variant, but if it doesn't have the glyph coverage,
we may also use another variant from the same family.

Constify ass_msg format (NFC)

directwrite: multiple improvements to font scanning

There were various issues with font scanning. This addresses the following:

- Synthesized font faces (bold/oblique) were added to the list. Just skip
  those, this is handled internally by libass.
- Use the win32 font family names, if available. Traditionally, Windows
  groups font families in a different way, so that the number of
  variants is small (<= 4). With this, Arial Narrow and Arial Black
  appear as a separate family, which is what we want.
- Full names are not mandatory. Correctly handle the case that there
  are no full names.
- Don't use the bogus LOCALE_NAME_MAX_LENGTH constant to determine the
  size of the name buffer. Names can be almost arbitrarily long.
  Handle names up to 256 characters correctly and truncate longer names.

fontselect: fix oblique/italic mixup

The constants were swapped. In some cases this lead to incorrect matching.

fontselect: fix undefined behavior with calloc

If allocations have the size zero, malloc/calloc implementations
can return a zero-size buffer or NULL. The earlier introduced malloc
checking blows up if an implementation returns NULL. Fix that by only
allocating and checking when it's actually needed.

Also fix a minor problem with iconv deinitialization in an error path.

directwrite: fix linking

fontselect: replace magic numbers (NFC)

fontselect: trim names of embedded fonts

Embedded fonts tend to be extra bad, so trim the names. I have
encountered fonts faces with untrimmed names.

Leave this at the discretion of the font provider for platform-specific
font providers.

fontselect: add and use strdup_trimmed

This is just a cleaner and safer interface for string trimming.

fontselect: simplify lookup of embedded fonts

Currently, it is not safe to change the embedded fonts
(ass_add_font/ass_clear_fonts) while an ASS_Renderer exists. We can
simplify how embedded fonts are looked up because of that.

At some point, ASS_Library and ASS_Renderer should be merged and we
can then implement a more flexible approach.

fontselect: malloc and error checking

Add malloc checks with useful semantics and error checks in some
specific cases. This should hopefully make fontselect more robust.

The platform-specific font providers (DirectWrite/CoreText/FontConfig)
still need to be checked for proper memory management.

fontselect: simplify cmap lookup for embedded fonts

FreeType can do it for us and is probably more efficient. Also fixes
deinitialization order of ASS_Renderer to make this work.

fontselect: improved and simplified matching

Sorting the font list is overkill and not very useful. We are
interested in *exact* name matches only; all other font families don't
matter and we'll use another fallback mechanism for glyph fallbacks
(TBD).

Replace the sorting and glyph fallback search with a simple linear
scan.  Fonts are first matched against family name first (to allow
further comparison against style attributes) and if that fails,
the fullname is considered.

fontselect: add fallback and substitution callbacks

Add callbacks to introduce more sane fallback handling and font
alias substitutions.

fontselect: add documentation

Add some documentation to the font provider callbacks and metadata
struct.

directwrite: fix indentation

directwrite: add missing memory release in case of failure

directwrite: release localizedStrings

directwrite: fix error handling in font scanning

Fix that a single broken font could mess up the entire font scanning.

directwrite: use standard malloc

directwrite: add 'width' attribute

This is required for proper font matching.

directwrite: wire up destroy callbacks

directwrite: cache FontFileStream

Extract a function to set up FontFileStream and store it in a newly
introduced private struct. Fix memory management as well.

directwrite: add initial fontselect implementation

Incomplete, leaks memory, but capable of rendering something.

Changed configure.ac to work with c++ files

Compile the check with the g++ compiler now

Added directwrite check

fontselect: fix NULL dereference

Apparently on some broken fonts, FreeType can return a NULL family name. Avoid
to crash in these cases.

Provisional support for libiconv

Fix compiler compatibility

Fix warnings

fontselect: expose a fontprovider listing API

This allows client code to query libass for the font providers it was compiled
with. It can be useful for clients so that they can show selection interfaces
to their users.

fontselect: expose a fontprovider selection API

Allow the user of libass to select the font provider from ass_set_fonts. This
API change actually doesn't break client code which was passing `fc=1`; now
the same value will autodetect a usable font provider.

Also add an api to list available font providers as that is useful for client
code to show drop down menus with a font provider to choose from.

fontselect: use fallback fonts when querying font providers

51f9e80b added a MatchFontsFunc callback which allows to lookup font names
directly on the font provider. This approach broke support for font fallback
which worked only with lookups from libass in-memory font database.

This commit moves the font fallback code in the font lookup function, so that
it is available for all font providers.

coretext: fix conversion from CFStringRef to utf8 buffer

The code incorrectly assumed that the utf8 characters could always be
represented with only one byte. This commit queries CFStringRef instances for
the actual amount of bytes needed.

coretext: also lazy load fonts based on Family and PostScript names

Previously, the lazy load of fonts was only using display name. Also use the
other names available through the CoreText API (FamilyName and PostScriptName).

fontselect: coretext: allow to match fontname using the provider

Not all APIs cache everything the same way that fontconfig does. This allows
to first perform a match based on the font name and then score the matched
fonts using the common code using and in memory database approach.

The benefit is the application doesn't have to load all of the fonts and
query for weight, slant, width, path and fullnames.

I left both code paths inside ass_coretext.c. This allows to test matching
problems and have a term of comparison with the slower implementation.
To activate it one just has to flip the CT_FONTS_EAGER_LOAD define to 1.

Here are some benchmarks with a pretty typical OS X font library of ~600 fonts
and using Libass's test program to load a script with 'Helvetica Neue':

CT_FONTS_EAGER_LOAD=0
0.04s user 0.02s system 79% cpu 0.081 total

CT_FONTS_EAGER_LOAD=1
0.12s user 0.06s system 44% cpu 0.420 total

fontselect: coretext: allow selection based on PostScript name

Up until now fontselect used the face index to identify which font to load
from a font collection. While this pretty convenient when using something
freetype based like fontconfig, it seems to be somewhat freetype specific.

CoreText uses the PostScript name as the unique identifier of a font. This
commit allows to use that instead of the index to decide which face to open
with FT_New_Face. To use the PostScript name the provider must return a -1
index and the PostScript name.

fontselect: implement a coretext font provider

Fontconfig is known to be very slow on OS X and Windows, this has to do with
the extremely prohibitive cache times (which are getting even longer with
latest versions of Fontconfig).

This commits starts to address the problem by using CoreText on OS X to load
the font data. The commit uses the simplest possible approach to load all of
the data in memory and then use it to match. This causes a somewhat slow
startup time (around ~400ms on my i7) but it is already better than waiting
*minutes* for Fontconfig to cache the fonts data.

A later commit will improve the speed of the match by using a hybrid approach
that lazy loads in the libass database only the necessary fonts.

Add todo comments

Support multiple font family names

Some fonts use localized family names, especially CJK fonts, which
often have English and Japanese or Chinese names. Handle these cases
just like full names.

nit: add width to font_info_dump

Add support for font width property

Add a width field to metadata. This is used for sorting fonts as
well. Fixes wrong matches with different width variants in the same
font family.

Use streamed access for memory fonts

This is faster in many cases, and more suitable for Windows' GetFontData
function.

Pass family name as path for memory fonts

This is a bit nicer because we can actually see which physical font
has been selected for a certain logical font.

Export font provider interface

Add wrapper to the ASS_Renderer to create a font provider from
its internal font selector and shuffle some code around to export
everything that's needed for font providers to the public. Document
font provider functions.

Memory font support

Allow memory fonts with the get_face_data callback. This feature is
used for embedded fonts, but can be used by any font provider.

Make sure font path is valid

We do not support memory-based fonts yet, so a path is mandatory.

Fix weight validity check

Free a provider's fonts when it is freed

When a provider is freed, iterate the font database, free all fonts
that belong to that provider and compact the database afterwards.

Add convenience defines for slant values

There is no standard scale for slant. This is almost a boolean
attribute. However, a font can have a real italic variant, and/or a
simple oblique variant. fontconfig's notation supports both of these,
so it makes sense to reuse that notation for the sake of flexibility;
we might need to differentiate between them.

oops: remove debug output

Check weight and slant validity in font provider

When adding a new font, check that weight and slant are valid. If
they're not, use reasonable defaults.

Use TrueType font weight scale

fontconfig uses an unusual scale from 0-215 for the font weight. It
looks like it is somewhat derived from the typographic scale some font
families use, but is still rather nonstandard. Nowadays the TrueType
scale from 100-900 seems to be standard. CSS uses it, for example.

However, most importantly, VSFilter also uses the TrueType scale. So
let's use it in libass, too.

Fix similarity calculations

Add a fixed set of fallback fonts

Add a small set of fixed fallback fonts, some of them with very wide
glyph coverage.

Don't match any font if there's no glyph coverage

Do not return a font face at all instead of using the last one. Fixes
fallback to the default font path.

Restore fontconfig runtime configuration

Pass the fontconfig configuration file option and enable switch
through into the font selector. This restores some of the old
functionality related to fontconfig.

However, the functionality to delay the fontconfig database update will
not come back. This is not a big problem. Later it will be possible to
manually add the fontconfig provider, which will delay the update in a
comparable way.

Fix compilation without fontconfig

Conditionally add the fontconfig provider. We can actually run
without fontconfig now! That is, if embedded fonts or fallbacks are
good enough.

Fix off-by-one bug in font matching

Add reference to font provider in font database

This provides more flexibility than just referencing the callbacks:
we can identify the font provider (useful for removing fonts when a
provider is freed) and possibly access the font provider private data.

Improve font selector/provider documentation

Convert embedded font handling to a real font provider

Add glyph coverage map for embedded fonts

Introduce a simple glyph coverage map (created when the font is added)
and use it for checking glyph coverage in font selection. This uses a
simple linear search at the moment.

Never add a face twice to an ASS_Font

Introduce a unique ID per font face and check it in add_face to make
sure we never add a font face twice. This is useful in case the glyph
coverage report is unreliable.

Fix trimming function

Did not correctly handle empty strings (only whitespace). Whoops.

Trim spaces of font family strings

This adds a trimming utility function that is used for trimming strings
of font requests in the font sorter.

Custom font matching and font sources

Implement a simple font sorter (FontSelector) and an interface to deal
with multiple font sources (FontProvider). Unfinished business,
but works for the most part. Currently the only implemented FontProvider
uses fontconfig.

Implement cascade gaussian blur

That's complete version with SSE2/AVX2 assembly.
Should be much faster than old algorithm even in pure C.

Algorithm description can be found in this article (PDF):
https://github.com/MrSmile/CascadeBlur/releases

Close #9

Fix code path of rasterization through FreeType

Release 0.12.3