packages feed

kb-text-shape-0.3.0.0: src/KB/Text/Shape/Font.hs

module KB.Text.Shape.Font
  ( -- * Distillation
    extractBlob

    -- * Loading
  , FontData(..)
  , createFont
  , destroyFont

    -- * Using
  , withFontData
  , Handles.Font

    -- * Querying
  , getFontInfo
  , Info(..)
  , lookupFontString
  , variationAxes
  , Structs.VariationAxisInfo(..)
  , emToCaps

  -- * Loading internals
  , withLoader
  , loadFont
  , LoadFontResult(..)
  , placeBlob
  ) where

import Prelude hiding (id)
import Foreign

import Control.Monad (forM, when)
import Data.ByteString (ByteString)
import Data.ByteString qualified as ByteString
import Data.ByteString.Internal qualified as ByteString
import Data.ByteString.Unsafe qualified as ByteString
import Data.Maybe (catMaybes)
import Data.Text (Text)
import Data.Text.Encoding qualified as Text
import Data.Text.Encoding.Error (lenientDecode)

import KB.Text.Shape.FFI.API.Direct qualified as ShapeDirect
import KB.Text.Shape.FFI.Flags qualified as Flags
import KB.Text.Shape.FFI.Enums qualified as Enums
import KB.Text.Shape.FFI.Handles qualified as Handles
import KB.Text.Shape.FFI.Structs qualified as Structs

-- | Extract and pre-process font data needed for shaping.
extractBlob
  :: ByteString -- ^ TTF font data
  -> Int -- ^ Font index (use 0 for the first/only font)
  -> IO ByteString -- ^ KBTS blob data
extractBlob fontData fontIndex =
  withLoader \font statePtr -> do
    loadFont fontData fontIndex font statePtr >>= \case
      Left err ->
        error $ show err
      Right LoadFontNeedsBlob{scratchSize, outputSize} ->
        placeBlob font statePtr scratchSize outputSize
      Right LoadFontReady ->
        pure fontData

createFont :: ByteString -> Int -> IO FontData
createFont fontSource fontIndex =
  withLoader \font statePtr -> do
    loadFont fontSource fontIndex font statePtr >>= \case
      Left err ->
        error $ show err
      Right LoadFontNeedsBlob{scratchSize, outputSize} -> do
        blobData <- placeBlob font statePtr scratchSize outputSize
        pure font{fontResources = [fontSource, blobData]}
      Right LoadFontReady ->
        pure font{fontResources = [fontSource]}

destroyFont :: FontData -> IO ()
destroyFont font = withFontData font ShapeDirect.kbts_FreeFont

-- | Haskell-owned font data
data FontData = FontData
 { fontData :: ForeignPtr Word8
 , fontResources :: [ByteString]
 }
  deriving (Eq, Show)

-- | Use the font handle from a loaded font
withFontData :: FontData -> (Handles.Font -> IO r) -> IO r
withFontData FontData{fontData} action = withForeignPtr fontData (action . Handles.Font . castPtr)

{- | Font metadata and metrics.

Name strings are the Windows-platform US English records, see 'lookupFontString'.
-}
getFontInfo :: Handles.Font -> IO Info
getFontInfo font = do
  Structs.FontInfo2{strings = _, ..} <-
    alloca \fontInfoPtr -> do
      Structs.prepareFontInfo2 fontInfoPtr
      ShapeDirect.kbts_GetFontInfo2 font fontInfoPtr
      peek fontInfoPtr
  strings <- catMaybes <$> traverse englishString allStringIds
  pure Info{..}
  where
    englishString stringId =
      fmap (stringId,) <$> lookupFontString font stringId Enums.WINDOWS_LANGUAGE_ID_ENGLISH_UNITED_STATES
    allStringIds =
      map (Enums.FontInfoStringId . fromIntegral) [1 .. Enums.FONT_INFO_STRING_ID_COUNT1 - 1]

{- | Fetch a name string in the given language.

Only Windows-platform name records are considered.
IDs from 'Enums.FONT_INFO_STRING_ID_COUNT1' up pass through as raw OpenType name IDs, like 'Structs.VariationAxisInfo' names.
See 'Structs.VariationInstanceInfo' for the instance name IDs that collide with the named ones.
-}
lookupFontString :: Handles.Font -> Enums.FontInfoStringId -> Enums.WindowsLanguageId -> IO (Maybe Text)
lookupFontString font stringId languageId = lookupWithCapacity 256
  where
    lookupWithCapacity capacity =
      allocaBytes capacity \buffer ->
        lookupInto buffer capacity >>= \case
          0 -> pure Nothing
          size
            | size > capacity -> lookupWithCapacity size
            | otherwise -> Just . Text.decodeUtf8With lenientDecode <$> ByteString.packCStringLen (buffer, size)
    lookupInto buffer capacity =
      fromIntegral <$> ShapeDirect.kbts_LookupFontString font stringId languageId buffer (fromIntegral capacity)

