I have changed the code to get the bounding box by using a
`cairo_recording_surface' instead of relying on CFF/TFF outline bounding
boxes. The code works great and Bixa Color is being rendered properly too.
I have also changed `ft_glyphslot_preset_bitmap' to work with OT-SVG
glyphs, so now, the slot will be preset at the loading stage.

However, there is one performance concern I have:

Since the bitmap presetting of an OT-SVG glyph can only be done by the
"rendering port", I had to create a hook function called `preset_slot'.
Then I create a wrapper function around it in my `ot-svg' module and this
wrapper function gets exposed via the interface of the `ot-svg' module.
Ultimately, this function gets used in `ft_glyphslot_preset_bitmap' for
presetting an OT-SVG glyph.

This hook function (for librsvg) would work in the following manner:
* create a cairo recording surface
* render the glyph on that surface (you'll have to check whether to render
the whole document or a particular element)
* get the bounds
* perform any transformations on the bounds if necessary and then preset
the slot

At the end of `FT_Load_Glyph' you'll see that it calls
`ft_glyphslot_preset_bitmap' only if `FT_LOAD_RENDER' has not been passed.
Which indicates that `FT_Render_Glyph' shouldn't really care whether
presetting was done or not. In fact, in `ft_smooth_render_generic',
`ft_glyphslot_preset_bitmap' is called again. I have to replicate the same
behavior with OT-SVG. Thus, in `ft_svg_render', I call the preset hook
again to be sure that presetting is done, this is so that I can use the
width/height to allocate memory before calling the render hook. Then in
render hook, once again the same recording surface calculations will need
to be done to get the bounding box (which is necessary for rendering).

So you see, the same thing is being done 3 times. I just need this
information to persist in an accurate manner so I can reuse it instead of
calculating it again and again. I have managed to reduce this to 2 by doing

The preset hook function takes an argument called `cache' (just a name, can
change), if this is set to TRUE, it'll store all of its calculations inside
the state of the rendering port. When `ft_svg_render' calls the preset hook
it'll set `cache' to TRUE, thus all calculations will be stored in the
rendering port's state and then the render hook can just use those. When
`FT_Load_Glyph' calls `ft_glyphslot_preset_bitmap', it'll call the wrapper
function with `cache' set to FALSE, thus, no state gets stored then.

Thus there is a possible repetition here (which is also present in the case
of traditional glyphs). if there's a better way to do this, let me know.
Should we worry about this performance concern?

Freetype-devel mailing list

Reply via email to