Re: [Devel] Apple Licenses Question

[Antoine Leca]

Daniel Migowski wrote:
> 
> I got the following idea as a "workaround" for the patent.
> As far as I see at the moment, its no problem to deliever a truetype VM,
> if it doesn't use the DELTA instructions

Problem: this severely lowers the rendering quality...

> or can handle opcodes, that work on freedom and projection vectors
> which are not orthogonal.

Hmm, I defer on David (because I did not study carefully the patents)
which I read as agreeing with you.

 
> OK, there are fonts, which use the above technologie, but we have the
> truetype VM, and why can't we write some code (a compiler), that decodes
> the instructions in TrueType-fonts, and replaces them by code, that
> does the actual projection? OK, we have to blow up existing fonts,
> but if only the result matters, who cares?

I believe the resulting effects will be (substancially) worse than the
original.

First, one key point: patents are not like copyrights: the way the actual
code is written is of no effect, that is the "idea" behind the code that
is important.
It would be very easy to write an extension to our TrueType "VM", with
a supplementary opcode (say, $A8) which sets up a special version of
the vectors under which the MxRP operations will behave exactly as
they do with non-parallel vectors; then, the "compiler" will just
rewrite the TT program to invoke the new opcode rather than the ones
($00-$09) that set up the vectors, and the net result will be a font
that will behave exactly the same under our engine than the original did
under any engine (including Freetype). This is basically what is done
when someone need to avoid a copyright issue on some code: let's writing
some other code that does exactly the same, using a different stream of
instructions.
The problem with this approach is that it is very likely to infringe the
patent, because what is patented is the idea of using two vectors (as
I read it, perhaps David can elaborate on this); implementing the new
version of MxRP will need to use the same technics as Apple patented...
As a result, you'll have to produce code that deal with diagonals _only_
using the classical x or y hints; the result is likely to be quite a
bit less attractive than the original.

A much better idea, methinks, is what Vadim exposed (drastically changing
the way diagonal hints are handled).

<ADVOCATE OF DEVIL>
However, there is a big hindrance behind this whole idea: the resulting
fonts can _only_ be handled by Freetype, or in other words cannot be used
on Windows and MacOS; as a result, the "market" for the building of such
fonts will be extremely narrow, which in turn mean that almost nobody
except a handful of fanatics (no pun intended) will take the care of
producing good-quality "TuxType" fonts.
</ADVOCATE>

 
> Then the truetype engine is completly free. The other question is, if the
> compiler is free then. It does not use the patentet technologie 'to render'
> fonts, it just replaces instructions, which result in new fonts, that look
> the same. One could also call these fonts TuxType fonts.

BTW, this is usually a violation of the copyright on the fonts (at least
in normal countries, read outside the U.S.A. ;-)). If you restrict yourself
to the "free" fonts that you can change the code (almost) at will, your
solution is probably too complex, as transforming them to Type1 will be
much easier (or even yet done).

For example, as a type designer, I certainly do not want an automatic tool
to "rewrite" my carefully hinted font; OTOH, I would probably welcome
anyone
that rewrites the hints to Type1 (and then holds a joined copyright) if I
can
verify the quality of the result.
I think other font designers may agree with me.

 
> Btw, maybe font foundrys would then just convert their fonts to TuxType, to
> make them linux compatible?

One, they do not have to, since most fonts are already available as Type1
;-).
Two, I do not usually see foundries as NGOs working for the sake a trublion
like Linux.
Three, perhaps Apple (which at the moment did stay very quiet against
Freetype) may see this as evil, and may start legal actions (which will be
_very_ dommageable to Freetype as a whole); or at least foundries
(remember,
font designers are one of the few remainings Mac fanatics) may want to
avoid
irritating Apple.

 
> PPS: Or is it illegal for a compiler, to produce patented code?

I can't see why it may be. Put in other words, if you build a machine or
a process that may be used to produce patented pieces, as long as you
avoid actually producing these pieces, there is no infringement (unless of
course the process itself is patented, which is usually the case in
industry;
but this is not possible for a compiler alone).
But remember, I am not a lawyer.


Antoine