| /**************************************************************************** |
| * |
| * ttcolr.c |
| * |
| * TrueType and OpenType colored glyph layer support (body). |
| * |
| * Copyright (C) 2018-2020 by |
| * David Turner, Robert Wilhelm, Dominik Röttsches, and Werner Lemberg. |
| * |
| * Originally 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' table specification: |
| * |
| * https://www.microsoft.com/typography/otspec/colr.htm |
| * |
| */ |
| |
| |
| #include <freetype/internal/ftdebug.h> |
| #include <freetype/internal/ftstream.h> |
| #include <freetype/tttags.h> |
| #include <freetype/ftcolor.h> |
| #include <freetype/config/integer-types.h> |
| |
| |
| #ifdef TT_CONFIG_OPTION_COLOR_LAYERS |
| |
| #include "ttcolr.h" |
| |
| |
| /* NOTE: These are the table sizes calculated through the specs. */ |
| #define BASE_GLYPH_SIZE 6U |
| #define BASE_GLYPH_V1_RECORD_SIZE 6U |
| #define LAYER_V1_LIST_PAINT_OFFSET_SIZE 4U |
| #define LAYER_V1_LIST_NUM_LAYERS_SIZE 4U |
| #define COLOR_STOP_SIZE 6U |
| #define LAYER_SIZE 4U |
| #define COLR_HEADER_SIZE 14U |
| |
| |
| typedef struct BaseGlyphRecord_ |
| { |
| FT_UShort gid; |
| FT_UShort first_layer_index; |
| FT_UShort num_layers; |
| |
| } BaseGlyphRecord; |
| |
| |
| typedef struct BaseGlyphV1Record_ |
| { |
| FT_UShort gid; |
| /* Offset from start of BaseGlyphV1List, i.e., from base_glyphs_v1. */ |
| FT_ULong paint_offset; |
| |
| } BaseGlyphV1Record; |
| |
| |
| typedef struct Colr_ |
| { |
| FT_UShort version; |
| FT_UShort num_base_glyphs; |
| FT_UShort num_layers; |
| |
| FT_Byte* base_glyphs; |
| FT_Byte* layers; |
| |
| FT_ULong num_base_glyphs_v1; |
| /* Points at beginning of BaseGlyphV1List. */ |
| FT_Byte* base_glyphs_v1; |
| |
| FT_ULong num_layers_v1; |
| FT_Byte* layers_v1; |
| |
| /* The memory that backs up the `COLR' table. */ |
| void* table; |
| FT_ULong table_size; |
| |
| } Colr; |
| |
| |
| /************************************************************************** |
| * |
| * 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 ttcolr |
| |
| |
| 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* table = NULL; |
| FT_Byte* p = NULL; |
| /* Needed for reading array lengths in referenced tables. */ |
| FT_Byte* p1 = NULL; |
| |
| Colr* colr = NULL; |
| |
| FT_ULong base_glyph_offset, layer_offset; |
| FT_ULong base_glyphs_offset_v1, num_base_glyphs_v1; |
| FT_ULong layer_offset_v1, num_layers_v1; |
| FT_ULong table_size; |
| |
| |
| /* `COLR' always needs `CPAL' */ |
| if ( !face->cpal ) |
| return FT_THROW( Invalid_File_Format ); |
| |
| error = face->goto_table( face, TTAG_COLR, stream, &table_size ); |
| if ( error ) |
| goto NoColr; |
| |
| if ( table_size < COLR_HEADER_SIZE ) |
| goto InvalidTable; |
| |
| if ( FT_FRAME_EXTRACT( table_size, table ) ) |
| goto NoColr; |
| |
| p = table; |
| |
| if ( FT_NEW( colr ) ) |
| goto NoColr; |
| |
| colr->version = FT_NEXT_USHORT( p ); |
| if ( colr->version != 0 && colr->version != 1 ) |
| goto InvalidTable; |
| |
| colr->num_base_glyphs = FT_NEXT_USHORT( p ); |
| base_glyph_offset = FT_NEXT_ULONG( p ); |
| |
| if ( base_glyph_offset >= table_size ) |
| goto InvalidTable; |
| if ( colr->num_base_glyphs * BASE_GLYPH_SIZE > |
| table_size - base_glyph_offset ) |
| goto InvalidTable; |
| |
| layer_offset = FT_NEXT_ULONG( p ); |
| colr->num_layers = FT_NEXT_USHORT( p ); |
| |
| if ( layer_offset >= table_size ) |
| goto InvalidTable; |
| if ( colr->num_layers * LAYER_SIZE > table_size - layer_offset ) |
| goto InvalidTable; |
| |
| if ( colr->version == 1 ) |
| { |
| base_glyphs_offset_v1 = FT_NEXT_ULONG( p ); |
| |
| if ( base_glyphs_offset_v1 >= table_size ) |
| goto InvalidTable; |
| |
| p1 = (FT_Byte*)( table + base_glyphs_offset_v1 ); |
| num_base_glyphs_v1 = FT_PEEK_ULONG( p1 ); |
| |
| if ( num_base_glyphs_v1 * BASE_GLYPH_V1_RECORD_SIZE > |
| table_size - base_glyphs_offset_v1 ) |
| goto InvalidTable; |
| |
| colr->num_base_glyphs_v1 = num_base_glyphs_v1; |
| colr->base_glyphs_v1 = p1; |
| |
| layer_offset_v1 = FT_NEXT_ULONG( p ); |
| |
| if ( !layer_offset_v1 || layer_offset_v1 >= table_size ) |
| goto InvalidTable; |
| |
| p1 = (FT_Byte*)( table + layer_offset_v1 ); |
| num_layers_v1 = FT_PEEK_ULONG( p1 ); |
| |
| colr->num_layers_v1 = num_layers_v1; |
| colr->layers_v1 = p1; |
| } |
| |
| colr->base_glyphs = (FT_Byte*)( table + base_glyph_offset ); |
| colr->layers = (FT_Byte*)( table + layer_offset ); |
| colr->table = table; |
| colr->table_size = table_size; |
| |
| face->colr = colr; |
| |
| return FT_Err_Ok; |
| |
| InvalidTable: |
| error = FT_THROW( Invalid_Table ); |
| |
| NoColr: |
| FT_FRAME_RELEASE( table ); |
| FT_FREE( colr ); |
| |
| 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; |
| |
| Colr* colr = (Colr*)face->colr; |
| |
| |
| if ( colr ) |
| { |
| FT_FRAME_RELEASE( colr->table ); |
| FT_FREE( colr ); |
| } |
| } |
| |
| |
| static FT_Bool |
| find_base_glyph_record( FT_Byte* base_glyph_begin, |
| FT_Int num_base_glyph, |
| FT_UInt 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_Bool ) |
| tt_face_get_colr_layer( TT_Face face, |
| FT_UInt base_glyph, |
| FT_UInt *aglyph_index, |
| FT_UInt *acolor_index, |
| FT_LayerIterator* iterator ) |
| { |
| Colr* colr = (Colr*)face->colr; |
| BaseGlyphRecord glyph_record; |
| |
| |
| if ( !colr ) |
| return 0; |
| |
| if ( !iterator->p ) |
| { |
| FT_ULong offset; |
| |
| |
| /* first call to function */ |
| iterator->layer = 0; |
| |
| if ( !find_base_glyph_record( colr->base_glyphs, |
| colr->num_base_glyphs, |
| base_glyph, |
| &glyph_record ) ) |
| return 0; |
| |
| if ( glyph_record.num_layers ) |
| iterator->num_layers = glyph_record.num_layers; |
| else |
| return 0; |
| |
| offset = LAYER_SIZE * glyph_record.first_layer_index; |
| if ( offset + LAYER_SIZE * glyph_record.num_layers > colr->table_size ) |
| return 0; |
| |
| iterator->p = colr->layers + offset; |
| } |
| |
| if ( iterator->layer >= iterator->num_layers ) |
| return 0; |
| |
| *aglyph_index = FT_NEXT_USHORT( iterator->p ); |
| *acolor_index = FT_NEXT_USHORT( iterator->p ); |
| |
| if ( *aglyph_index >= (FT_UInt)( FT_FACE( face )->num_glyphs ) || |
| ( *acolor_index != 0xFFFF && |
| *acolor_index >= face->palette_data.num_palette_entries ) ) |
| return 0; |
| |
| iterator->layer++; |
| |
| return 1; |
| } |
| |
| |
| static FT_Bool |
| find_base_glyph_v1_record ( FT_Byte * base_glyph_begin, |
| FT_Int num_base_glyph, |
| FT_UInt glyph_id, |
| BaseGlyphV1Record *record ) |
| { |
| FT_Int min = 0; |
| FT_Int max = num_base_glyph - 1; |
| |
| |
| while ( min <= max ) |
| { |
| FT_Int mid = min + ( max - min ) / 2; |
| |
| /* |
| * `base_glyph_begin` is the beginning of `BaseGlyphV1List`; |
| * skip `numBaseGlyphV1Records` by adding 4 to start binary search |
| * in the array of `BaseGlyphV1Record`. |
| */ |
| FT_Byte *p = base_glyph_begin + 4 + mid * BASE_GLYPH_V1_RECORD_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->paint_offset = FT_NEXT_ULONG ( p ); |
| return 1; |
| } |
| } |
| |
| return 0; |
| } |
| |
| |
| FT_LOCAL_DEF ( FT_Bool ) |
| tt_face_get_colr_glyph_paint( TT_Face face, |
| FT_UInt base_glyph, |
| FT_OpaquePaint* opaque_paint ) |
| { |
| Colr* colr = (Colr*)face->colr; |
| |
| BaseGlyphV1Record base_glyph_v1_record; |
| FT_Byte* p; |
| |
| |
| if ( colr->version < 1 || !colr->num_base_glyphs_v1 || |
| !colr->base_glyphs_v1 ) |
| return 0; |
| |
| if ( opaque_paint->p ) |
| return 0; |
| |
| if ( !find_base_glyph_v1_record( colr->base_glyphs_v1, |
| colr->num_base_glyphs_v1, |
| base_glyph, |
| &base_glyph_v1_record ) ) |
| return 0; |
| |
| if ( !base_glyph_v1_record.paint_offset || |
| base_glyph_v1_record.paint_offset > colr->table_size ) |
| return 0; |
| |
| p = (FT_Byte*)( colr->base_glyphs_v1 + |
| base_glyph_v1_record.paint_offset ); |
| if ( p >= ( (FT_Byte*)colr->table + colr->table_size ) ) |
| return 0; |
| |
| opaque_paint->p = p; |
| |
| return 1; |
| } |
| |
| |
| FT_LOCAL_DEF( FT_Error ) |
| tt_face_colr_blend_layer( TT_Face face, |
| FT_UInt color_index, |
| FT_GlyphSlot dstSlot, |
| FT_GlyphSlot srcSlot ) |
| { |
| FT_Error error; |
| |
| FT_UInt x, y; |
| FT_Byte b, g, r, alpha; |
| |
| FT_ULong 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 = (int)dstSlot->bitmap.width * 4; |
| dstSlot->bitmap.num_grays = 256; |
| |
| size = dstSlot->bitmap.rows * (unsigned int)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 = (FT_UInt)( x_max - x_min ); |
| FT_UInt rows = (FT_UInt)( y_max - y_min ); |
| FT_UInt pitch = width * 4; |
| |
| FT_Byte* buf = NULL; |
| FT_Byte* p; |
| FT_Byte* q; |
| |
| |
| size = rows * pitch; |
| if ( FT_ALLOC( buf, size ) ) |
| return error; |
| |
| p = dstSlot->bitmap.buffer; |
| q = buf + |
| (int)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 = (int)pitch; |
| |
| dstSlot->internal->flags |= FT_GLYPH_OWN_BITMAP; |
| dstSlot->format = FT_GLYPH_FORMAT_BITMAP; |
| } |
| } |
| |
| if ( color_index == 0xFFFF ) |
| { |
| if ( face->have_foreground_color ) |
| { |
| b = face->foreground_color.blue; |
| g = face->foreground_color.green; |
| r = face->foreground_color.red; |
| alpha = face->foreground_color.alpha; |
| } |
| else |
| { |
| if ( face->palette_data.palette_flags && |
| ( face->palette_data.palette_flags[face->palette_index] & |
| FT_PALETTE_FOR_DARK_BACKGROUND ) ) |
| { |
| /* white opaque */ |
| b = 0xFF; |
| g = 0xFF; |
| r = 0xFF; |
| alpha = 0xFF; |
| } |
| else |
| { |
| /* black opaque */ |
| b = 0x00; |
| g = 0x00; |
| r = 0x00; |
| alpha = 0xFF; |
| } |
| } |
| } |
| else |
| { |
| b = face->palette[color_index].blue; |
| g = face->palette[color_index].green; |
| r = face->palette[color_index].red; |
| alpha = face->palette[color_index].alpha; |
| } |
| |
| /* 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] = (FT_Byte)( bb * ba2 / 255 + fb ); |
| dst[4 * x + 1] = (FT_Byte)( bg * ba2 / 255 + fg ); |
| dst[4 * x + 2] = (FT_Byte)( br * ba2 / 255 + fr ); |
| dst[4 * x + 3] = (FT_Byte)( 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 */ |