{- | The variation axes of a variable font, in the font's order.

A static font has none.
Look up an axis name with 'lookupFontString' and its @nameStringId@.
-}
variationAxes :: Handles.Font -> IO [Structs.VariationAxisInfo]
variationAxes font = do
  axisCount <- alloca \axisCountPtr -> do
    ShapeDirect.kbts_GetVariationInfo font axisCountPtr nullPtr
    peek axisCountPtr
  forM [0 .. axisCount - 1] \axisIndex ->
    alloca \axisInfoPtr -> do
      _found <- ShapeDirect.kbts_GetVariationAxisInfo font axisIndex axisInfoPtr
      peek axisInfoPtr

data Info = Info
  { strings :: [(Enums.FontInfoStringId, Text)]
  , styleFlags :: Flags.FontStyleFlags
  , weight :: Enums.FontWeight
  , width :: Enums.FontWidth

  , unitsPerEm :: Word16

    -- Bounding box
  , xMin :: Int16
  , yMin :: Int16
  , xMax :: Int16
  , yMax :: Int16

  , ascent :: Int16
  , descent :: Int16
  , lineGap :: Int16

  , capitalHeight :: Int16 -- ^ Zero when the font does not provide it.
  }
  deriving (Eq, Show)

{- | Scaling factor to go from font-specific Em units to a cap-height normalized units.

This results in more consistent font sizing when using multiple fonts.
You may even have a chance to align something vertically!
-}
{-# INLINE emToCaps #-}
emToCaps :: Fractional a => Info -> a
emToCaps Info{unitsPerEm, capitalHeight} = fromIntegral unitsPerEm / fromIntegral capitalHeight

withLoader :: (FontData -> Ptr ShapeDirect.LoadFontState -> IO a) -> IO a
withLoader action = do
  fontData <- mallocForeignPtrBytes Handles.sizeOfFontData
  let font = FontData{fontData, fontResources = []}
  withFontData font \(Handles.Font fontPtr) ->
    fillBytes fontPtr 0x00 Handles.sizeOfFontData
  alloca \statePtr -> do
    fillBytes statePtr 0x00 $ sizeOf (undefined :: ShapeDirect.LoadFontState)
    action font statePtr

data LoadFontResult
  = LoadFontReady
  | LoadFontNeedsBlob { scratchSize :: Int, outputSize :: Int}

loadFont
  :: ByteString
  -> Int
  -> FontData
  -> Ptr ShapeDirect.LoadFontState
  -> IO (Either Enums.LoadFontError LoadFontResult)
loadFont ttfData fontIndex font statePtr =
  withFontData font \fontPtr ->
    alloca \scratchSizePtr ->
      alloca \outputSizePtr ->
        ByteString.unsafeUseAsCStringLen ttfData \(ttfDataPtr, ttfDataSize) -> do
          err <- ShapeDirect.kbts_LoadFont
            fontPtr
            statePtr
            (castPtr ttfDataPtr)
            (fromIntegral ttfDataSize)
            (fromIntegral fontIndex)
            scratchSizePtr
            outputSizePtr
          case err of
            Enums.LOAD_FONT_ERROR_NONE ->
              pure $ Right LoadFontReady
            Enums.LOAD_FONT_ERROR_NEED_TO_CREATE_BLOB -> do
              scratchSize <- fromIntegral <$> peek scratchSizePtr
              outputSize <- fromIntegral <$> peek outputSizePtr
              pure $ Right LoadFontNeedsBlob{..}
            _ ->
              pure $ Left err

placeBlob :: FontData -> Ptr ShapeDirect.LoadFontState -> Int -> Int -> IO ByteString
placeBlob font statePtr scratchSize outputSize =
  allocaBytes scratchSize \scratchPtr -> do
    fillBytes scratchPtr 0x00 scratchSize
    outputData <- mallocForeignPtrBytes outputSize
    withForeignPtr outputData \outputPtr ->
      withFontData font \fontPtr -> do
        fillBytes outputPtr 0x00 outputSize
        err <- ShapeDirect.kbts_PlaceBlob fontPtr statePtr scratchPtr (castPtr outputPtr)
        when (err /= Enums.LOAD_FONT_ERROR_NONE) $
          error $ show err
        pure $! ByteString.fromForeignPtr0 outputData outputSize