freetype/src/sfnt/ttcolr.c

/***************************************************************************/
/*                                                                         */
/*  ttcolr.c                                                               */
/*                                                                         */
/*    TrueType and OpenType color outline support.                         */
/*                                                                         */
/*  Copyright 2018 by                                                      */
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
/*                                                                         */
/*  Written by Shao Yu Zhang <shaozhang@fb.com>.                           */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used,       */
/*  modified, and distributed under the terms of the FreeType project      */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/


  /*************************************************************************/
  /*                                                                       */
  /* `COLR' and `CPAL' table specification:                                */
  /*                                                                       */
  /*   https://www.microsoft.com/typography/otspec/colr.htm                */
  /*   https://www.microsoft.com/typography/otspec/cpal.htm                */
  /*                                                                       */
  /*************************************************************************/


#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_TRUETYPE_TAGS_H


#ifdef TT_CONFIG_OPTION_COLOR_LAYERS

#include "ttcolr.h"


  /* NOTE: These are the table sizes calculated through the specs. */
#define BASE_GLYPH_SIZE            6
#define LAYER_SIZE                 4
#define COLR_HEADER_SIZE          14
#define CPAL_V0_HEADER_BASE_SIZE  12
#define COLOR_SIZE                 4


  typedef struct BaseGlyphRecord_
  {
    FT_UShort  gid;
    FT_UShort  first_layer_index;
    FT_UShort  num_layers;

  } BaseGlyphRecord;


  typedef struct Colr_
  {
    FT_UShort  version;
    FT_UShort  num_base_glyphs;
    FT_UShort  num_layers;

    FT_Byte*  base_glyphs;
    FT_Byte*  layers;

  } Colr;


  typedef struct Cpal_
  {
    FT_UShort  version;        /* Table version number (0 or 1 supported). */
    FT_UShort  num_palettes_entries;      /* # of entries in each palette. */
    FT_UShort  num_palettes;                /* # of palettes in the table. */
    FT_UShort  num_colors;               /* Total number of color records, */
                                         /* combined for all palettes.     */
    FT_Byte*  colors;                              /* RGBA array of colors */
    FT_Byte*  color_indices; /* Index of each palette's first color record */
                             /* in the combined color record array.        */

    /* version 1 fields */
    FT_ULong*   palette_types;
    FT_UShort*  palette_labels;
    FT_UShort*  palette_entry_labels;

  } Cpal;


  typedef struct ColrCpal_
  {
    /* Accessors into the colr/cpal tables. */
    Colr  colr;
    Cpal  cpal;

    /* The memory which backs up colr/cpal tables. */
    void*  colr_table;
    void*  cpal_table;

  } ColrCpal;


  /*************************************************************************/
  /*                                                                       */
  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  /* messages during execution.                                            */
  /*                                                                       */
