I was hoping for a bigger win than this, but cairogears is now significantly
faster than it was with just traps. One potential problem is that adding
src texture coordinates blew up vertex size from 12 bytes to 20, and we're
emitting quite a few vertices. There's plenty of hope for the future,
though: With shaders we could remove the 2 new texcoords again by stuffing a
position to source coordinate transformation matrix in constants. Then
with EXT_geometry_shader4 plus EXT_gpu_shader4 we should be able to get the
24 bytes for 2 vertices down to 16 or less.
This is a minor performance regression over software, but is the basis for
not rasterizing the geometry into a temporary mask, which should be a
significant win.
This appears to be no performance difference in cairogears versus the traps
fallback before, but is a step towards handing the information off to the
hardware.
Gl defaults to NEAREST_MIPMAP_LINEAR on new texture objects.
This should save space or bandwidth with DRI drivers, as they'll use the
parameter as a hint, and then not have to either fix up later or waste
space for unused mipmap levels.
This fixes the operator and operator-alpha tests to rgb24 destinations.
While we request an RGB texture, the returned texture has alpha bits, so when
we blend against it as a renderbuffer, we get the junk alpha values. Whether
or not this is a driver bug, we'll have this problem when we get visuals
with alpha bits for windows despite not requestiong alpha, so we have to
handle it in cairo.
This saves the driver from converting the quad into tris on its own. We'd
rather be able to specify a rect as 2-3 points and use the rectangular
rendering feature that most of our hardware has, if it was possible, but
it isn't exposed in GL.
This reverts commit 564d64a132.
In hindsight, and with further discussion with Jeff Muizelaar, this
behaviour of using the stored contents from the mime-data is completely
the opposite of the users' expectations. When the user calls
cairo_surface_write_to_png(), usually in the course of debugging their
rendering code, they expect the precise contents of the surface to be
saved.
Since we only need to allocate elts for intersection events and edges, the
number of elts in flight at any one time is actually quite small and can
usually be accommodated from an embedded pool.
Propagate the error status from deep within the bowels, in order to reduce
the number of duplicate _cairo_error() and generally clean up the return
values.
We now have the ability to distinguish an error case where the backend is
left in an inconsistent state from a transitory error. For the former we
need to report the error condition via the return value, which will be
propagated to the font-face. For the latter we just construct an in-error
scaled font nil-object which is passed back to the user.
We only want to set the error state on the backend when it implies that
the font-face is in an inconsistent state. For example, this may be due to
a locking error in the backend or that we have detected a corrupt font.
In contrast, if we merely fail to allocated the scaled font then we just
wish to return that error to the user, without making the font-face itself
inert.
Check the user input for validity before passing the values on to the
backend. Currently the error is detected by the backend and the error is
propagated onto the font-face.
Ensure that the temporary images are freed after we finish with the
pattern.
Note that we are using 3 members of the surface for temporary storage
whilst emitting patterns, this should be reviewed.
_cairo_memory_stream_destroy() finalizes the stream even if the stream was
in error and that error is reported back to the caller - so ensure we
don't try to free the stream again.
Paul Messmer provided a thorough analysis of a race between destroying the
final reference on a font and a concurrent recreation of the font -
demonstrating how it is possible for the create() to return the font that
was in the process of being freed.
To stop the race, we need to recheck the reference count upon taking the
mutex guarding the hash table.
We failed to cleanup the font face correctly after an allocation failure
during _cairo_toy_font_face_init() leading to memleaks and live entries
being left in the font-face hash tables.
As a fun itch to scratch, I've been fixing incorrect uses of the
contraction "it's" in comments within the mozilla source tree (tracked
in https://bugzilla.mozilla.org/show_bug.cgi?id=458167 ), and I ran
across 6 instances of this typo in mozilla's snapshot of cairo.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Adds an error code replacing CAIRO_STATUS_NO_MEMORY in one case where it
is not really appropriate. CAIRO_STATUS_INVALID_SIZE is used by several
backends that do not support image sizes beyond 2^15 pixels on each side.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
The agreement on the mailing list was that returning NULL is the right
thing to do, and indeed the callers of _cairo_glitz_surface_create_similar
are prepared to receive NULL and return CAIRO_STATUS_INT_UNSUPPORTED in
that case.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Currently glyphs are cached independently in each font i.e. each font
maintains a cache of up to 256 glyphs, and there can be as many scaled fonts
in use as the application needs and references (we maintain a holdover
cache of 512 scaled fonts as well).
Alternatively, as in this patch, we can maintain a global pool of glyphs
split between all open fonts. This allows a heavily used individual font
to cache more glyphs than we could allow if we used per-font glyph caches,
but at the same time maintains fairness across all fonts (by using random
replacement) and provides a cap on the maximum number of global glyphs.
The glyphs are allocated in pages, which are cached in the global pool.
Using pages means we can exploit spatial locality within the font
(nearby indices are typically used in clusters) to reduce frequency of small
allocations and allow the scaled font to reserve a single MRU page of
glyphs. This caching dramatically reduces the cairo overhead during the
cairo-perf benchmarks, and drastically reduces the number of allocations
made by the application (for example browsing multi-lingual site with
firefox).
The bounding polygon of the control points, defines the extents of the
spline. Therefore if the control points are entirely contained within the
current path extents, so is the spline and we do not need to evaluate its
tight bounds.
