module Main (main) where
import Control.Monad
import Data.Char (chr, ord)
import Data.IORef
import Foreign hiding (void)
import Foreign.C (CInt, withCString)
import Prelude hiding (id)
import Control.Exception (ErrorCall(..), bracket, evaluate, throwIO, try)
import Data.ByteString (ByteString)
import Data.Either (isLeft)
import Data.ByteString qualified as ByteString
import Data.ByteString.Unsafe qualified as ByteString
import Data.List (sort)
import Data.Set (Set)
import Data.Set qualified as Set
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Text.Foreign qualified as Text
import System.Mem (performMajorGC)
import Test.Tasty
import Test.Tasty.HUnit
import KB.Text.Shape.FFI.API.Context qualified as ShapeContext
import KB.Text.Shape.FFI.API.Direct qualified as ShapeDirect
import KB.Text.Shape.FFI.API.Other qualified as Other
import KB.Text.Shape.FFI.API.Segmentation qualified as Segmentation
import KB.Text.Shape.FFI.Allocator qualified as Allocator
import KB.Text.Shape.FFI.Enums qualified as Enums
import KB.Text.Shape.FFI.Flags qualified as Flags
import KB.Text.Shape.FFI.Handles qualified as Handles
import KB.Text.Shape.FFI.Iterators qualified as Iterators
import KB.Text.Shape.FFI.Structs qualified as Structs
import KB.Text.Shape qualified as TextShape
import KB.Text.Shape.Font qualified as Font
import KB.Text.Shape.Segmentation qualified as TextSegmentation
testFontTtf :: FilePath
testFontTtf = "test/Ubuntu-R.ttf"
-- | Written on suite startup; also serves as the bench fixture.
testFontKbts :: FilePath
testFontKbts = "test/Ubuntu-R.kbts"
-- | Latin, Ethiopic, Hebrew and Devanagari runs. Ubuntu-R only has glyphs for the Latin parts.
testText :: Text
testText = "Hello, ሰላם።, שלמלך, नमस्ते world!"
longTestText :: Text
longTestText = Text.replicate 64 testText
main :: IO ()
main = do
ttfData <- ByteString.readFile testFontTtf
blobData <- Font.extractBlob ttfData 0
ByteString.writeFile testFontKbts blobData
defaultMain $ testGroup "kb-text-shape"
[ fontTests ttfData blobData
, contextTests ttfData blobData
, directTests ttfData
, segmentationTests
, scriptTests
, coverageTests ttfData
, allocatorTests ttfData
]
-- * Fonts
fontTests :: ByteString -> ByteString -> TestTree
fontTests ttfData blobData = testGroup "fonts"
[ testCase "kbts_FontCount sees one font in the TTF" $
ByteString.unsafeUseAsCStringLen ttfData \(ptr, len) -> do
count <- evaluate $ ShapeDirect.kbts_FontCount (castPtr ptr) (fromIntegral len)
count @?= 1
, testCase "createFont produces a valid font" $
withFont ttfData \font -> do
valid <- evaluate $ ShapeDirect.kbts_FontIsValid font
assertBool "kbts_FontIsValid" (valid /= 0)
, testCase "extractBlob output loads without another blob pass" $ do
assertBool "blob is not empty" . not $ ByteString.null blobData
Font.withLoader \font statePtr ->
Font.loadFont blobData 0 font statePtr >>= \case
Right Font.LoadFontReady -> pure ()
Right Font.LoadFontNeedsBlob{} -> assertFailure "blob wants another blob pass"
Left err -> assertFailure $ "blob failed to load: " <> show err
, testCase "garbage font data is not counted as a font" $
-- NB: this is as far as input validation goes, fonts are trusted input!
ByteString.unsafeUseAsCStringLen (ByteString.replicate 1024 0x2A) \(ptr, len) -> do
count <- evaluate $ ShapeDirect.kbts_FontCount (castPtr ptr) (fromIntegral len)
count @?= 0
, testCase "getFontInfo reports style and metrics" $
withFont ttfData \font -> do
info <- Font.getFontInfo font
lookup Enums.FONT_INFO_STRING_ID_FAMILY info.strings @?= Just "Ubuntu"
info.styleFlags @?= Flags.FONT_STYLE_FLAG_REGULAR
info.weight @?= Enums.FONT_WEIGHT_NORMAL
info.width @?= Enums.FONT_WIDTH_NORMAL
info.unitsPerEm @?= 1000
info.capitalHeight @?= 693
info.ascent @?= 932
info.descent @?= (-189)
info.lineGap @?= 0
(info.xMin, info.yMin, info.xMax, info.yMax) @?= (-211, -195, 1266, 958)
, testCase "getFontInfo agrees between TTF and blob" $
withFont ttfData \ttf ->
withFont blobData \blob -> do
ttfInfo <- Font.getFontInfo ttf
blobInfo <- Font.getFontInfo blob
blobInfo @?= ttfInfo
, testCase "lookupFontString reads Windows-language name records" $
withFont ttfData \font -> do
family <- Font.lookupFontString font Enums.FONT_INFO_STRING_ID_FAMILY Enums.WINDOWS_LANGUAGE_ID_ENGLISH_UNITED_STATES
family @?= Just "Ubuntu"
missing <- Font.lookupFontString font Enums.FONT_INFO_STRING_ID_FAMILY Enums.WINDOWS_LANGUAGE_ID_JAPANESE_JAPAN
missing @?= Nothing
, testCase "kbts_WindowsIdsForLanguage lists en-US for English" $ do
count <- ShapeDirect.kbts_WindowsIdsForLanguage Enums.LANGUAGE_ENGLISH nullPtr 0
assertBool "English has Windows IDs" (count > 0)
ids <- allocaArray (fromIntegral count) \idsPtr -> do
matching <- ShapeDirect.kbts_WindowsIdsForLanguage Enums.LANGUAGE_ENGLISH idsPtr count
matching @?= count
peekArray (fromIntegral count) idsPtr
assertBool "en-US is listed" (Enums.WINDOWS_LANGUAGE_ID_ENGLISH_UNITED_STATES `elem` ids)
, testCase "Ubuntu-R exposes its variation axes" $
withFont ttfData \font -> do
(axisCount, instanceCount) <- variationInfo font
(axisCount, instanceCount) @?= (2, 12)
axes <- forM [0 .. axisCount - 1] \axisIndex ->
alloca \infoPtr -> do
found <- ShapeDirect.kbts_GetVariationAxisInfo font axisIndex infoPtr
assertBool "axis index in bounds" (found /= 0)
peek infoPtr
[ (axis.tag, axis.minimumValue, axis.defaultValue, axis.maximumValue, axis.flags) | axis <- axes ]
@?= [ (tagWord "wdth", 75, 100, 100, Flags.VARIATION_AXIS_FLAG_NONE)
, (tagWord "wght", 100, 400, 800, Flags.VARIATION_AXIS_FLAG_NONE)
]
names <- forM axes \axis -> englishName font axis.nameStringId
names @?= [Just "Width", Just "Weight"]
outOfBounds <- alloca $ ShapeDirect.kbts_GetVariationAxisInfo font axisCount
outOfBounds @?= 0
, testCase "variationAxes lists the axes in font order" $
withFont ttfData \font -> do
axes <- Font.variationAxes font
[ (axis.tag, axis.minimumValue, axis.defaultValue, axis.maximumValue) | axis <- axes ]
@?= [ (tagWord "wdth", 75, 100, 100)
, (tagWord "wght", 100, 400, 800)
]
, testCase "named instances carry coordinates and subfamily names" $
withFont ttfData \font ->
alloca \infoPtr ->
allocaArray 2 \vectorPtr -> do
found <- ShapeDirect.kbts_GetVariationInstance font 4 infoPtr vectorPtr
assertBool "instance index in bounds" (found /= 0)
info <- peek infoPtr
info.flags @?= Flags.VARIATION_INSTANCE_FLAG_NONE
englishName font info.subfamilyNameStringId >>= (@?= Just "Bold")
peekArray 2 vectorPtr >>= (@?= [100, 700])
, testCase "NormalizeVariationVector maps axis extremes to F2Dot14" $
withFont ttfData \font -> do
normalizeVariations font [100, 400] >>= (@?= [0, 0])
normalizeVariations font [100, 800] >>= (@?= [0, 0x4000])
normalizeVariations font [75, 100] >>= (@?= [-0x4000, -0x4000])
, testCase "kbts_GetFontInfo (v1) agrees with the extended query" $
withFont ttfData \font ->
alloca \infoPtr -> do
ShapeDirect.kbts_GetFontInfo font infoPtr
Structs.FontInfo{styleFlags, weight, width} <- peek infoPtr
info2 <- Font.getFontInfo font
(styleFlags, weight, width) @?= (info2.styleFlags, info2.weight, info2.width)
]
-- * Context API
contextTests :: ByteString -> ByteString -> TestTree
contextTests ttfData blobData = testGroup "context API"
[ testCase "font stack refcounting" $
TextShape.withContext \ctx -> do
font <- TextShape.pushFontFromMemory ctx ttfData 0
uses <- TextShape.pushFont ctx font
uses @?= 2
pop1 <- TextShape.popFont ctx
pop1 @?= (1, font)
pop0 <- TextShape.popFont ctx
pop0 @?= (0, font)
, testCase "pushFontFromFile loads from disk" $
TextShape.withContext \ctx -> do
_font <- TextShape.pushFontFromFile ctx testFontTtf 0
glyphs <- shapeText ctx "Abc"
map (.codepoint) glyphs @?= "Abc"
, testCase "pushFontFromFile loads a pre-distilled blob" $ do
ttfGlyphs <- TextShape.withContext \ctx -> do
_font <- TextShape.pushFontFromFile ctx testFontTtf 0
shapeText ctx "Abc"
blobGlyphs <- TextShape.withContext \ctx -> do
_font <- TextShape.pushFontFromFile ctx testFontKbts 0
shapeText ctx "Abc"
blobGlyphs @?= ttfGlyphs
, testCase "simple latin text is one LTR run" $
withFontContext ttfData \ctx _font -> do
results <- TextShape.run ctx $ TextShape.text_ "Hello!"
(r, glyphs) <- expectOneRun results
r.script @?= Enums.SCRIPT_LATIN
r.direction @?= Enums.DIRECTION_LTR
r.paragraphDirection @?= Enums.DIRECTION_LTR
map (.codepoint) glyphs @?= "Hello!"
map (.codepointIndex) glyphs @?= [0 .. 5]
assertBool "all glyphs mapped" $ all (\g -> g.id /= 0) glyphs
assertBool "positive advances" $ all (\g -> g.gpos.advanceX > 0) glyphs
shapeError <- ShapeContext.kbts_ShapeError ctx.handle
shapeError @?= Enums.SHAPE_ERROR_NONE
, testCase "char_ feeds single codepoints" $
withFontContext ttfData \ctx _font -> do
results <- TextShape.run ctx do
TextShape.char_ 'A'
TextShape.char_ 'b'
concatMap (map (.codepoint) . snd) results @?= "Ab"
, testCase "multi-script text segments into runs" $
withFontContext ttfData \ctx _font -> do
results <- TextShape.run ctx $ TextShape.text_ testText
let runs = map fst results
assertBool "several runs" (length runs >= 4)
forM_ [Enums.SCRIPT_LATIN, Enums.SCRIPT_ETHIOPIC, Enums.SCRIPT_HEBREW, Enums.SCRIPT_DEVANAGARI] \script ->
assertBool ("has a run of " <> show script) $
script `elem` map (.script) runs
forM_ runs \r ->
r.paragraphDirection @?= Enums.DIRECTION_LTR
-- all input made it through, in logical order per run
let allIndices = concatMap (map (.codepointIndex) . snd) results
sort allIndices @?= [0 .. Text.length testText - 1]
, testCase "RTL runs are flipped to visual order" $
withFontContext ttfData \ctx _font -> do
results <- TextShape.run ctx $ TextShape.text_ testText
let rtl = [ x | x@(r, _) <- results, r.direction == Enums.DIRECTION_RTL ]
assertBool "has RTL runs" . not $ null rtl
forM_ rtl \(r, glyphs) -> do
r.script @?= Enums.SCRIPT_HEBREW
let indices = map (.codepointIndex) glyphs
indices @?= reverse (sort indices)
, testCase "TTF and blob shape identically" $ do
ttfResults <- withFontContext ttfData \ctx _font ->
TextShape.run ctx $ TextShape.text_ testText
blobResults <- withFontContext blobData \ctx _font ->
TextShape.run ctx $ TextShape.text_ testText
-- font handles differ between contexts, compare everything else
let strip (r, glyphs) = ((r.script, r.direction, r.paragraphDirection, r.flags), glyphs)
map strip blobResults @?= map strip ttfResults
, testCase "withFont_ splits the text into font runs" $
TextShape.withContext \ctx -> do
fontA <- TextShape.pushFontFromMemory ctx ttfData 0
fontB <- TextShape.pushFontFromMemory ctx ttfData 0
assertBool "two loads give distinct handles" (fontA /= fontB)
results <- TextShape.run ctx do
TextShape.text_ "abc"
TextShape.withFont_ fontA $ TextShape.text_ "def"
TextShape.text_ "ghi"
concatMap (map (.codepoint) . snd) results @?= "abcdefghi"
-- XXX: characterizes an upstream quirk: the font is sampled when
-- pending breaks flush, not when codepoints are fed, so mid-input
-- font switches land about one segment too early.
-- Expected [(B, "abc"), (A, "def"), (B, "ghi")], but 2.32 gives:
let named font
| font == fontA = 'A'
| font == fontB = 'B'
| otherwise = '?'
[ (named r.font, map (.codepoint) glyphs) | (r, glyphs) <- results ]
@?= [('A', "abc"), ('B', "defghi")]
, testCase "bottom-to-top font priority flag reverses the stack" $
bracket (TextShape.createContextWith Flags.SHAPE_CONTEXT_FLAG_FONT_PRIORITY_BOTTOM_TO_TOP) TextShape.destroyContext \ctx -> do
fontA <- TextShape.pushFontFromMemory ctx ttfData 0
fontB <- TextShape.pushFontFromMemory ctx ttfData 0
assertBool "two loads give distinct handles" (fontA /= fontB)
results <- TextShape.run ctx $ TextShape.text_ "abc"
map (\(r, _) -> r.font) results @?= [fontA]
, testCase "context works in caller-provided fixed memory" $
withFont ttfData \font ->
withFixedMemoryContext (4 * 1024 * 1024) \ctx -> do
_uses <- TextShape.pushFont ctx font
glyphs <- shapeText ctx "Fixed"
map (.codepoint) glyphs @?= "Fixed"
-- fixed-memory contexts own no external allocations, nothing to destroy
, testCase "a context out of memory fails the push and the run" $
withFont ttfData \font ->
withFixedMemoryContext 1024 \ctx -> do
expectContextError Enums.SHAPE_ERROR_OUT_OF_MEMORY $ TextShape.pushFont ctx font
expectContextError Enums.SHAPE_ERROR_OUT_OF_MEMORY $ TextShape.run ctx (TextShape.text_ "Abc")
, testCase "pushFont rejects a font without a blob" $
withFontContext ttfData \ctx font -> do
expectFontError $ TextShape.pushFont ctx (Handles.Font nullPtr)
popped <- TextShape.popFont ctx
popped @?= (0, font)
, testCase "withFont_ with a rejected font leaves the stack intact" $
withFontContext ttfData \ctx font -> do
expectFontError $ TextShape.run ctx do
TextShape.text_ "abc"
TextShape.withFont_ (Handles.Font nullPtr) $ TextShape.text_ "def"
results <- TextShape.run ctx $ TextShape.text_ "Abc"
map (\(r, _) -> r.font) results @?= [font]
, testCase "pushFontFromMemory pops a font that fails validation" $
withFontContext ttfData \ctx font -> do
try @TextShape.ShapeException (TextShape.pushFontFromMemory ctx (withoutCapitalHeight ttfData) 0) >>= \case
Left (TextShape.FontError _origin reason) -> reason @?= "font has no capital height (OS/2 sCapHeight)"
other -> assertFailure $ "expected the capital height rejection, got " <> show other
results <- TextShape.run ctx $ TextShape.text_ "Abc"
map (\(r, _) -> r.font) results @?= [font]
, testCase "pushFontFromFile reports a missing file" $
TextShape.withContext \ctx ->
expectFontError $ TextShape.pushFontFromFile ctx "test/does-not-exist.ttf" 0
, testCase "feature overrides toggle ligatures" $
withFontContext ttfData \ctx _font -> do
ligated <- shapeText ctx "fi"
length ligated @?= 1
assertBool "ligature flag set" $
all (\g -> g.flags .&. Flags.GLYPH_FLAG_LIGATURE /= mempty) ligated
plain <- concatMap snd <$> TextShape.run ctx do
TextShape.withFeature_ Enums.FEATURE_TAG_liga 0 $
TextShape.text_ "fi"
map (.codepoint) plain @?= "fi"
, testCase "feature stack pop reports the removal" $
withFontContext ttfData \ctx _font -> do
popped <- newIORef (-1)
_results <- TextShape.run ctx do
TextShape.pushFeature_ Enums.FEATURE_TAG_liga 1
TextShape.text_ "fi"
TextShape.popFeature_ Enums.FEATURE_TAG_liga >>= writeIORef popped
readIORef popped >>= (@?= 1)
, testCase "withFeature_ drops its override when the section throws" $
withFontContext ttfData \ctx _font -> do
thrown <- try @ErrorCall $ TextShape.run ctx do
TextShape.withFeature_ Enums.FEATURE_TAG_liga 0 do
TextShape.text_ "fi"
throwIO $ ErrorCall "section failed"
assertBool "the section threw" (isLeft thrown)
ligated <- shapeText ctx "fi"
length ligated @?= 1
, testCase "repeated feature tags keep the latest override" $
withFontContext ttfData \ctx _font -> do
onThenOff <- concatMap snd <$> TextShape.run ctx do
TextShape.withFeature_ Enums.FEATURE_TAG_liga 1 $
TextShape.withFeature_ Enums.FEATURE_TAG_liga 0 $
TextShape.text_ "fi"
map (.codepoint) onThenOff @?= "fi"
afterRepeats <- concatMap snd <$> TextShape.run ctx do
TextShape.withFeature_ Enums.FEATURE_TAG_kern 1 $
TextShape.withFeature_ Enums.FEATURE_TAG_kern 1 $
TextShape.withFeature_ Enums.FEATURE_TAG_liga 0 $
TextShape.text_ "fi"
map (.codepoint) afterRepeats @?= "fi"
, testCase "shaped codepoints can be retrieved by index" $
withFontContext ttfData \ctx _font -> do
_results <- TextShape.run ctx $ TextShape.text_ "Hi"
alloca \cpPtr -> do
found <- ShapeContext.kbts_ShapeGetShapeCodepoint ctx.handle 1 cpPtr
assertBool "codepoint 1 found" (found /= 0)
cp <- peek cpPtr
cp.codepoint @?= ord 'i'
cp.userId @?= 1
cp.featureOverrideCount @?= 0
, testCase "codepoint iterator walks the input" $
withFontContext ttfData \ctx _font -> do
collected <- newIORef []
_results <- TextShape.run ctx do
TextShape.text_ "abc"
alloca \itPtr -> alloca \cpPtr -> alloca \ixPtr -> do
ShapeContext.hs_ShapeCurrentCodepointsIterator ctx.handle itPtr
valid <- ShapeContext.kbts_ShapeCodepointIteratorIsValid itPtr
assertBool "iterator is valid" (valid /= 0)
let go acc = do
more <- ShapeContext.kbts_ShapeCodepointIteratorNext itPtr cpPtr ixPtr
if more /= 0
then do
cp <- peek cpPtr
ix <- peek ixPtr
go $ (fromIntegral ix, chr cp.codepoint) : acc
else pure $ reverse acc
go [] >>= writeIORef collected
readIORef collected >>= (@?= [(0 :: Int, 'a'), (1, 'b'), (2, 'c')])
, testCase "codepoint iterator walks the input (v2)" $
withFontContext ttfData \ctx _font -> do
collected <- newIORef []
_results <- TextShape.run ctx do
TextShape.text_ "abc"
alloca \itPtr -> alloca \cpPtr -> alloca \ixPtr -> do
ShapeContext.hs_ShapeCurrentCodepointsIterator ctx.handle itPtr
Structs.prepareCodepoint2 cpPtr
let go acc = do
more <- ShapeContext.kbts_ShapeCodepointIteratorNext2 itPtr cpPtr ixPtr
if more /= 0
then do
cp <- peek cpPtr
ix <- peek ixPtr
go $ (fromIntegral ix, chr cp.codepoint) : acc
else pure $ reverse acc
go [] >>= writeIORef collected
readIORef collected >>= (@?= [(0 :: Int, 'a'), (1, 'b'), (2, 'c')])
, testCase "Codepoint reports the paragraph direction" $
withFontContext ttfData \ctx _font -> do
feedText ctx Enums.DIRECTION_RTL "abc"
_runs <- shapeRuns2 ctx
alloca \cpPtr -> do
found <- ShapeContext.kbts_ShapeGetShapeCodepoint ctx.handle 0 cpPtr
assertBool "codepoint 0 found" (found /= 0)
cp <- peek cpPtr
cp.codepoint @?= ord 'a'
cp.direction @?= Enums.DIRECTION_LTR
cp.paragraphDirection @?= Enums.DIRECTION_RTL
, testCase "Codepoint2 reports the paragraph direction" $
withFontContext ttfData \ctx _font -> do
feedText ctx Enums.DIRECTION_RTL "abc"
_runs <- shapeRuns2 ctx
alloca \cpPtr -> do
Structs.prepareCodepoint2 cpPtr
found <- ShapeContext.kbts_ShapeGetShapeCodepoint2 ctx.handle 0 cpPtr
assertBool "codepoint 0 found" (found /= 0)
cp <- peek cpPtr
cp.codepoint @?= ord 'a'
cp.direction @?= Enums.DIRECTION_LTR
cp.paragraphDirection @?= Enums.DIRECTION_RTL
, testCase "ShapeRun2 yields the same runs as ShapeRun" $ do
viaRun <- withFontContext ttfData \ctx _font ->
TextShape.run ctx $ TextShape.text_ testText
viaRun2 <- withFontContext ttfData \ctx _font -> do
feedText ctx Enums.DIRECTION_DONT_KNOW testText
shapeRuns2 ctx
let strip (r, glyphs) = ((r.script, r.direction, r.paragraphDirection, r.flags), glyphs)
map strip viaRun2 @?= map strip viaRun
, testCase "font variations change the shaped advances" $
withFont ttfData \font ->
TextShape.withContext \ctx -> do
(_, regular) <- pushFontWith ctx font []
regularAdvances <- advancesOf ctx "Abc"
_ <- ShapeContext.kbts_ShapePopFont ctx.handle
(handle, pushed) <- pushFontWith ctx font [Structs.Variation (tagWord "wght") 800]
pushed @?= regular
assertBool "font got a stack slot" (handle /= Handles.CONTEXT_FONT_HANDLE_INVALID)
boldAdvances <- advancesOf ctx "Abc"
assertBool "Extra Bold is wider" (sum boldAdvances > sum regularAdvances)
applied <- ShapeContext.kbts_ShapeSetFontVariation ctx.handle handle (tagWord "wght") 400
applied @?= 1
advancesOf ctx "Abc" >>= (@?= regularAdvances)
vectorSet <- withArray [100, 800] $ ShapeContext.kbts_ShapeSetFontVariationVector ctx.handle handle
vectorSet @?= 1
advancesOf ctx "Abc" >>= (@?= boldAdvances)
setMany <- withArrayLen [Structs.Variation (tagWord "wght") 400, Structs.Variation (tagWord "slnt") 10] \count variationsPtr ->
ShapeContext.kbts_ShapeSetFontVariations ctx.handle handle variationsPtr (fromIntegral count)
setMany @?= 1
advancesOf ctx "Abc" >>= (@?= regularAdvances)
unsupported <- ShapeContext.kbts_ShapeSetFontVariation ctx.handle handle (tagWord "slnt") 10
unsupported @?= 0
, testCase "withFontVariations shapes the whole run with the axis values" $
withFontContext ttfData \ctx font -> do
extraBold <- TextShape.withContext \boldCtx -> do
_ <- pushFontWith boldCtx font [wght 800]
advancesOf boldCtx "Abc"
regular <- advancesOf ctx "Abc"
assertBool "Extra Bold is wider" (sum extraBold > sum regular)
TextShape.withFontVariations ctx font [wght 800] (advancesOf ctx "Abc") >>= (@?= extraBold)
advancesOf ctx "Abc" >>= (@?= regular)
TextShape.popFont ctx >>= (@?= (0, font))
, testCase "withFontVariations takes the last value of a repeated axis" $
withFontContext ttfData \ctx font -> do
extraBold <- TextShape.withFontVariations ctx font [wght 800] (advancesOf ctx "Abc")
TextShape.withFontVariations ctx font [wght 300, wght 800] (advancesOf ctx "Abc") >>= (@?= extraBold)
, testCase "withFontVariations keeps the body's context error" $
withFont ttfData \font ->
withFixedMemoryContext (16 * 1024) \ctx -> do
thrown <- try $ TextShape.withFontVariations ctx font [] $
TextShape.run ctx (TextShape.text_ longTestText)
case thrown of
Left (TextShape.ContextError origin err) -> do
origin @?= "kbts_ShapeRun"
err @?= Enums.SHAPE_ERROR_OUT_OF_MEMORY
other -> assertFailure $ "expected the run's ContextError, got " <> show (void other)
kept <- readIORef ctx.fonts
assertBool "the pushed font was released" (null kept)
, testCase "a font section at the end of the input shapes in the font below (upstream font_push_lags_input)" $
withFontContext ttfData \ctx font -> do
regular <- advancesOf ctx "Abc"
section <- TextShape.run ctx $
TextShape.withFontVariations_ font [wght 800] $
TextShape.text_ "Abc"
map (.advanceX) (concatMap snd section) @?= regular
, testCase "withFontVariations_ without variations matches withFont_" $
withFontContext ttfData \ctx font -> do
plain <- TextShape.run ctx $ TextShape.withFont_ font $ TextShape.text_ "Abc"
varied <- TextShape.run ctx $ TextShape.withFontVariations_ font [] $ TextShape.text_ "Abc"
varied @?= plain
, testCase "withFontVariations_ with a rejected font leaves the stack intact" $
withFontContext ttfData \ctx font -> do
expectFontError $ TextShape.run ctx do
TextShape.withFontVariations_ (Handles.Font nullPtr) [wght 800] $ TextShape.text_ "Abc"
results <- TextShape.run ctx $ TextShape.text_ "Abc"
map (\(r, _) -> r.font) results @?= [font]
, testCase "blob-loaded fonts keep their variations" $
withFont blobData \blobFont ->
withFont ttfData \ttfFont -> do
fromBlob <- TextShape.withContext \ctx -> do
_ <- pushFontWith ctx blobFont [wght 800]
advancesOf ctx "Abc"
fromTtf <- TextShape.withContext \ctx -> do
_ <- pushFontWith ctx ttfFont [wght 800]
advancesOf ctx "Abc"
fromBlob @?= fromTtf
axes <- Font.variationAxes blobFont
map (.tag) axes @?= [tagWord "wdth", tagWord "wght"]
, testCase "fonts pushed from file and memory take variations" $ do
regular <- withFontContext ttfData \ctx _font -> advancesOf ctx "Abc"
let bold = [Structs.Variation (tagWord "wght") 800]
fromFile <- TextShape.withContext \ctx -> do
withCString testFontTtf \pathPtr ->
withArrayLen bold \count variationsPtr ->
expectWrittenHandle ctx $
ShapeContext.kbts_ShapePushFontFromFile2 ctx.handle pathPtr 0 variationsPtr (fromIntegral count)
advancesOf ctx "Abc"
fromMemory <- TextShape.withContext \ctx ->
ByteString.unsafeUseAsCStringLen ttfData \(memoryPtr, memorySize) -> do
withArrayLen bold \count variationsPtr ->
expectWrittenHandle ctx $
ShapeContext.kbts_ShapePushFontFromMemory2 ctx.handle (castPtr memoryPtr) (fromIntegral memorySize) 0 variationsPtr (fromIntegral count)
advancesOf ctx "Abc"
fromMemory @?= fromFile
assertBool "Extra Bold is wider" (sum fromFile > sum regular)
, testCase "failed pushes report the invalid context font handle" $
TextShape.withContext \ctx -> do
fromFile <- withCString "test/does-not-exist.ttf" \pathPtr ->
failedPushHandle $ ShapeContext.kbts_ShapePushFontFromFile2 ctx.handle pathPtr 0 nullPtr 0
fromMemory <- withArrayLen [1 .. 8 :: Word8] \size garbagePtr ->
failedPushHandle $ ShapeContext.kbts_ShapePushFontFromMemory2 ctx.handle (castPtr garbagePtr) (fromIntegral size) 0 nullPtr 0
fromFile @?= Handles.CONTEXT_FONT_HANDLE_INVALID
fromMemory @?= Handles.CONTEXT_FONT_HANDLE_INVALID
, testCase "ShapeRun2 reports the run's variation vector" $
withFont ttfData \font ->
TextShape.withContext \ctx -> do
_ <- pushFontWith ctx font [Structs.Variation (tagWord "wght") 700]
feedText ctx Enums.DIRECTION_DONT_KNOW "Abc"
runs <- shapeRuns2 ctx
assertBool "has runs" . not $ null runs
forM_ runs \(run, _glyphs) -> do
assertBool "vector is set" (run.variationVector /= nullPtr)
peekArray 2 run.variationVector >>= (@?= [100, 700])
, testCase "global variation pops keep the rest of the stack" $
withFontContext ttfData \ctx _font -> do
let weight = tagWord "wght"
width = tagWord "wdth"
pushes <- sequence
[ ShapeContext.kbts_ShapePushGlobalVariation ctx.handle weight 300
, ShapeContext.kbts_ShapePushGlobalVariation ctx.handle width 80
]
pushes @?= [1, 1]
pops <- mapM (ShapeContext.kbts_ShapePopGlobalVariation ctx.handle) [width, weight, weight]
pops @?= [1, 1, 0]
glyphs <- shapeText ctx "Abc"
map (.codepoint) glyphs @?= "Abc"
]
-- * Direct API
directTests :: ByteString -> TestTree
directTests ttfData = testGroup "direct API"
[ testCase "direct shaping matches the context pipeline" $
withShapeSetup ttfData \font _config scratchpad -> do
direct <- directShape font scratchpad nullGlyphConfig "Hello!"
viaContext <- withFontContext ttfData \ctx _font -> shapeText ctx "Hello!"
map (.id) direct @?= map (.id) viaContext
map (.gpos) direct @?= map (.gpos) viaContext
, testCase "a scratchpad can be reused across shaping calls" $
withShapeSetup ttfData \font _config scratchpad -> do
one <- directShape font scratchpad nullGlyphConfig "abc"
two <- directShape font scratchpad nullGlyphConfig "abc"
two @?= one
, testCase "scratchpad in caller-provided fixed memory" $
withFont ttfData \font ->
withShapeConfig font \config -> do
need <- evaluate $ ShapeDirect.kbts_SizeOfShapeScratchpad config
assertBool "scratchpad size is known" (need > 0)
let size = fromIntegral need + 4 * 1024 * 1024
allocaBytes size \mem -> do
scratchpad <- ShapeDirect.kbts_PlaceShapeScratchpadFixedMemory config (castPtr mem) (fromIntegral size)
assertBool "scratchpad placed" (scratchpad /= Handles.ShapeScratchpad nullPtr)
glyphs <- directShape font scratchpad nullGlyphConfig "Fixed"
map (.codepoint) glyphs @?= "Fixed"
, testCase "scratchpad placed at caller memory, allocating dynamically" $
withFont ttfData \font ->
withShapeConfig font \config -> do
need <- evaluate $ ShapeDirect.kbts_SizeOfShapeScratchpad config
allocaBytes (fromIntegral need) \mem -> do
scratchpad <- ShapeDirect.kbts_PlaceShapeScratchpad config (castPtr mem) nullFunPtr nullPtr
assertBool "scratchpad placed" (scratchpad /= Handles.ShapeScratchpad nullPtr)
glyphs <- directShape font scratchpad nullGlyphConfig "Placed"
map (.codepoint) glyphs @?= "Placed"
ShapeDirect.kbts_DestroyShapeScratchpad scratchpad
, testCase "shape config placed in caller memory" $
withFont ttfData \font -> do
size <- evaluate $ ShapeDirect.kbts_SizeOfShapeConfig font Enums.SCRIPT_LATIN Enums.LANGUAGE_DONT_KNOW
assertBool "config size is known" (size > 0)
allocaBytes (fromIntegral size) \mem -> do
config <- ShapeDirect.kbts_PlaceShapeConfig font Enums.SCRIPT_LATIN Enums.LANGUAGE_DONT_KNOW (castPtr mem)
assertBool "config placed" (config /= Handles.ShapeConfig nullPtr)
withScratchpad config \scratchpad -> do
glyphs <- directShape font scratchpad nullGlyphConfig "Placed"
map (.codepoint) glyphs @?= "Placed"
, testCase "ShapeDirect2 without variations matches ShapeDirect" $
withShapeSetup ttfData \font _config scratchpad -> do
viaShapeDirect <- directShape font scratchpad nullGlyphConfig "Hello!"
viaShapeDirect2 <- directShape2 font scratchpad nullPtr "Hello!"
viaShapeDirect2 @?= viaShapeDirect
, testCase "ShapeDirect2 applies a normalized variation vector" $
withShapeSetup ttfData \font _config scratchpad -> do
regular <- directShape font scratchpad nullGlyphConfig "Abc"
bold <- withArray [100, 800] \vectorPtr ->
allocaArray 2 \normalizedPtr -> do
ShapeDirect.kbts_NormalizeVariationVector font vectorPtr normalizedPtr
directShape2 font scratchpad normalizedPtr "Abc"
assertBool "Extra Bold is wider" (sum (map (.advanceX) bold) > sum (map (.advanceX) regular))
, testCase "shape configs without variations share a UID across v1 and v2" $
withFont ttfData \font -> do
size <- ShapeDirect.kbts_SizeOfShapeConfig2 font Enums.SCRIPT_LATIN Enums.LANGUAGE_DONT_KNOW nullPtr
sizeV1 <- evaluate $ ShapeDirect.kbts_SizeOfShapeConfig font Enums.SCRIPT_LATIN Enums.LANGUAGE_DONT_KNOW
size @?= sizeV1
allocaBytes (fromIntegral size) \mem -> alloca \placedUidPtr -> alloca \queriedUidPtr -> do
config <- ShapeDirect.kbts_PlaceShapeConfig2 font Enums.SCRIPT_LATIN Enums.LANGUAGE_DONT_KNOW nullPtr (castPtr mem) placedUidPtr
assertBool "config placed" (config /= Handles.ShapeConfig nullPtr)
placedUid <- peek placedUidPtr
assertBool "UID is set" (placedUid /= Structs.Uid 0 0 0 0)
ShapeDirect.kbts_ShapeConfigUid config queriedUidPtr
peek queriedUidPtr >>= (@?= placedUid)
bracket
(ShapeDirect.kbts_CreateShapeConfig font Enums.SCRIPT_LATIN Enums.LANGUAGE_DONT_KNOW nullFunPtr nullPtr)
ShapeDirect.kbts_DestroyShapeConfig
\configV1 -> do
ShapeDirect.kbts_ShapeConfigUid configV1 queriedUidPtr
peek queriedUidPtr >>= (@?= placedUid)
, testCase "shape configs can be created for a variation" $
withFont ttfData \font ->
withArray [100, 800] \vectorPtr ->
alloca \uidPtr ->
bracket
(ShapeDirect.kbts_CreateShapeConfig2 font Enums.SCRIPT_LATIN Enums.LANGUAGE_DONT_KNOW vectorPtr nullFunPtr nullPtr uidPtr)
ShapeDirect.kbts_DestroyShapeConfig
\config -> do
assertBool "config created" (config /= Handles.ShapeConfig nullPtr)
uid <- peek uidPtr
assertBool "UID is set" (uid /= Structs.Uid 0 0 0 0)
withScratchpad config \scratchpad -> do
glyphs <- allocaArray 2 \normalizedPtr -> do
ShapeDirect.kbts_NormalizeVariationVector font vectorPtr normalizedPtr
directShape2 font scratchpad normalizedPtr "Abc"
map (.codepoint) glyphs @?= "Abc"
, testCase "glyph storage in caller-provided fixed memory" $
withShapeSetup ttfData \font _config scratchpad -> do
let size = 1024 * 1024
allocaBytes size \mem ->
alloca @Structs.GlyphStorage \storagePtr -> do
ok <- ShapeDirect.kbts_InitializeGlyphStorageFixedMemory storagePtr (castPtr mem) (fromIntegral size)
assertBool "storage initialized" (ok /= 0)
forM_ (Text.unpack "abc") \c -> do
glyphPtr <- ShapeDirect.kbts_PushGlyph storagePtr font (fromIntegral (ord c)) nullGlyphConfig 0
assertBool "glyph pushed" (glyphPtr /= nullPtr)
glyphs <- shapeStorage scratchpad storagePtr
map (.codepoint) glyphs @?= "abc"
, testCase "glyph configs accept feature overrides" $
withShapeSetup ttfData \font config scratchpad -> do
let overrides =
[ Structs.FeatureOverride Enums.FEATURE_TAG_liga 0
, Structs.FeatureOverride Enums.FEATURE_TAG_smcp 1
, Structs.FeatureOverride Enums.FEATURE_TAG_salt 3 -- non-binary values are stored explicitly
]
withArrayLen overrides \count overridesPtr -> do
size <- evaluate $ ShapeDirect.kbts_SizeOfGlyphConfig config overridesPtr (fromIntegral count)
assertBool "glyph config size is known" (size > 0)
allocaBytes (fromIntegral size) \mem -> do
placed <- ShapeDirect.kbts_PlaceGlyphConfig config overridesPtr (fromIntegral count) (castPtr mem)
assertBool "glyph config placed" (placed /= nullGlyphConfig)
glyphs <- directShape font scratchpad placed "fine"
map (.codepoint) glyphs @?= "fine"
bracket
(ShapeDirect.kbts_CreateGlyphConfig config overridesPtr (fromIntegral count) nullFunPtr nullPtr)
ShapeDirect.kbts_DestroyGlyphConfig
\created -> do
assertBool "glyph config created" (created /= nullGlyphConfig)
glyphs <- directShape font scratchpad created "fine"
map (.codepoint) glyphs @?= "fine"
, testCase "codepoint to glyph mapping" $
withFont ttfData \font -> do
glyphIdA <- ShapeDirect.kbts_CodepointToGlyphId font (fromIntegral (ord 'A'))
assertBool "'A' is mapped" (glyphIdA > 0)
glyphIdHan <- ShapeDirect.kbts_CodepointToGlyphId font 0x6C49
glyphIdHan @?= 0
alloca @Structs.Glyph \glyphPtr -> do
ShapeDirect.hs_CodepointToGlyph font (fromIntegral (ord 'A')) nullGlyphConfig 7 glyphPtr
glyph <- peek glyphPtr
glyph.codepoint @?= fromIntegral (ord 'A')
fromIntegral glyph.id @?= glyphIdA
glyph.userIdOrCodepointIndex @?= 7
, testCase "clearing active glyphs empties the iterator" $
withShapeSetup ttfData \font _config _scratchpad ->
withGlyphStorage \storagePtr -> do
forM_ (Text.unpack "abc") \c ->
void $ ShapeDirect.kbts_PushGlyph storagePtr font (fromIntegral (ord c)) nullGlyphConfig 0
alloca \itPtr -> do
ShapeDirect.hs_ActiveGlyphIterator storagePtr itPtr
valid <- evaluate $ Iterators.kbts_GlyphIteratorIsValid itPtr
assertBool "iterator over pushed glyphs is valid" (valid /= 0)
ShapeDirect.kbts_ClearActiveGlyphs storagePtr
alloca \itPtr -> do
ShapeDirect.hs_ActiveGlyphIterator storagePtr itPtr
alloca \outPtr -> do
more <- Iterators.kbts_GlyphIteratorNext itPtr outPtr
more @?= 0
]
-- * Segmentation
segmentationTests :: TestTree
segmentationTests = testGroup "segmentation"
[ testCase "guess text properties (UTF-8)" $ do
guessUtf8 "hello there" >>= (@?= (Enums.DIRECTION_LTR, Enums.SCRIPT_LATIN))
guessUtf8 "שלום" >>= (@?= (Enums.DIRECTION_RTL, Enums.SCRIPT_HEBREW))
, testCase "guess text properties (UTF-32)" $ do
guessUtf32 "hello" >>= (@?= (Enums.DIRECTION_LTR, Enums.SCRIPT_LATIN))
guessUtf32 "مرحبا" >>= (@?= (Enums.DIRECTION_RTL, Enums.SCRIPT_ARABIC))
, testCase "guess text properties (generic entry point)" $ do
let text = "hello" :: Text
Text.withCStringLen text \(ptr, len) ->
alloca \directionPtr -> alloca \scriptPtr -> do
poke directionPtr Enums.DIRECTION_DONT_KNOW
poke scriptPtr Enums.SCRIPT_DONT_KNOW
Segmentation.kbts_GuessTextProperties (castPtr ptr) (fromIntegral len) Enums.TEXT_FORMAT_UTF8 directionPtr scriptPtr
direction <- peek directionPtr
script <- peek scriptPtr
(direction, script) @?= (Enums.DIRECTION_LTR, Enums.SCRIPT_LATIN)
, testCase "BreakEntireStringUtf32 finds words and hard line breaks" $ do
breaks <- breakEntireUtf32 "one two\nthree"
assertBool "found breaks" . not $ null breaks
assertBool "found a word break" $
any (\b -> hasBreakFlag b.flags Flags.BREAK_FLAG_WORD) breaks
let hard = [ b.position | b <- breaks, hasBreakFlag b.flags Flags.BREAK_FLAG_LINE_HARD ]
hard @?= [8]
, testCase "incremental break state agrees with the entire-string API" $ do
let text = "one two\nthree four"
whole <- breakEntireUtf32 text
incremental <- breakIncremental text
-- The entire-string API merges the flags of same-position breaks, but
-- its output needs another merge pass: a late-arriving break can get
-- merged into a zeroed hole (see 'withBreakBuffers') instead of the
-- real record, splitting the position across two records.
mergeBreaks incremental @?= mergeBreaks whole
, testCase "Segmentation.breaks reports UTF-8 byte positions" $ do
let text = "øne two\nthree fõur"
whole <- breakEntireUtf8 text
mergeBreaks (TextSegmentation.breaks text) @?= mergeBreaks whole
, testCase "BreakEntireStringUtf8 agrees with UTF-32 on ASCII" $ do
let text = "one two\nthree four"
utf32 <- breakEntireUtf32 text
utf8 <- breakEntireUtf8 text
let key b = (b.position, b.flags)
map key utf8 @?= map key utf32
]
-- * Scripts
scriptTests :: TestTree
scriptTests = testGroup "scripts"
[ testCase "kbts_ScriptDirection" $ do
Other.kbts_ScriptDirection Enums.SCRIPT_LATIN @?= Enums.DIRECTION_LTR
Other.kbts_ScriptDirection Enums.SCRIPT_HEBREW @?= Enums.DIRECTION_RTL
Other.kbts_ScriptDirection Enums.SCRIPT_ARABIC @?= Enums.DIRECTION_RTL
, testCase "kbts_ScriptIsComplex" $ do
Other.kbts_ScriptIsComplex Enums.SCRIPT_LATIN @?= 0
assertBool "arabic is complex" $ Other.kbts_ScriptIsComplex Enums.SCRIPT_ARABIC /= 0
assertBool "devanagari is complex" $ Other.kbts_ScriptIsComplex Enums.SCRIPT_DEVANAGARI /= 0
, testCase "kbts_ScriptTagToScript decodes FOURCC tags" $ do
Other.kbts_ScriptTagToScript (scriptTag "latn") @?= Enums.SCRIPT_LATIN
Other.kbts_ScriptTagToScript (scriptTag "hebr") @?= Enums.SCRIPT_HEBREW
Other.kbts_ScriptTagToScript (scriptTag "dev2") @?= Enums.SCRIPT_DEVANAGARI -- kbts uses the v2 Indic tags
]
-- * Font coverage
coverageTests :: ByteString -> TestTree
coverageTests ttfData = testGroup "font coverage"
[ testCase "latin text is covered" $
coverage "Hello" >>= (@?= True)
, testCase "CJK text is not covered" $
coverage "汉字" >>= (@?= False)
]
where
coverage :: Text -> IO Bool
coverage text =
withFont ttfData \font ->
alloca @Structs.FontCoverageTest \testPtr -> do
fillBytes testPtr 0 $ sizeOf (undefined :: Structs.FontCoverageTest)
Other.kbts_FontCoverageTestBegin testPtr font
forM_ (Text.unpack text) \c ->
Other.kbts_FontCoverageTestCodepoint testPtr (fromIntegral (ord c))
covered <- Other.kbts_FontCoverageTestEnd testPtr
pure $ covered /= 0
-- * Allocator callback
allocatorTests :: ByteString -> TestTree
allocatorTests ttfData = testGroup "allocator"
[ testCase "haskell allocator drives a scratchpad lifecycle" $
withFont ttfData \font ->
withShapeConfig font \config -> do
allocCount <- newIORef (0 :: Int)
liveSet <- newIORef (Set.empty :: Set (Ptr ()))
Allocator.withAllocator (countingAllocator allocCount liveSet) \allocFn -> do
scratchpad <- ShapeDirect.kbts_CreateShapeScratchpad config allocFn nullPtr
assertBool "scratchpad created" (scratchpad /= Handles.ShapeScratchpad nullPtr)
glyphs <- directShape font scratchpad nullGlyphConfig "Hello, world"
map (.codepoint) glyphs @?= "Hello, world"
ShapeDirect.kbts_DestroyShapeScratchpad scratchpad
allocs <- readIORef allocCount
assertBool "allocator was exercised" (allocs > 0)
live <- readIORef liveSet
live @?= Set.empty
, testCase "haskell allocator drives a context lifecycle" $
withFont ttfData \font -> do
allocCount <- newIORef (0 :: Int)
liveSet <- newIORef (Set.empty :: Set (Ptr ()))
Allocator.withAllocator (collectingAllocator allocCount liveSet) \allocFn -> do
handle <- ShapeContext.kbts_CreateShapeContext2 allocFn nullPtr Flags.SHAPE_CONTEXT_FLAG_NONE
assertBool "context created" (handle /= Handles.ShapeContext nullPtr)
fonts <- newIORef mempty
let ctx = TextShape.Context{handle, fonts}
_uses <- TextShape.pushFont ctx font
let styled section = TextShape.withFeature_ Enums.FEATURE_TAG_liga 0 $ TextShape.withFont_ font section
viaText <- TextShape.run ctx $ styled $ TextShape.text_ longTestText
viaChars <- TextShape.run ctx $ styled $ mapM_ TextShape.char_ (Text.unpack longTestText)
concatMap (map (.codepoint) . snd) viaChars @?= concatMap (map (.codepoint) . snd) viaText
_popped <- TextShape.popFont ctx
TextShape.destroyContext ctx
allocs <- readIORef allocCount
assertBool "allocator was exercised" (allocs > 0)
live <- readIORef liveSet
live @?= Set.empty
]
countingAllocator :: IORef Int -> IORef (Set (Ptr ())) -> Allocator.Allocator
countingAllocator allocCount liveSet _data opPtr = do
op <- peek opPtr
case op.kind of
Allocator.OP_KIND_ALLOCATE -> do
ptr <- mallocBytes $ fromIntegral op.size
modifyIORef' allocCount (+ 1)
modifyIORef' liveSet $ Set.insert ptr
poke opPtr op{Allocator.pointer = ptr}
Allocator.OP_KIND_FREE -> do
modifyIORef' liveSet $ Set.delete op.pointer
free op.pointer
other ->
error $ "unexpected allocator op: " <> show other
{- | A 'countingAllocator' that runs a major GC on every call.
The GC has to stop every capability.
A capability stuck in an @unsafe@ call never stops.
A callback from such a call deadlocks the suite.
-}
collectingAllocator :: IORef Int -> IORef (Set (Ptr ())) -> Allocator.Allocator
collectingAllocator allocCount liveSet allocatorData opPtr = do
performMajorGC
countingAllocator allocCount liveSet allocatorData opPtr
-- * Fixtures
-- | A loaded standalone font.
withFont :: ByteString -> (Handles.Font -> IO r) -> IO r
withFont bytes action =
bracket (Font.createFont bytes 0) Font.destroyFont \fontData ->
Font.withFontData fontData action
-- | A shaping context with one font pushed.
withFontContext :: ByteString -> (TextShape.Context -> Handles.Font -> IO r) -> IO r
withFontContext bytes action =
TextShape.withContext \ctx -> do
font <- TextShape.pushFontFromMemory ctx bytes 0
action ctx font
withFixedMemoryContext :: Int -> (TextShape.Context -> IO r) -> IO r
withFixedMemoryContext spareBytes action = do
contextSize <- evaluate ShapeContext.kbts_SizeOfShapeContext
assertBool "context size is known" (contextSize > 0)
allocaBytes (size contextSize) \mem -> do
handle <- ShapeContext.kbts_PlaceShapeContextFixedMemory2 (castPtr mem) (fromIntegral (size contextSize)) Flags.SHAPE_CONTEXT_FLAG_NONE
assertBool "context placed" (handle /= Handles.ShapeContext nullPtr)
fonts <- newIORef mempty
action TextShape.Context{handle, fonts}
where
size contextSize = fromIntegral contextSize + spareBytes
withShapeConfig :: Handles.Font -> (Handles.ShapeConfig -> IO r) -> IO r
withShapeConfig font =
bracket
(ShapeDirect.kbts_CreateShapeConfig font Enums.SCRIPT_DONT_KNOW Enums.LANGUAGE_DONT_KNOW nullFunPtr nullPtr)
ShapeDirect.kbts_DestroyShapeConfig
withScratchpad :: Handles.ShapeConfig -> (Handles.ShapeScratchpad -> IO r) -> IO r
withScratchpad config =
bracket
(ShapeDirect.kbts_CreateShapeScratchpad config nullFunPtr nullPtr)
ShapeDirect.kbts_DestroyShapeScratchpad
-- | Font, shape config and scratchpad for direct shaping.
withShapeSetup :: ByteString -> (Handles.Font -> Handles.ShapeConfig -> Handles.ShapeScratchpad -> IO r) -> IO r
withShapeSetup bytes action =
withFont bytes \font ->
withShapeConfig font \config ->
withScratchpad config \scratchpad ->
action font config scratchpad
withGlyphStorage :: (Ptr Structs.GlyphStorage -> IO r) -> IO r
withGlyphStorage action =
alloca @Structs.GlyphStorage \ptr -> do
ok <- ShapeDirect.kbts_InitializeGlyphStorage ptr nullFunPtr nullPtr
assertBool "glyph storage initialized" (ok /= 0)
result <- action ptr
ShapeDirect.kbts_FreeAllGlyphs ptr
pure result
nullGlyphConfig :: Handles.GlyphConfig
nullGlyphConfig = Handles.GlyphConfig nullPtr
-- * Helpers
shapeText :: TextShape.Context -> Text -> IO [TextShape.Glyph]
shapeText ctx text = concatMap snd <$> TextShape.run ctx (TextShape.text_ text)
feedText :: TextShape.Context -> Enums.Direction -> Text -> IO ()
feedText ctx paragraphDirection text = do
ShapeContext.kbts_ShapeBegin ctx.handle paragraphDirection Enums.LANGUAGE_DONT_KNOW
Text.withCStringLen text \(ptr, len) ->
ShapeContext.kbts_ShapeUtf8 ctx.handle ptr (fromIntegral len) Enums.USER_ID_GENERATION_MODE_CODEPOINT_INDEX
ShapeContext.kbts_ShapeEnd ctx.handle
shapeRuns2 :: TextShape.Context -> IO [(Structs.Run2, [TextShape.Glyph])]
shapeRuns2 ctx =
alloca \runPtr ->
alloca \glyphOutPtr ->
collect runPtr glyphOutPtr
where
collect runPtr glyphOutPtr = do
more <- ShapeContext.kbts_ShapeRun2 ctx.handle runPtr
if more == 0
then pure []
else do
run <- peek runPtr
glyphs <- TextShape.iterateGlyphs glyphOutPtr (Structs.run2GlyphIterator runPtr)
((run, glyphs) :) <$> collect runPtr glyphOutPtr
expectOneRun :: [(TextShape.Run, [TextShape.Glyph])] -> IO (TextShape.Run, [TextShape.Glyph])
expectOneRun = \case
[x] -> pure x
other -> assertFailure $ "expected one run, got " <> show (length other)
directShape :: Handles.Font -> Handles.ShapeScratchpad -> Handles.GlyphConfig -> Text -> IO [TextShape.Glyph]
directShape font scratchpad glyphConfig text =
withGlyphStorage \storagePtr -> do
forM_ (Text.unpack text) \c ->
ShapeDirect.kbts_PushGlyph storagePtr font (fromIntegral (ord c)) glyphConfig 0
shapeStorage scratchpad storagePtr
directShape2 :: Handles.Font -> Handles.ShapeScratchpad -> Ptr Int16 -> Text -> IO [TextShape.Glyph]
directShape2 font scratchpad normalizedVector text =
withGlyphStorage \storagePtr -> do
forM_ (Text.unpack text) \c ->
ShapeDirect.kbts_PushGlyph storagePtr font (fromIntegral (ord c)) nullGlyphConfig 0
alloca \itPtr -> do
err <- ShapeDirect.kbts_ShapeDirect2 scratchpad storagePtr Enums.DIRECTION_DONT_KNOW normalizedVector itPtr
err @?= Enums.SHAPE_ERROR_NONE
alloca \outPtr -> TextShape.iterateGlyphs outPtr itPtr
variationInfo :: Handles.Font -> IO (CInt, CInt)
variationInfo font =
alloca \axisCountPtr ->
alloca \instanceCountPtr -> do
ShapeDirect.kbts_GetVariationInfo font axisCountPtr instanceCountPtr
(,) <$> peek axisCountPtr <*> peek instanceCountPtr
normalizeVariations :: Handles.Font -> [Float] -> IO [Int16]
normalizeVariations font vector =
withArrayLen vector \count vectorPtr ->
allocaArray count \normalizedPtr -> do
ShapeDirect.kbts_NormalizeVariationVector font vectorPtr normalizedPtr
peekArray count normalizedPtr
englishName :: Handles.Font -> Word16 -> IO (Maybe Text)
englishName font nameId =
Font.lookupFontString font (Enums.FontInfoStringId (fromIntegral nameId)) Enums.WINDOWS_LANGUAGE_ID_ENGLISH_UNITED_STATES
pushFontWith :: TextShape.Context -> Handles.Font -> [Structs.Variation] -> IO (Handles.ContextFontHandle, Handles.Font)
pushFontWith ctx font variations =
withArrayLen variations \count variationsPtr ->
alloca \handlePtr -> do
pushed <- ShapeContext.kbts_ShapePushFont2 ctx.handle font variationsPtr (fromIntegral count) handlePtr
handle <- peek handlePtr
pure (handle, pushed)
withoutCapitalHeight :: ByteString -> ByteString
withoutCapitalHeight ttf = before <> ByteString.pack [0, 0] <> ByteString.drop 2 rest
where
(before, rest) = ByteString.splitAt (os2Offset + 88) ttf
os2Offset = case [readU32 (record + 8) | record <- tableRecords, ByteString.take 4 (ByteString.drop record ttf) == "OS/2"] of
offset : _ -> offset
[] -> error "withoutCapitalHeight: the font has no OS/2 table"
tableRecords = [12 + 16 * index | index <- [0 .. readU16 4 - 1]]
readU16 at = fromIntegral (ByteString.index ttf at) * 0x100 + fromIntegral (ByteString.index ttf (at + 1))
readU32 at = readU16 at * 0x10000 + readU16 (at + 2)
failedPushHandle :: (Ptr Handles.ContextFontHandle -> IO Handles.Font) -> IO Handles.ContextFontHandle
failedPushHandle push =
alloca \handlePtr -> do
poke handlePtr (Handles.ContextFontHandle 0x12345678)
pushed <- push handlePtr
pushed @?= Handles.Font nullPtr
peek handlePtr
expectContextError :: Enums.ShapeError -> IO a -> Assertion
expectContextError expected action =
try action >>= \case
Left (TextShape.ContextError _origin err) -> err @?= expected
Left other -> assertFailure $ "expected a ContextError, got " <> show other
Right _ -> assertFailure "expected a ContextError, got no exception"
expectFontError :: IO a -> Assertion
expectFontError action =
try action >>= \case
Left (TextShape.FontError _origin _reason) -> pure ()
Left other -> assertFailure $ "expected a FontError, got " <> show other
Right _ -> assertFailure "expected a FontError, got no exception"
expectWrittenHandle :: TextShape.Context -> (Ptr Handles.ContextFontHandle -> IO Handles.Font) -> IO ()
expectWrittenHandle ctx push =
alloca \handlePtr -> do
poke handlePtr unwritten
pushed <- push handlePtr
assertBool "font pushed" (pushed /= Handles.Font nullPtr)
handle <- peek handlePtr
assertBool "context font handle written" (handle /= unwritten)
applied <- ShapeContext.kbts_ShapeSetFontVariation ctx.handle handle (tagWord "wght") 800
applied @?= 1
where
unwritten = Handles.ContextFontHandle 0x12345678
advancesOf :: TextShape.Context -> Text -> IO [Int]
advancesOf ctx text = map (.advanceX) <$> shapeText ctx text
shapeStorage :: Handles.ShapeScratchpad -> Ptr Structs.GlyphStorage -> IO [TextShape.Glyph]
shapeStorage scratchpad storagePtr =
alloca \itPtr -> do
err <- ShapeDirect.kbts_ShapeDirect scratchpad storagePtr Enums.DIRECTION_DONT_KNOW itPtr
err @?= Enums.SHAPE_ERROR_NONE
alloca \outPtr -> TextShape.iterateGlyphs outPtr itPtr
guessUtf8 :: Text -> IO (Enums.Direction, Enums.Script)
guessUtf8 text =
Text.withCStringLen text \(ptr, len) ->
alloca \directionPtr -> alloca \scriptPtr -> do
poke directionPtr Enums.DIRECTION_DONT_KNOW
poke scriptPtr Enums.SCRIPT_DONT_KNOW
Segmentation.kbts_GuessTextPropertiesUtf8 ptr (fromIntegral len) directionPtr scriptPtr
(,) <$> peek directionPtr <*> peek scriptPtr
guessUtf32 :: Text -> IO (Enums.Direction, Enums.Script)
guessUtf32 text =
withArrayLen (map (fromIntegral . ord) (Text.unpack text) :: [CInt]) \len ptr ->
alloca \directionPtr -> alloca \scriptPtr -> do
poke directionPtr Enums.DIRECTION_DONT_KNOW
poke scriptPtr Enums.SCRIPT_DONT_KNOW
Segmentation.kbts_GuessTextPropertiesUtf32 ptr (fromIntegral len) directionPtr scriptPtr
(,) <$> peek directionPtr <*> peek scriptPtr
hasBreakFlag :: Flags.BreakFlags -> Flags.BreakFlags -> Bool
hasBreakFlag flags flag = flags .&. flag == flag
-- | Collect breaks with 1-per-codepoint positions and a generous output capacity.
breakEntireUtf32 :: Text -> IO [Structs.Break]
breakEntireUtf32 text =
withArrayLen (map (fromIntegral . ord) (Text.unpack text) :: [CInt]) \len codepointsPtr ->
withBreakBuffers len \breaksPtr breakCountPtr flagsPtr flagCountPtr -> do
Segmentation.kbts_BreakEntireStringUtf32
Enums.DIRECTION_DONT_KNOW
Enums.JAPANESE_LINE_BREAK_STYLE_NORMAL
mempty
(castPtr codepointsPtr)
(fromIntegral len)
breaksPtr
(fromIntegral $ breakCapacity len)
breakCountPtr
flagsPtr
(fromIntegral len)
flagCountPtr
breakEntireUtf8 :: Text -> IO [Structs.Break]
breakEntireUtf8 text =
Text.withCStringLen text \(textPtr, len) ->
withBreakBuffers len \breaksPtr breakCountPtr flagsPtr flagCountPtr -> do
Segmentation.kbts_BreakEntireStringUtf8
Enums.DIRECTION_DONT_KNOW
Enums.JAPANESE_LINE_BREAK_STYLE_NORMAL
mempty
textPtr
(fromIntegral len)
breaksPtr
(fromIntegral $ breakCapacity len)
breakCountPtr
flagsPtr
(fromIntegral len)
flagCountPtr
breakCapacity :: Int -> Int
breakCapacity len = 4 * len + 16
{- | Prepare output buffers for a @BreakEntireString*@ call and read them back.
Upstream (still in 2.32) advances its write cursor and the final count even
when a break gets merged into a previously written position, leaving unwritten
holes in the output array. The vendored copy patches that. The buffer is still
pre-zeroed and empty-flag records dropped as insurance. A real break always
carries at least one flag.
-}
withBreakBuffers
:: Int
-> (Ptr Structs.Break -> Ptr CInt -> Ptr Flags.BreakFlags -> Ptr CInt -> IO ())
-> IO [Structs.Break]
withBreakBuffers len fill =
allocaArray capacity \breaksPtr ->
alloca \breakCountPtr ->
allocaArray len \flagsPtr ->
alloca \flagCountPtr -> do
fillBytes breaksPtr 0 $ capacity * sizeOf (undefined :: Structs.Break)
fill breaksPtr breakCountPtr flagsPtr flagCountPtr
count <- peek breakCountPtr
breaks <- peekArray (min capacity (fromIntegral count)) breaksPtr
pure $ filter (\b -> b.flags /= mempty) breaks
where
capacity = breakCapacity len
-- | Merge same-position breaks the way @kbts_BreakEntireString@ does.
mergeBreaks :: [Structs.Break] -> [(Int, Flags.BreakFlags)]
mergeBreaks = foldl insert []
where
insert acc b =
case break (\(position, _flags) -> position == b.position) acc of
(before, (position, flags) : next) -> before <> ((position, flags <> b.flags) : next)
(_, []) -> acc <> [(b.position, b.flags)]
breakIncremental :: Text -> IO [Structs.Break]
breakIncremental text =
allocaBytes Handles.sizeOfBreakState \raw -> do
fillBytes raw 0 Handles.sizeOfBreakState
let state = Handles.BreakState (castPtr raw)
Segmentation.kbts_BreakBegin state Enums.DIRECTION_DONT_KNOW Enums.JAPANESE_LINE_BREAK_STYLE_NORMAL mempty
alloca \breakPtr -> do
let drain acc = do
more <- Segmentation.kbts_Break state breakPtr
if more /= 0
then do
b <- peek breakPtr
drain $ b : acc
else pure acc
feed acc (c, isLast) = do
Segmentation.kbts_BreakAddCodepoint state (fromIntegral (ord c)) 1 (if isLast then 1 else 0)
drain acc
codepoints = Text.unpack text
annotated = zip codepoints $ map (== length codepoints) [1 ..]
reverse <$> foldM feed [] annotated
scriptTag :: Text -> Other.ScriptTag
scriptTag = Other.ScriptTag . tagWord
tagWord :: Text -> Word32
tagWord tag = case Text.unpack tag of
[a, b, c, d] -> Enums.fourcc a b c d
other -> error $ "tagWord: expected 4 characters, got " <> show other
wght :: Float -> TextShape.Variation
wght = TextShape.Variation (TextShape.fourcc 'w' 'g' 'h' 't')