#undef  FT_COMPONENT
#define FT_COMPONENT  trace_ttcolrcpal


  FT_LOCAL_DEF( FT_Error )
  tt_face_load_colr( TT_Face    face,
                     FT_Stream  stream )
  {
    FT_Error   error;
    FT_Memory  memory = face->root.memory;

    FT_Byte*  colr_table = NULL;
    FT_Byte*  cpal_table = NULL;
    FT_Byte*  p          = NULL;

    Colr       colr;
    Cpal       cpal;
    ColrCpal*  cc = NULL;

    FT_ULong  base_glyph_begin, base_glyph_end, layer_begin, layer_end;
    FT_ULong  colors_begin, colors_end;
    FT_ULong  table_size;


    face->colr_and_cpal = NULL;

    error = face->goto_table( face, TTAG_COLR, stream, &table_size );
    if ( error )
      goto NoColor;

    if ( table_size < sizeof ( COLR_HEADER_SIZE ) )
      goto InvalidTable;

    if ( FT_FRAME_EXTRACT( table_size, colr_table ) )
      goto NoColor;

    p = colr_table;

    FT_ZERO( &colr );
    colr.version         = FT_NEXT_USHORT( p );
    colr.num_base_glyphs = FT_NEXT_USHORT( p );

    base_glyph_begin = FT_NEXT_ULONG( p );
    layer_begin      = FT_NEXT_ULONG( p );

    colr.num_layers  = FT_NEXT_USHORT( p );
    colr.base_glyphs = (FT_Byte*)( colr_table + base_glyph_begin );
    colr.layers      = (FT_Byte*)( colr_table + layer_begin      );

    if ( colr.version != 0 )
      goto InvalidTable;

    /* Ensure variable length tables lies within the COLR table.      */
    /* We wrap around FT_ULong at most once since count is FT_UShort. */

    base_glyph_end = base_glyph_begin +
                     colr.num_base_glyphs * BASE_GLYPH_SIZE;
    layer_end      = layer_begin +
                     colr.num_layers * LAYER_SIZE;
    if ( base_glyph_end < base_glyph_begin || base_glyph_end > table_size ||
         layer_end      < layer_begin      || layer_end      > table_size )
      goto InvalidTable;

    /* Ensure pointers don't wrap. */
    if ( colr.base_glyphs < colr_table || colr.layers < colr_table )
      goto InvalidTable;

    error = face->goto_table( face, TTAG_CPAL, stream, &table_size );
    if ( error )
      goto NoColor;

    if ( table_size < CPAL_V0_HEADER_BASE_SIZE )
      goto InvalidTable;

    if ( FT_FRAME_EXTRACT( table_size, cpal_table ) )
      goto NoColor;

    p = cpal_table;

    FT_ZERO( &cpal );
    cpal.version              = FT_NEXT_USHORT( p );
    cpal.num_palettes_entries = FT_NEXT_USHORT( p );
    cpal.num_palettes         = FT_NEXT_USHORT( p );
    cpal.num_colors           = FT_NEXT_USHORT( p );

    colors_begin = FT_NEXT_ULONG( p );

    cpal.color_indices = p;
    cpal.colors        = (FT_Byte*)cpal_table + colors_begin;

    if ( cpal.version != 0 && cpal.version != 1 )
      goto InvalidTable;

    colors_end = colors_begin + cpal.num_colors * COLOR_SIZE;

    /* Ensure variable length tables lies within the COLR table.      */
    /* We wrap around FT_ULong at most once since count is FT_UShort. */
    if ( colors_end < colors_begin || colors_end > table_size )
      goto InvalidTable;

    if ( cpal.colors < cpal_table )
      goto InvalidTable;

    if ( FT_NEW( cc ) )
      goto NoColor;

    cc->colr       = colr;
    cc->cpal       = cpal;
    cc->colr_table = colr_table;
    cc->cpal_table = cpal_table;

    face->colr_and_cpal = cc;

    return FT_Err_Ok;

  InvalidTable:
    error = FT_THROW( Invalid_File_Format );

  NoColor:
    if ( colr_table )
      FT_FRAME_RELEASE( colr_table );
    if ( cpal_table )
      FT_FRAME_RELEASE( cpal_table );

    return error;
  }


  FT_LOCAL_DEF( void )
  tt_face_free_colr( TT_Face  face )
  {
    FT_Stream  stream = face->root.stream;
    FT_Memory  memory = face->root.memory;

    ColrCpal*  colr_and_cpal = (ColrCpal*)face->colr_and_cpal;


    if ( colr_and_cpal )
    {
      FT_FRAME_RELEASE( colr_and_cpal->colr_table );
      FT_FRAME_RELEASE( colr_and_cpal->cpal_table );

      FT_FREE( face->colr_and_cpal );
    }
  }


  static FT_Bool
  find_base_glyph_record( FT_Byte*          base_glyph_begin,
                          FT_Int            num_base_glyph,
                          FT_UShort         glyph_id,
                          BaseGlyphRecord*  record )
  {
    FT_Int  min = 0;
    FT_Int  max = num_base_glyph - 1;


    while ( min <= max )
    {
      FT_Int    mid = min + ( max - min ) / 2;
      FT_Byte*  p   = base_glyph_begin + mid * BASE_GLYPH_SIZE;

      FT_UShort  gid  = FT_NEXT_USHORT( p );


      if ( gid < glyph_id )
        min = mid + 1;
      else if (gid > glyph_id )
        max = mid - 1;
      else
      {
        record->gid               = gid;
        record->first_layer_index = FT_NEXT_USHORT( p );
        record->num_layers        = FT_NEXT_USHORT( p );

        return 1;
      }
    }

    return 0;
  }


  FT_LOCAL_DEF( FT_Error )
  tt_face_load_colr_layers( TT_Face              face,
                            FT_Int               glyph_id,
                            FT_Glyph_LayerRec*  *ret_layers,
                            FT_UShort*           ret_num_layers )
  {
    FT_Error   error;
    FT_Memory  memory = face->root.memory;

    ColrCpal*  colr_and_cpal = (ColrCpal *)face->colr_and_cpal;
    Colr*      colr          = &colr_and_cpal->colr;
    Cpal*      cpal          = &colr_and_cpal->cpal;

    BaseGlyphRecord     glyph_record;
    FT_Glyph_LayerRec*  layers;
    int                 layer_idx;
    FT_Byte*            layer_record_ptr;


    if ( !ret_layers || !ret_num_layers )
      return FT_THROW( Invalid_Argument );

    if ( !find_base_glyph_record( colr->base_glyphs,
                                  colr->num_base_glyphs,
                                  glyph_id,
                                  &glyph_record ) )
      return FT_THROW ( Invalid_Table );

    /* Load all colors for the glyphs; this would be stored in the slot. */
    layer_record_ptr = colr->layers +
                       glyph_record.first_layer_index * LAYER_SIZE;

    if ( FT_NEW_ARRAY( layers, glyph_record.num_layers ) )
      goto Error;

    for ( layer_idx = 0; layer_idx < glyph_record.num_layers; layer_idx++ )
    {
      FT_UShort  gid           = FT_NEXT_USHORT( layer_record_ptr );
      FT_UShort  palette_index = FT_NEXT_USHORT( layer_record_ptr );


      if ( palette_index != 0xFFFF                     &&
           palette_index >= cpal->num_palettes_entries )
      {
        error = FT_THROW( Invalid_File_Format );
        goto Error;
      }

      layers[layer_idx].color_index = palette_index;
      layers[layer_idx].glyph_index = gid;
    }

    *ret_layers     = layers;
    *ret_num_layers = glyph_record.num_layers;

    return FT_Err_Ok;

  Error:
    if ( layers )
      FT_FREE( layers );

    return error;
  }


  static FT_Bool
  tt_face_find_color( TT_Face    face,
                      FT_UShort  color_index,
                      FT_Byte*   blue,
                      FT_Byte*   green,
                      FT_Byte*   red,
                      FT_Byte*   alpha )
  {
    ColrCpal*  colr_and_cpal = (ColrCpal *)face->colr_and_cpal;
    Cpal*      cpal          = &colr_and_cpal->cpal;

    FT_Int    palette_index = 0;
    FT_Byte*  p;
    FT_Int    color_offset;


    if ( color_index >= cpal->num_palettes_entries )
      return 0;

    p = cpal->color_indices + palette_index * sizeof ( FT_UShort );

    color_offset = FT_NEXT_USHORT( p );

    p = cpal->colors + color_offset + COLOR_SIZE * color_index;

    *red   = FT_NEXT_BYTE( p );
    *green = FT_NEXT_BYTE( p );
    *blue  = FT_NEXT_BYTE( p );
    *alpha = FT_NEXT_BYTE( p );

    return 1;
  }


  FT_LOCAL_DEF( FT_Error )
  tt_face_colr_blend_layer( TT_Face       face,
                            FT_Int        color_index,
                            FT_GlyphSlot  dstSlot,
                            FT_GlyphSlot  srcSlot )
  {
    FT_Error  error;

    FT_UInt  x, y;
    FT_Byte  b, g, r, alpha;

    FT_Long   size;
    FT_Byte*  src;
    FT_Byte*  dst;


    if ( !dstSlot->bitmap.buffer )
    {
      /* Initialize destination of color bitmap */
      /* with the size of first component.      */
      dstSlot->bitmap_left = srcSlot->bitmap_left;
      dstSlot->bitmap_top  = srcSlot->bitmap_top;

      dstSlot->bitmap.width      = srcSlot->bitmap.width;
      dstSlot->bitmap.rows       = srcSlot->bitmap.rows;
      dstSlot->bitmap.pixel_mode = FT_PIXEL_MODE_BGRA;
      dstSlot->bitmap.pitch      = dstSlot->bitmap.width * 4;
      dstSlot->bitmap.num_grays  = 256;

      size = dstSlot->bitmap.rows * dstSlot->bitmap.pitch;

      error = ft_glyphslot_alloc_bitmap( dstSlot, size );
      if ( error )
        return error;

      FT_MEM_ZERO( dstSlot->bitmap.buffer, size );
    }
    else
    {
      /* Resize destination if needed such that new component fits. */
      FT_Int  x_min, x_max, y_min, y_max;


      x_min = FT_MIN( dstSlot->bitmap_left, srcSlot->bitmap_left );
      x_max = FT_MAX( dstSlot->bitmap_left + (FT_Int)dstSlot->bitmap.width,
                      srcSlot->bitmap_left + (FT_Int)srcSlot->bitmap.width );

      y_min = FT_MIN( dstSlot->bitmap_top - (FT_Int)dstSlot->bitmap.rows,
                      srcSlot->bitmap_top - (FT_Int)srcSlot->bitmap.rows );
      y_max = FT_MAX( dstSlot->bitmap_top, srcSlot->bitmap_top );

      if ( x_min != dstSlot->bitmap_left                                 ||
           x_max != dstSlot->bitmap_left + (FT_Int)dstSlot->bitmap.width ||
           y_min != dstSlot->bitmap_top - (FT_Int)dstSlot->bitmap.rows   ||
           y_max != dstSlot->bitmap_top                                  )
      {
        FT_Memory  memory = face->root.memory;

        FT_UInt  width = x_max - x_min;
        FT_UInt  rows  = y_max - y_min;
        FT_UInt  pitch = width * 4;

        FT_Byte*  buf;
        FT_Byte*  p;
        FT_Byte*  q;


        size  = rows * pitch;
        if ( FT_ALLOC( buf, size ) )
          return error;

        p = dstSlot->bitmap.buffer;
        q = buf +
            pitch * ( y_max - dstSlot->bitmap_top ) +
            4 * ( dstSlot->bitmap_left - x_min );

        for ( y = 0; y < dstSlot->bitmap.rows; y++ )
        {
          FT_MEM_COPY( q, p, dstSlot->bitmap.width * 4 );

          p += dstSlot->bitmap.pitch;
          q += pitch;
        }

        ft_glyphslot_set_bitmap( dstSlot, buf );

        dstSlot->bitmap_top  = y_max;
        dstSlot->bitmap_left = x_min;

        dstSlot->bitmap.width = width;
        dstSlot->bitmap.rows  = rows;
        dstSlot->bitmap.pitch = pitch;

        dstSlot->internal->flags |= FT_GLYPH_OWN_BITMAP;
        dstSlot->format           = FT_GLYPH_FORMAT_BITMAP;
      }
    }

    /* Default assignments to pacify compiler. */
    r = g = b = 0;
    alpha = 255;

    if ( color_index != 0xFFFF )
      tt_face_find_color( face, color_index, &b, &g, &r, &alpha );
    else
    {
      /* TODO. foreground color from argument?                */
      /* Add public FT_Render_Glyph_Color() with color value? */
    }

    /* XXX Convert if srcSlot.bitmap is not grey? */
    src = srcSlot->bitmap.buffer;
    dst = dstSlot->bitmap.buffer +
          dstSlot->bitmap.pitch * ( dstSlot->bitmap_top - srcSlot->bitmap_top ) +
          4 * ( srcSlot->bitmap_left - dstSlot->bitmap_left );

    for ( y = 0; y < srcSlot->bitmap.rows; y++ )
    {
      for ( x = 0; x < srcSlot->bitmap.width; x++ )
      {
        int  aa = src[x];
        int  fa = alpha * aa / 255;

        int  fb = b * fa / 255;
        int  fg = g * fa / 255;
        int  fr = r * fa / 255;

        int  ba2 = 255 - fa;

        int  bb = dst[4 * x + 0];
        int  bg = dst[4 * x + 1];
        int  br = dst[4 * x + 2];
        int  ba = dst[4 * x + 3];


        dst[4 * x + 0] = bb * ba2 / 255 + fb;
        dst[4 * x + 1] = bg * ba2 / 255 + fg;
        dst[4 * x + 2] = br * ba2 / 255 + fr;
        dst[4 * x + 3] = ba * ba2 / 255 + fa;
      }

      src += srcSlot->bitmap.pitch;
      dst += dstSlot->bitmap.pitch;
    }

    return FT_Err_Ok;
  }

#else /* !TT_CONFIG_OPTION_COLOR_LAYERS */

  /* ANSI C doesn't like empty source files */
  typedef int  _tt_colr_dummy;

#endif /* !TT_CONFIG_OPTION_COLOR_LAYERS */

/* EOF */