src/cff/cffload.c

   1 /****************************************************************************
   2  *
   3  * cffload.c
   4  *
   5  *   OpenType and CFF data/program tables loader (body).
   6  *
   7  * Copyright (C) 1996-2023 by
   8  * David Turner, Robert Wilhelm, and Werner Lemberg.
   9  *
  10  * This file is part of the FreeType project, and may only be used,
  11  * modified, and distributed under the terms of the FreeType project
  12  * license, LICENSE.TXT.  By continuing to use, modify, or distribute
  13  * this file you indicate that you have read the license and
  14  * understand and accept it fully.
  15  *
  16  */
  17
  18
  19 #include <freetype/internal/ftdebug.h>
  20 #include <freetype/internal/ftobjs.h>
  21 #include <freetype/internal/ftstream.h>
  22 #include <freetype/tttags.h>
  23 #include <freetype/t1tables.h>
  24 #include <freetype/internal/psaux.h>
  25
  26 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
  27 #include <freetype/ftmm.h>
  28 #include <freetype/internal/services/svmm.h>
  29 #endif
  30
  31 #include "cffload.h"
  32 #include "cffparse.h"
  33
  34 #include "cfferrs.h"
  35
  36
  37 #define FT_FIXED_ONE  ( (FT_Fixed)0x10000 )
  38
  39
  40 #if 1
  41
  42   static const FT_UShort  cff_isoadobe_charset[229] =
  43   {
  44       0,   1,   2,   3,   4,   5,   6,   7,
  45       8,   9,  10,  11,  12,  13,  14,  15,
  46      16,  17,  18,  19,  20,  21,  22,  23,
  47      24,  25,  26,  27,  28,  29,  30,  31,
  48      32,  33,  34,  35,  36,  37,  38,  39,
  49      40,  41,  42,  43,  44,  45,  46,  47,
  50      48,  49,  50,  51,  52,  53,  54,  55,
  51      56,  57,  58,  59,  60,  61,  62,  63,
  52      64,  65,  66,  67,  68,  69,  70,  71,
  53      72,  73,  74,  75,  76,  77,  78,  79,
  54      80,  81,  82,  83,  84,  85,  86,  87,
  55      88,  89,  90,  91,  92,  93,  94,  95,
  56      96,  97,  98,  99, 100, 101, 102, 103,
  57     104, 105, 106, 107, 108, 109, 110, 111,
  58     112, 113, 114, 115, 116, 117, 118, 119,
  59     120, 121, 122, 123, 124, 125, 126, 127,
  60     128, 129, 130, 131, 132, 133, 134, 135,
  61     136, 137, 138, 139, 140, 141, 142, 143,
  62     144, 145, 146, 147, 148, 149, 150, 151,
  63     152, 153, 154, 155, 156, 157, 158, 159,
  64     160, 161, 162, 163, 164, 165, 166, 167,
  65     168, 169, 170, 171, 172, 173, 174, 175,
  66     176, 177, 178, 179, 180, 181, 182, 183,
  67     184, 185, 186, 187, 188, 189, 190, 191,
  68     192, 193, 194, 195, 196, 197, 198, 199,
  69     200, 201, 202, 203, 204, 205, 206, 207,
  70     208, 209, 210, 211, 212, 213, 214, 215,
  71     216, 217, 218, 219, 220, 221, 222, 223,
  72     224, 225, 226, 227, 228
  73   };
  74
  75   static const FT_UShort  cff_expert_charset[166] =
  76   {
  77       0,   1, 229, 230, 231, 232, 233, 234,
  78     235, 236, 237, 238,  13,  14,  15,  99,
  79     239, 240, 241, 242, 243, 244, 245, 246,
  80     247, 248,  27,  28, 249, 250, 251, 252,
  81     253, 254, 255, 256, 257, 258, 259, 260,
  82     261, 262, 263, 264, 265, 266, 109, 110,
  83     267, 268, 269, 270, 271, 272, 273, 274,
  84     275, 276, 277, 278, 279, 280, 281, 282,
  85     283, 284, 285, 286, 287, 288, 289, 290,
  86     291, 292, 293, 294, 295, 296, 297, 298,
  87     299, 300, 301, 302, 303, 304, 305, 306,
  88     307, 308, 309, 310, 311, 312, 313, 314,
  89     315, 316, 317, 318, 158, 155, 163, 319,
  90     320, 321, 322, 323, 324, 325, 326, 150,
  91     164, 169, 327, 328, 329, 330, 331, 332,
  92     333, 334, 335, 336, 337, 338, 339, 340,
  93     341, 342, 343, 344, 345, 346, 347, 348,
  94     349, 350, 351, 352, 353, 354, 355, 356,
  95     357, 358, 359, 360, 361, 362, 363, 364,
  96     365, 366, 367, 368, 369, 370, 371, 372,
  97     373, 374, 375, 376, 377, 378
  98   };
  99
 100   static const FT_UShort  cff_expertsubset_charset[87] =
 101   {
 102       0,   1, 231, 232, 235, 236, 237, 238,
 103      13,  14,  15,  99, 239, 240, 241, 242,
 104     243, 244, 245, 246, 247, 248,  27,  28,
 105     249, 250, 251, 253, 254, 255, 256, 257,
 106     258, 259, 260, 261, 262, 263, 264, 265,
 107     266, 109, 110, 267, 268, 269, 270, 272,
 108     300, 301, 302, 305, 314, 315, 158, 155,
 109     163, 320, 321, 322, 323, 324, 325, 326,
 110     150, 164, 169, 327, 328, 329, 330, 331,
 111     332, 333, 334, 335, 336, 337, 338, 339,
 112     340, 341, 342, 343, 344, 345, 346
 113   };
 114
 115   static const FT_UShort  cff_standard_encoding[256] =
 116   {
 117       0,   0,   0,   0,   0,   0,   0,   0,
 118       0,   0,   0,   0,   0,   0,   0,   0,
 119       0,   0,   0,   0,   0,   0,   0,   0,
 120       0,   0,   0,   0,   0,   0,   0,   0,
 121       1,   2,   3,   4,   5,   6,   7,   8,
 122       9,  10,  11,  12,  13,  14,  15,  16,
 123      17,  18,  19,  20,  21,  22,  23,  24,
 124      25,  26,  27,  28,  29,  30,  31,  32,
 125      33,  34,  35,  36,  37,  38,  39,  40,
 126      41,  42,  43,  44,  45,  46,  47,  48,
 127      49,  50,  51,  52,  53,  54,  55,  56,
 128      57,  58,  59,  60,  61,  62,  63,  64,
 129      65,  66,  67,  68,  69,  70,  71,  72,
 130      73,  74,  75,  76,  77,  78,  79,  80,
 131      81,  82,  83,  84,  85,  86,  87,  88,
 132      89,  90,  91,  92,  93,  94,  95,   0,
 133       0,   0,   0,   0,   0,   0,   0,   0,
 134       0,   0,   0,   0,   0,   0,   0,   0,
 135       0,   0,   0,   0,   0,   0,   0,   0,
 136       0,   0,   0,   0,   0,   0,   0,   0,
 137       0,  96,  97,  98,  99, 100, 101, 102,
 138     103, 104, 105, 106, 107, 108, 109, 110,
 139       0, 111, 112, 113, 114,   0, 115, 116,
 140     117, 118, 119, 120, 121, 122,   0, 123,
 141       0, 124, 125, 126, 127, 128, 129, 130,
 142     131,   0, 132, 133,   0, 134, 135, 136,
 143     137,   0,   0,   0,   0,   0,   0,   0,
 144       0,   0,   0,   0,   0,   0,   0,   0,
 145       0, 138,   0, 139,   0,   0,   0,   0,
 146     140, 141, 142, 143,   0,   0,   0,   0,
 147       0, 144,   0,   0,   0, 145,   0,   0,
 148     146, 147, 148, 149,   0,   0,   0,   0
 149   };
 150
 151   static const FT_UShort  cff_expert_encoding[256] =
 152   {
 153       0,   0,   0,   0,   0,   0,   0,   0,
 154       0,   0,   0,   0,   0,   0,   0,   0,
 155       0,   0,   0,   0,   0,   0,   0,   0,
 156       0,   0,   0,   0,   0,   0,   0,   0,
 157       1, 229, 230,   0, 231, 232, 233, 234,
 158     235, 236, 237, 238,  13,  14,  15,  99,
 159     239, 240, 241, 242, 243, 244, 245, 246,
 160     247, 248,  27,  28, 249, 250, 251, 252,
 161       0, 253, 254, 255, 256, 257,   0,   0,
 162       0, 258,   0,   0, 259, 260, 261, 262,
 163       0,   0, 263, 264, 265,   0, 266, 109,
 164     110, 267, 268, 269,   0, 270, 271, 272,
 165     273, 274, 275, 276, 277, 278, 279, 280,
 166     281, 282, 283, 284, 285, 286, 287, 288,
 167     289, 290, 291, 292, 293, 294, 295, 296,
 168     297, 298, 299, 300, 301, 302, 303,   0,
 169       0,   0,   0,   0,   0,   0,   0,   0,
 170       0,   0,   0,   0,   0,   0,   0,   0,
 171       0,   0,   0,   0,   0,   0,   0,   0,
 172       0,   0,   0,   0,   0,   0,   0,   0,
 173       0, 304, 305, 306,   0,   0, 307, 308,
 174     309, 310, 311,   0, 312,   0,   0, 312,
 175       0,   0, 314, 315,   0,   0, 316, 317,
 176     318,   0,   0,   0, 158, 155, 163, 319,
 177     320, 321, 322, 323, 324, 325,   0,   0,
 178     326, 150, 164, 169, 327, 328, 329, 330,
 179     331, 332, 333, 334, 335, 336, 337, 338,
 180     339, 340, 341, 342, 343, 344, 345, 346,
 181     347, 348, 349, 350, 351, 352, 353, 354,
 182     355, 356, 357, 358, 359, 360, 361, 362,
 183     363, 364, 365, 366, 367, 368, 369, 370,
 184     371, 372, 373, 374, 375, 376, 377, 378
 185   };
 186
 187 #endif /* 1 */
 188
 189
 190   FT_LOCAL_DEF( FT_UShort )
 191   cff_get_standard_encoding( FT_UInt  charcode )
 192   {
 193     return (FT_UShort)( charcode < 256 ? cff_standard_encoding[charcode]
 194                                        : 0 );
 195   }
 196
 197
 198   /**************************************************************************
 199    *
 200    * The macro FT_COMPONENT is used in trace mode.  It is an implicit
 201    * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
 202    * messages during execution.
 203    */
 204 #undef  FT_COMPONENT
 205 #define FT_COMPONENT  cffload
 206
 207
 208   /* read an offset from the index's stream current position */
 209   static FT_ULong
 210   cff_index_read_offset( CFF_Index  idx,
 211                          FT_Error  *errorp )
 212   {
 213     FT_Error   error;
 214     FT_Stream  stream = idx->stream;
 215     FT_Byte    tmp[4];
 216     FT_ULong   result = 0;
 217
 218
 219     if ( !FT_STREAM_READ( tmp, idx->off_size ) )
 220     {
 221       FT_Int  nn;
 222
 223
 224       for ( nn = 0; nn < idx->off_size; nn++ )
 225         result = ( result << 8 ) | tmp[nn];
 226     }
 227
 228     *errorp = error;
 229     return result;
 230   }
 231
 232
 233   static FT_Error
 234   cff_index_init( CFF_Index  idx,
 235                   FT_Stream  stream,
 236                   FT_Bool    load,
 237                   FT_Bool    cff2 )
 238   {
 239     FT_Error   error;
 240     FT_Memory  memory = stream->memory;
 241     FT_UInt    count;
 242
 243
 244     FT_ZERO( idx );
 245
 246     idx->stream = stream;
 247     idx->start  = FT_STREAM_POS();
 248
 249     if ( cff2 )
 250     {
 251       if ( FT_READ_ULONG( count ) )
 252         goto Exit;
 253       idx->hdr_size = 5;
 254     }
 255     else
 256     {
 257       if ( FT_READ_USHORT( count ) )
 258         goto Exit;
 259       idx->hdr_size = 3;
 260     }
 261
 262     if ( count > 0 )
 263     {
 264       FT_Byte   offsize;
 265       FT_ULong  size;
 266
 267
 268       /* there is at least one element; read the offset size,           */
 269       /* then access the offset table to compute the index's total size */
 270       if ( FT_READ_BYTE( offsize ) )
 271         goto Exit;
 272
 273       if ( offsize < 1 || offsize > 4 )
 274       {
 275         error = FT_THROW( Invalid_Table );
 276         goto Exit;
 277       }
 278
 279       idx->count    = count;
 280       idx->off_size = offsize;
 281       size          = (FT_ULong)( count + 1 ) * offsize;
 282
 283       idx->data_offset = idx->start + idx->hdr_size + size;
 284
 285       if ( FT_STREAM_SKIP( size - offsize ) )
 286         goto Exit;
 287
 288       size = cff_index_read_offset( idx, &error );
 289       if ( error )
 290         goto Exit;
 291
 292       if ( size == 0 )
 293       {
 294         error = FT_THROW( Invalid_Table );
 295         goto Exit;
 296       }
 297
 298       idx->data_size = --size;
 299
 300       if ( load )
 301       {
 302         /* load the data */
 303         if ( FT_FRAME_EXTRACT( size, idx->bytes ) )
 304           goto Exit;
 305       }
 306       else
 307       {
 308         /* skip the data */
 309         if ( FT_STREAM_SKIP( size ) )
 310           goto Exit;
 311       }
 312     }
 313
 314   Exit:
 315     if ( error )
 316       FT_FREE( idx->offsets );
 317
 318     return error;
 319   }
 320
 321
 322   static void
 323   cff_index_done( CFF_Index  idx )
 324   {
 325     if ( idx->stream )
 326     {
 327       FT_Stream  stream = idx->stream;
 328       FT_Memory  memory = stream->memory;
 329
 330
 331       if ( idx->bytes )
 332         FT_FRAME_RELEASE( idx->bytes );
 333
 334       FT_FREE( idx->offsets );
 335       FT_ZERO( idx );
 336     }
 337   }
 338
 339
 340   static FT_Error
 341   cff_index_load_offsets( CFF_Index  idx )
 342   {
 343     FT_Error   error  = FT_Err_Ok;
 344     FT_Stream  stream = idx->stream;
 345     FT_Memory  memory = stream->memory;
 346
 347
 348     if ( idx->count > 0 && !idx->offsets )
 349     {
 350       FT_Byte    offsize = idx->off_size;
 351       FT_ULong   data_size;
 352       FT_Byte*   p;
 353       FT_Byte*   p_end;
 354       FT_ULong*  poff;
 355
 356
 357       data_size = (FT_ULong)( idx->count + 1 ) * offsize;
 358
 359       if ( FT_QNEW_ARRAY( idx->offsets, idx->count + 1 ) ||
 360            FT_STREAM_SEEK( idx->start + idx->hdr_size )  ||
 361            FT_FRAME_ENTER( data_size )                   )
 362         goto Exit;
 363
 364       poff   = idx->offsets;
 365       p      = (FT_Byte*)stream->cursor;
 366       p_end  = p + data_size;
 367
 368       switch ( offsize )
 369       {
 370       case 1:
 371         for ( ; p < p_end; p++, poff++ )
 372           poff[0] = p[0];
 373         break;
 374
 375       case 2:
 376         for ( ; p < p_end; p += 2, poff++ )
 377           poff[0] = FT_PEEK_USHORT( p );
 378         break;
 379
 380       case 3:
 381         for ( ; p < p_end; p += 3, poff++ )
 382           poff[0] = FT_PEEK_UOFF3( p );
 383         break;
 384
 385       default:
 386         for ( ; p < p_end; p += 4, poff++ )
 387           poff[0] = FT_PEEK_ULONG( p );
 388       }
 389
 390       FT_FRAME_EXIT();
 391     }
 392
 393   Exit:
 394     if ( error )
 395       FT_FREE( idx->offsets );
 396
 397     return error;
 398   }
 399
 400
 401   /* Allocate a table containing pointers to an index's elements. */
 402   /* The `pool' argument makes this function convert the index    */
 403   /* entries to C-style strings (that is, null-terminated).       */
 404   static FT_Error
 405   cff_index_get_pointers( CFF_Index   idx,
 406                           FT_Byte***  table,
 407                           FT_Byte**   pool,
 408                           FT_ULong*   pool_size )
 409   {
 410     FT_Error   error     = FT_Err_Ok;
 411     FT_Memory  memory    = idx->stream->memory;
 412
 413     FT_Byte**  tbl       = NULL;
 414     FT_Byte*   new_bytes = NULL;
 415     FT_ULong   new_size;
 416
 417
 418     *table = NULL;
 419
 420     if ( !idx->offsets )
 421     {
 422       error = cff_index_load_offsets( idx );
 423       if ( error )
 424         goto Exit;
 425     }
 426
 427     new_size = idx->data_size + idx->count;
 428
 429     if ( idx->count > 0                                &&
 430          !FT_QNEW_ARRAY( tbl, idx->count + 1 )         &&
 431          ( !pool || !FT_ALLOC( new_bytes, new_size ) ) )
 432     {
 433       FT_ULong  n, cur_offset;
 434       FT_ULong  extra     = 0;
 435       FT_Byte*  org_bytes = idx->bytes;
 436
 437
 438       /* at this point, `idx->offsets' can't be NULL */
 439       cur_offset = idx->offsets[0] - 1;
 440
 441       /* sanity check */
 442       if ( cur_offset != 0 )
 443       {
 444         FT_TRACE0(( "cff_index_get_pointers:"
 445                     " invalid first offset value %ld set to zero\n",
 446                     cur_offset ));
 447         cur_offset = 0;
 448       }
 449
 450       if ( !pool )
 451         tbl[0] = org_bytes + cur_offset;
 452       else
 453         tbl[0] = new_bytes + cur_offset;
 454
 455       for ( n = 1; n <= idx->count; n++ )
 456       {
 457         FT_ULong  next_offset = idx->offsets[n] - 1;
 458
 459
 460         /* two sanity checks for invalid offset tables */
 461         if ( next_offset < cur_offset )
 462           next_offset = cur_offset;
 463         else if ( next_offset > idx->data_size )
 464           next_offset = idx->data_size;
 465
 466         if ( !pool )
 467           tbl[n] = org_bytes + next_offset;
 468         else
 469         {
 470           tbl[n] = new_bytes + next_offset + extra;
 471
 472           if ( next_offset != cur_offset )
 473           {
 474             FT_MEM_COPY( tbl[n - 1],
 475                          org_bytes + cur_offset,
 476                          tbl[n] - tbl[n - 1] );
 477             tbl[n][0] = '\0';
 478             tbl[n]   += 1;
 479             extra++;
 480           }
 481         }
 482
 483         cur_offset = next_offset;
 484       }
 485       *table = tbl;
 486
 487       if ( pool )
 488         *pool = new_bytes;
 489       if ( pool_size )
 490         *pool_size = new_size;
 491     }
 492
 493   Exit:
 494     if ( error && new_bytes )
 495       FT_FREE( new_bytes );
 496     if ( error && tbl )
 497       FT_FREE( tbl );
 498
 499     return error;
 500   }
 501
 502
 503   FT_LOCAL_DEF( FT_Error )
 504   cff_index_access_element( CFF_Index  idx,
 505                             FT_UInt    element,
 506                             FT_Byte**  pbytes,
 507                             FT_ULong*  pbyte_len )
 508   {
 509     FT_Error  error = FT_Err_Ok;
 510
 511
 512     if ( idx && idx->count > element )
 513     {
 514       /* compute start and end offsets */
 515       FT_Stream  stream = idx->stream;
 516       FT_ULong   off1, off2 = 0;
 517
 518
 519       /* load offsets from file or the offset table */
 520       if ( !idx->offsets )
 521       {
 522         FT_ULong  pos = element * idx->off_size;
 523
 524
 525         if ( FT_STREAM_SEEK( idx->start + idx->hdr_size + pos ) )
 526           goto Exit;
 527
 528         off1 = cff_index_read_offset( idx, &error );
 529         if ( error )
 530           goto Exit;
 531
 532         if ( off1 != 0 )
 533         {
 534           do
 535           {
 536             element++;
 537             off2 = cff_index_read_offset( idx, &error );
 538
 539           } while ( off2 == 0 && element < idx->count );
 540         }
 541       }
 542       else   /* use offsets table */
 543       {
 544         off1 = idx->offsets[element];
 545         if ( off1 )
 546         {
 547           do
 548           {
 549             element++;
 550             off2 = idx->offsets[element];
 551
 552           } while ( off2 == 0 && element < idx->count );
 553         }
 554       }
 555
 556       /* XXX: should check off2 does not exceed the end of this entry; */
 557       /*      at present, only truncate off2 at the end of this stream */
 558       if ( off2 > stream->size + 1                    ||
 559            idx->data_offset > stream->size - off2 + 1 )
 560       {
 561         FT_ERROR(( "cff_index_access_element:"
 562                    " offset to next entry (%ld)"
 563                    " exceeds the end of stream (%ld)\n",
 564                    off2, stream->size - idx->data_offset + 1 ));
 565         off2 = stream->size - idx->data_offset + 1;
 566       }
 567
 568       /* access element */
 569       if ( off1 && off2 > off1 )
 570       {
 571         *pbyte_len = off2 - off1;
 572
 573         if ( idx->bytes )
 574         {
 575           /* this index was completely loaded in memory, that's easy */
 576           *pbytes = idx->bytes + off1 - 1;
 577         }
 578         else
 579         {
 580           /* this index is still on disk/file, access it through a frame */
 581           if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
 582                FT_FRAME_EXTRACT( off2 - off1, *pbytes )      )
 583             goto Exit;
 584         }
 585       }
 586       else
 587       {
 588         /* empty index element */
 589         *pbytes    = 0;
 590         *pbyte_len = 0;
 591       }
 592     }
 593     else
 594       error = FT_THROW( Invalid_Argument );
 595
 596   Exit:
 597     return error;
 598   }
 599
 600
 601   FT_LOCAL_DEF( void )
 602   cff_index_forget_element( CFF_Index  idx,
 603                             FT_Byte**  pbytes )
 604   {
 605     if ( idx->bytes == 0 )
 606     {
 607       FT_Stream  stream = idx->stream;
 608
 609
 610       FT_FRAME_RELEASE( *pbytes );
 611     }
 612   }
 613
 614
 615   /* get an entry from Name INDEX */
 616   FT_LOCAL_DEF( FT_String* )
 617   cff_index_get_name( CFF_Font  font,
 618                       FT_UInt   element )
 619   {
 620     CFF_Index   idx = &font->name_index;
 621     FT_Memory   memory;
 622     FT_Byte*    bytes;
 623     FT_ULong    byte_len;
 624     FT_Error    error;
 625     FT_String*  name = NULL;
 626
 627
 628     if ( !idx->stream )  /* CFF2 does not include a name index */
 629       goto Exit;
 630
 631     memory = idx->stream->memory;
 632
 633     error = cff_index_access_element( idx, element, &bytes, &byte_len );
 634     if ( error )
 635       goto Exit;
 636
 637     if ( !FT_QALLOC( name, byte_len + 1 ) )
 638     {
 639       FT_MEM_COPY( name, bytes, byte_len );
 640       name[byte_len] = 0;
 641     }
 642     cff_index_forget_element( idx, &bytes );
 643
 644   Exit:
 645     return name;
 646   }
 647
 648
 649   /* get an entry from String INDEX */
 650   FT_LOCAL_DEF( FT_String* )
 651   cff_index_get_string( CFF_Font  font,
 652                         FT_UInt   element )
 653   {
 654     return ( element < font->num_strings )
 655              ? (FT_String*)font->strings[element]
 656              : NULL;
 657   }
 658
 659
 660   FT_LOCAL_DEF( FT_String* )
 661   cff_index_get_sid_string( CFF_Font  font,
 662                             FT_UInt   sid )
 663   {
 664     /* value 0xFFFFU indicates a missing dictionary entry */
 665     if ( sid == 0xFFFFU )
 666       return NULL;
 667
 668     /* if it is not a standard string, return it */
 669     if ( sid > 390 )
 670       return cff_index_get_string( font, sid - 391 );
 671
 672     /* CID-keyed CFF fonts don't have glyph names */
 673     if ( !font->psnames )
 674       return NULL;
 675
 676     /* this is a standard string */
 677     return (FT_String *)font->psnames->adobe_std_strings( sid );
 678   }
 679
 680
 681   /*************************************************************************/
 682   /*************************************************************************/
 683   /***                                                                   ***/
 684   /***   FD Select table support                                         ***/
 685   /***                                                                   ***/
 686   /*************************************************************************/
 687   /*************************************************************************/
 688
 689
 690   static void
 691   CFF_Done_FD_Select( CFF_FDSelect  fdselect,
 692                       FT_Stream     stream )
 693   {
 694     if ( fdselect->data )
 695       FT_FRAME_RELEASE( fdselect->data );
 696
 697     fdselect->data_size   = 0;
 698     fdselect->format      = 0;
 699     fdselect->range_count = 0;
 700   }
 701
 702
 703   static FT_Error
 704   CFF_Load_FD_Select( CFF_FDSelect  fdselect,
 705                       FT_UInt       num_glyphs,
 706                       FT_Stream     stream,
 707                       FT_ULong      offset )
 708   {
 709     FT_Error  error;
 710     FT_Byte   format;
 711     FT_UInt   num_ranges;
 712
 713
 714     /* read format */
 715     if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) )
 716       goto Exit;
 717
 718     fdselect->format      = format;
 719     fdselect->cache_count = 0;   /* clear cache */
 720
 721     switch ( format )
 722     {
 723     case 0:     /* format 0, that's simple */
 724       fdselect->data_size = num_glyphs;
 725       goto Load_Data;
 726
 727     case 3:     /* format 3, a tad more complex */
 728       if ( FT_READ_USHORT( num_ranges ) )
 729         goto Exit;
 730
 731       if ( !num_ranges )
 732       {
 733         FT_TRACE0(( "CFF_Load_FD_Select: empty FDSelect array\n" ));
 734         error = FT_THROW( Invalid_File_Format );
 735         goto Exit;
 736       }
 737
 738       fdselect->data_size = num_ranges * 3 + 2;
 739
 740     Load_Data:
 741       if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) )
 742         goto Exit;
 743       break;
 744
 745     default:    /* hmm... that's wrong */
 746       error = FT_THROW( Invalid_File_Format );
 747     }
 748
 749   Exit:
 750     return error;
 751   }
 752
 753
 754   FT_LOCAL_DEF( FT_Byte )
 755   cff_fd_select_get( CFF_FDSelect  fdselect,
 756                      FT_UInt       glyph_index )
 757   {
 758     FT_Byte  fd = 0;
 759
 760
 761     /* if there is no FDSelect, return zero               */
 762     /* Note: CFF2 with just one Font Dict has no FDSelect */
 763     if ( !fdselect->data )
 764       goto Exit;
 765
 766     switch ( fdselect->format )
 767     {
 768     case 0:
 769       fd = fdselect->data[glyph_index];
 770       break;
 771
 772     case 3:
 773       /* first, compare to the cache */
 774       if ( glyph_index - fdselect->cache_first < fdselect->cache_count )
 775       {
 776         fd = fdselect->cache_fd;
 777         break;
 778       }
 779
 780       /* then, look up the ranges array */
 781       {
 782         FT_Byte*  p       = fdselect->data;
 783         FT_Byte*  p_limit = p + fdselect->data_size;
 784         FT_Byte   fd2;
 785         FT_UInt   first, limit;
 786
 787
 788         first = FT_NEXT_USHORT( p );
 789         do
 790         {
 791           if ( glyph_index < first )
 792             break;
 793
 794           fd2   = *p++;
 795           limit = FT_NEXT_USHORT( p );
 796
 797           if ( glyph_index < limit )
 798           {
 799             fd = fd2;
 800
 801             /* update cache */
 802             fdselect->cache_first = first;
 803             fdselect->cache_count = limit - first;
 804             fdselect->cache_fd    = fd2;
 805             break;
 806           }
 807           first = limit;
 808
 809         } while ( p < p_limit );
 810       }
 811       break;
 812
 813     default:
 814       ;
 815     }
 816
 817   Exit:
 818     return fd;
 819   }
 820
 821
 822   /*************************************************************************/
 823   /*************************************************************************/
 824   /***                                                                   ***/
 825   /***   CFF font support                                                ***/
 826   /***                                                                   ***/
 827   /*************************************************************************/
 828   /*************************************************************************/
 829
 830   static FT_Error
 831   cff_charset_compute_cids( CFF_Charset  charset,
 832                             FT_UInt      num_glyphs,
 833                             FT_Memory    memory )
 834   {
 835     FT_Error   error   = FT_Err_Ok;
 836     FT_UInt    i;
 837     FT_UShort  max_cid = 0;
 838
 839
 840     if ( charset->max_cid > 0 )
 841       goto Exit;
 842
 843     for ( i = 0; i < num_glyphs; i++ )
 844     {
 845       if ( charset->sids[i] > max_cid )
 846         max_cid = charset->sids[i];
 847     }
 848
 849     if ( FT_NEW_ARRAY( charset->cids, (FT_ULong)max_cid + 1 ) )
 850       goto Exit;
 851
 852     /* When multiple GIDs map to the same CID, we choose the lowest */
 853     /* GID.  This is not described in any spec, but it matches the  */
 854     /* behaviour of recent Acroread versions.  The loop stops when  */
 855     /* the unsigned index wraps around after reaching zero.         */
 856     for ( i = num_glyphs - 1; i < num_glyphs; i-- )
 857       charset->cids[charset->sids[i]] = (FT_UShort)i;
 858
 859     charset->max_cid    = max_cid;
 860     charset->num_glyphs = num_glyphs;
 861
 862   Exit:
 863     return error;
 864   }
 865
 866
 867   FT_LOCAL_DEF( FT_UInt )
 868   cff_charset_cid_to_gindex( CFF_Charset  charset,
 869                              FT_UInt      cid )
 870   {
 871     FT_UInt  result = 0;
 872
 873
 874     if ( cid <= charset->max_cid )
 875       result = charset->cids[cid];
 876
 877     return result;
 878   }
 879
 880
 881   static void
 882   cff_charset_free_cids( CFF_Charset  charset,
 883                          FT_Memory    memory )
 884   {
 885     FT_FREE( charset->cids );
 886     charset->max_cid = 0;
 887   }
 888
 889
 890   static void
 891   cff_charset_done( CFF_Charset  charset,
 892                     FT_Stream    stream )
 893   {
 894     FT_Memory  memory = stream->memory;
 895
 896
 897     cff_charset_free_cids( charset, memory );
 898
 899     FT_FREE( charset->sids );
 900     charset->format = 0;
 901     charset->offset = 0;
 902   }
 903
 904
 905   static FT_Error
 906   cff_charset_load( CFF_Charset  charset,
 907                     FT_UInt      num_glyphs,
 908                     FT_Stream    stream,
 909                     FT_ULong     base_offset,
 910                     FT_ULong     offset,
 911                     FT_Bool      invert )
 912   {
 913     FT_Memory  memory = stream->memory;
 914     FT_Error   error  = FT_Err_Ok;
 915     FT_UShort  glyph_sid;
 916
 917
 918     /* If the offset is greater than 2, we have to parse the charset */
 919     /* table.                                                        */
 920     if ( offset > 2 )
 921     {
 922       FT_UInt  j;
 923
 924
 925       charset->offset = base_offset + offset;
 926
 927       /* Get the format of the table. */
 928       if ( FT_STREAM_SEEK( charset->offset ) ||
 929            FT_READ_BYTE( charset->format )   )
 930         goto Exit;
 931
 932       /* Allocate memory for sids. */
 933       if ( FT_QNEW_ARRAY( charset->sids, num_glyphs ) )
 934         goto Exit;
 935
 936       /* assign the .notdef glyph */
 937       charset->sids[0] = 0;
 938
 939       switch ( charset->format )
 940       {
 941       case 0:
 942         if ( num_glyphs > 0 )
 943         {
 944           if ( FT_FRAME_ENTER( ( num_glyphs - 1 ) * 2 ) )
 945             goto Exit;
 946
 947           for ( j = 1; j < num_glyphs; j++ )
 948             charset->sids[j] = FT_GET_USHORT();
 949
 950           FT_FRAME_EXIT();
 951         }
 952         break;
 953
 954       case 1:
 955       case 2:
 956         {
 957           FT_UInt  nleft;
 958           FT_UInt  i;
 959
 960
 961           j = 1;
 962
 963           while ( j < num_glyphs )
 964           {
 965             /* Read the first glyph sid of the range. */
 966             if ( FT_READ_USHORT( glyph_sid ) )
 967               goto Exit;
 968
 969             /* Read the number of glyphs in the range.  */
 970             if ( charset->format == 2 )
 971             {
 972               if ( FT_READ_USHORT( nleft ) )
 973                 goto Exit;
 974             }
 975             else
 976             {
 977               if ( FT_READ_BYTE( nleft ) )
 978                 goto Exit;
 979             }
 980
 981             /* try to rescue some of the SIDs if `nleft' is too large */
 982             if ( glyph_sid > 0xFFFFL - nleft )
 983             {
 984               FT_ERROR(( "cff_charset_load: invalid SID range trimmed"
 985                          " nleft=%d -> %ld\n", nleft, 0xFFFFL - glyph_sid ));
 986               nleft = ( FT_UInt )( 0xFFFFL - glyph_sid );
 987             }
 988
 989             /* Fill in the range of sids -- `nleft + 1' glyphs. */
 990             for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
 991               charset->sids[j] = glyph_sid;
 992           }
 993         }
 994         break;
 995
 996       default:
 997         FT_ERROR(( "cff_charset_load: invalid table format\n" ));
 998         error = FT_THROW( Invalid_File_Format );
 999         goto Exit;
1000       }
1001     }
1002     else
1003     {
1004       /* Parse default tables corresponding to offset == 0, 1, or 2.  */
1005       /* CFF specification intimates the following:                   */
1006       /*                                                              */
1007       /* In order to use a predefined charset, the following must be  */
1008       /* true: The charset constructed for the glyphs in the font's   */
1009       /* charstrings dictionary must match the predefined charset in  */
1010       /* the first num_glyphs.                                        */
1011
1012       charset->offset = offset;  /* record charset type */
1013
1014       switch ( (FT_UInt)offset )
1015       {
1016       case 0:
1017         if ( num_glyphs > 229 )
1018         {
1019           FT_ERROR(( "cff_charset_load: implicit charset larger than\n" ));
1020           FT_ERROR(( "predefined charset (Adobe ISO-Latin)\n" ));
1021           error = FT_THROW( Invalid_File_Format );
1022           goto Exit;
1023         }
1024
1025         /* Allocate memory for sids. */
1026         if ( FT_QNEW_ARRAY( charset->sids, num_glyphs ) )
1027           goto Exit;
1028
1029         /* Copy the predefined charset into the allocated memory. */
1030         FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs );
1031
1032         break;
1033
1034       case 1:
1035         if ( num_glyphs > 166 )
1036         {
1037           FT_ERROR(( "cff_charset_load: implicit charset larger than\n" ));
1038           FT_ERROR(( "predefined charset (Adobe Expert)\n" ));
1039           error = FT_THROW( Invalid_File_Format );
1040           goto Exit;
1041         }
1042
1043         /* Allocate memory for sids. */
1044         if ( FT_QNEW_ARRAY( charset->sids, num_glyphs ) )
1045           goto Exit;
1046
1047         /* Copy the predefined charset into the allocated memory.     */
1048         FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs );
1049
1050         break;
1051
1052       case 2:
1053         if ( num_glyphs > 87 )
1054         {
1055           FT_ERROR(( "cff_charset_load: implicit charset larger than\n" ));
1056           FT_ERROR(( "predefined charset (Adobe Expert Subset)\n" ));
1057           error = FT_THROW( Invalid_File_Format );
1058           goto Exit;
1059         }
1060
1061         /* Allocate memory for sids. */
1062         if ( FT_QNEW_ARRAY( charset->sids, num_glyphs ) )
1063           goto Exit;
1064
1065         /* Copy the predefined charset into the allocated memory.     */
1066         FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs );
1067
1068         break;
1069
1070       default:
1071         error = FT_THROW( Invalid_File_Format );
1072         goto Exit;
1073       }
1074     }
1075
1076     /* we have to invert the `sids' array for subsetted CID-keyed fonts */
1077     if ( invert )
1078       error = cff_charset_compute_cids( charset, num_glyphs, memory );
1079
1080   Exit:
1081     /* Clean up if there was an error. */
1082     if ( error )
1083     {
1084       FT_FREE( charset->sids );
1085       FT_FREE( charset->cids );
1086       charset->format = 0;
1087       charset->offset = 0;
1088     }
1089
1090     return error;
1091   }
1092
1093
1094   static void
1095   cff_vstore_done( CFF_VStoreRec*  vstore,
1096                    FT_Memory       memory )
1097   {
1098     FT_UInt  i;
1099
1100
1101     /* free regionList and axisLists */
1102     if ( vstore->varRegionList )
1103     {
1104       for ( i = 0; i < vstore->regionCount; i++ )
1105         FT_FREE( vstore->varRegionList[i].axisList );
1106     }
1107     FT_FREE( vstore->varRegionList );
1108
1109     /* free varData and indices */
1110     if ( vstore->varData )
1111     {
1112       for ( i = 0; i < vstore->dataCount; i++ )
1113         FT_FREE( vstore->varData[i].regionIndices );
1114     }
1115     FT_FREE( vstore->varData );
1116   }
1117
1118
1119   /* convert 2.14 to Fixed */
1120   #define FT_fdot14ToFixed( x )  ( (FT_Fixed)( (FT_ULong)(x) << 2 ) )
1121
1122
1123   static FT_Error
1124   cff_vstore_load( CFF_VStoreRec*  vstore,
1125                    FT_Stream       stream,
1126                    FT_ULong        base_offset,
1127                    FT_ULong        offset )
1128   {
1129     FT_Memory  memory = stream->memory;
1130     FT_Error   error  = FT_ERR( Invalid_File_Format );
1131
1132     FT_ULong*  dataOffsetArray = NULL;
1133     FT_UInt    i, j;
1134
1135
1136     /* no offset means no vstore to parse */
1137     if ( offset )
1138     {
1139       FT_UInt   vsOffset;
1140       FT_UInt   format;
1141       FT_UInt   dataCount;
1142       FT_UInt   regionCount;
1143       FT_ULong  regionListOffset;
1144
1145
1146       /* we need to parse the table to determine its size; */
1147       /* skip table length                                 */
1148       if ( FT_STREAM_SEEK( base_offset + offset ) ||
1149            FT_STREAM_SKIP( 2 )                    )
1150         goto Exit;
1151
1152       /* actual variation store begins after the length */
1153       vsOffset = FT_STREAM_POS();
1154
1155       /* check the header */
1156       if ( FT_READ_USHORT( format ) )
1157         goto Exit;
1158       if ( format != 1 )
1159       {
1160         error = FT_THROW( Invalid_File_Format );
1161         goto Exit;
1162       }
1163
1164       /* read top level fields */
1165       if ( FT_READ_ULONG( regionListOffset ) ||
1166            FT_READ_USHORT( dataCount )       )
1167         goto Exit;
1168
1169       /* make temporary copy of item variation data offsets; */
1170       /* we'll parse region list first, then come back       */
1171       if ( FT_QNEW_ARRAY( dataOffsetArray, dataCount ) )
1172         goto Exit;
1173
1174       for ( i = 0; i < dataCount; i++ )
1175       {
1176         if ( FT_READ_ULONG( dataOffsetArray[i] ) )
1177           goto Exit;
1178       }
1179
1180       /* parse regionList and axisLists */
1181       if ( FT_STREAM_SEEK( vsOffset + regionListOffset ) ||
1182            FT_READ_USHORT( vstore->axisCount )           ||
1183            FT_READ_USHORT( regionCount )                 )
1184         goto Exit;
1185
1186       vstore->regionCount = 0;
1187       if ( FT_QNEW_ARRAY( vstore->varRegionList, regionCount ) )
1188         goto Exit;
1189
1190       for ( i = 0; i < regionCount; i++ )
1191       {
1192         CFF_VarRegion*  region = &vstore->varRegionList[i];
1193
1194
1195         if ( FT_QNEW_ARRAY( region->axisList, vstore->axisCount ) )
1196           goto Exit;
1197
1198         /* keep track of how many axisList to deallocate on error */
1199         vstore->regionCount++;
1200
1201         for ( j = 0; j < vstore->axisCount; j++ )
1202         {
1203           CFF_AxisCoords*  axis = &region->axisList[j];
1204
1205           FT_Int16  start14, peak14, end14;
1206
1207
1208           if ( FT_READ_SHORT( start14 ) ||
1209                FT_READ_SHORT( peak14 )  ||
1210                FT_READ_SHORT( end14 )   )
1211             goto Exit;
1212
1213           axis->startCoord = FT_fdot14ToFixed( start14 );
1214           axis->peakCoord  = FT_fdot14ToFixed( peak14 );
1215           axis->endCoord   = FT_fdot14ToFixed( end14 );
1216         }
1217       }
1218
1219       /* use dataOffsetArray now to parse varData items */
1220       vstore->dataCount = 0;
1221       if ( FT_QNEW_ARRAY( vstore->varData, dataCount ) )
1222         goto Exit;
1223
1224       for ( i = 0; i < dataCount; i++ )
1225       {
1226         CFF_VarData*  data = &vstore->varData[i];
1227
1228
1229         if ( FT_STREAM_SEEK( vsOffset + dataOffsetArray[i] ) )
1230           goto Exit;
1231
1232         /* ignore `itemCount' and `shortDeltaCount' */
1233         /* because CFF2 has no delta sets           */
1234         if ( FT_STREAM_SKIP( 4 ) )
1235           goto Exit;
1236
1237         /* Note: just record values; consistency is checked later    */
1238         /*       by cff_blend_build_vector when it consumes `vstore' */
1239
1240         if ( FT_READ_USHORT( data->regionIdxCount ) )
1241           goto Exit;
1242
1243         if ( FT_QNEW_ARRAY( data->regionIndices, data->regionIdxCount ) )
1244           goto Exit;
1245
1246         /* keep track of how many regionIndices to deallocate on error */
1247         vstore->dataCount++;
1248
1249         for ( j = 0; j < data->regionIdxCount; j++ )
1250         {
1251           if ( FT_READ_USHORT( data->regionIndices[j] ) )
1252             goto Exit;
1253         }
1254       }
1255     }
1256
1257     error = FT_Err_Ok;
1258
1259   Exit:
1260     FT_FREE( dataOffsetArray );
1261     if ( error )
1262       cff_vstore_done( vstore, memory );
1263
1264     return error;
1265   }
1266
1267
1268   /* Clear blend stack (after blend values are consumed). */
1269   /*                                                      */
1270   /* TODO: Should do this in cff_run_parse, but subFont   */
1271   /*       ref is not available there.                    */
1272   /*                                                      */
1273   /* Allocation is not changed when stack is cleared.     */
1274   FT_LOCAL_DEF( void )
1275   cff_blend_clear( CFF_SubFont  subFont )
1276   {
1277     subFont->blend_top  = subFont->blend_stack;
1278     subFont->blend_used = 0;
1279   }
1280
1281
1282   /* Blend numOperands on the stack,                       */
1283   /* store results into the first numBlends values,        */
1284   /* then pop remaining arguments.                         */
1285   /*                                                       */
1286   /* This is comparable to `cf2_doBlend' but               */
1287   /* the cffparse stack is different and can't be written. */
1288   /* Blended values are written to a different buffer,     */
1289   /* using reserved operator 255.                          */
1290   /*                                                       */
1291   /* Blend calculation is done in 16.16 fixed-point.       */
1292   FT_LOCAL_DEF( FT_Error )
1293   cff_blend_doBlend( CFF_SubFont  subFont,
1294                      CFF_Parser   parser,
1295                      FT_UInt      numBlends )
1296   {
1297     FT_UInt  delta;
1298     FT_UInt  base;
1299     FT_UInt  i, j;
1300     FT_UInt  size;
1301
1302     CFF_Blend  blend = &subFont->blend;
1303
1304     FT_Memory  memory = subFont->blend.font->memory; /* for FT_REALLOC */
1305     FT_Error   error  = FT_Err_Ok;                   /* for FT_REALLOC */
1306
1307     /* compute expected number of operands for this blend */
1308     FT_UInt  numOperands = (FT_UInt)( numBlends * blend->lenBV );
1309     FT_UInt  count       = (FT_UInt)( parser->top - 1 - parser->stack );
1310
1311
1312     if ( numOperands > count )
1313     {
1314       FT_TRACE4(( " cff_blend_doBlend: Stack underflow %d argument%s\n",
1315                   count,
1316                   count == 1 ? "" : "s" ));
1317
1318       error = FT_THROW( Stack_Underflow );
1319       goto Exit;
1320     }
1321
1322     /* check whether we have room for `numBlends' values at `blend_top' */
1323     size = 5 * numBlends;           /* add 5 bytes per entry    */
1324     if ( subFont->blend_used + size > subFont->blend_alloc )
1325     {
1326       FT_Byte*  blend_stack_old = subFont->blend_stack;
1327       FT_Byte*  blend_top_old   = subFont->blend_top;
1328
1329
1330       /* increase or allocate `blend_stack' and reset `blend_top'; */
1331       /* prepare to append `numBlends' values to the buffer        */
1332       if ( FT_QREALLOC( subFont->blend_stack,
1333                         subFont->blend_alloc,
1334                         subFont->blend_alloc + size ) )
1335         goto Exit;
1336
1337       subFont->blend_top    = subFont->blend_stack + subFont->blend_used;
1338       subFont->blend_alloc += size;
1339
1340       /* iterate over the parser stack and adjust pointers */
1341       /* if the reallocated buffer has a different address */
1342       if ( blend_stack_old                         &&
1343            subFont->blend_stack != blend_stack_old )
1344       {
1345         FT_PtrDist  offset = subFont->blend_stack - blend_stack_old;
1346         FT_Byte**   p;
1347
1348
1349         for ( p = parser->stack; p < parser->top; p++ )
1350         {
1351           if ( *p >= blend_stack_old && *p < blend_top_old )
1352             *p += offset;
1353         }
1354       }
1355     }
1356     subFont->blend_used += size;
1357
1358     base  = count - numOperands;     /* index of first blend arg */
1359     delta = base + numBlends;        /* index of first delta arg */
1360
1361     for ( i = 0; i < numBlends; i++ )
1362     {
1363       const FT_Int32*  weight = &blend->BV[1];
1364       FT_Fixed         sum;
1365
1366
1367       /* convert inputs to 16.16 fixed point */
1368       sum = cff_parse_fixed( parser, &parser->stack[i + base] );
1369
1370       for ( j = 1; j < blend->lenBV; j++ )
1371         sum += FT_MulFix( cff_parse_fixed( parser, &parser->stack[delta++] ),
1372                           *weight++ );
1373
1374       /* point parser stack to new value on blend_stack */
1375       parser->stack[i + base] = subFont->blend_top;
1376
1377       /* Push blended result as Type 2 5-byte fixed-point number.  This */
1378       /* will not conflict with actual DICTs because 255 is a reserved  */
1379       /* opcode in both CFF and CFF2 DICTs.  See `cff_parse_num' for    */
1380       /* decode of this, which rounds to an integer.                    */
1381       *subFont->blend_top++ = 255;
1382       *subFont->blend_top++ = (FT_Byte)( sum >> 24 );
1383       *subFont->blend_top++ = (FT_Byte)( sum >> 16 );
1384       *subFont->blend_top++ = (FT_Byte)( sum >>  8 );
1385       *subFont->blend_top++ = (FT_Byte)sum;
1386     }
1387
1388     /* leave only numBlends results on parser stack */
1389     parser->top = &parser->stack[base + numBlends];
1390
1391   Exit:
1392     return error;
1393   }
1394
1395
1396   /* Compute a blend vector from variation store index and normalized  */
1397   /* vector based on pseudo-code in OpenType Font Variations Overview. */
1398   /*                                                                   */
1399   /* Note: lenNDV == 0 produces a default blend vector, (1,0,0,...).   */
1400   FT_LOCAL_DEF( FT_Error )
1401   cff_blend_build_vector( CFF_Blend  blend,
1402                           FT_UInt    vsindex,
1403                           FT_UInt    lenNDV,
1404                           FT_Fixed*  NDV )
1405   {
1406     FT_Error   error  = FT_Err_Ok;            /* for FT_REALLOC */
1407     FT_Memory  memory = blend->font->memory;  /* for FT_REALLOC */
1408
1409     FT_UInt       len;
1410     CFF_VStore    vs;
1411     CFF_VarData*  varData;
1412     FT_UInt       master;
1413
1414
1415     /* protect against malformed fonts */
1416     if ( !( lenNDV == 0 || NDV ) )
1417     {
1418       FT_TRACE4(( " cff_blend_build_vector:"
1419                   " Malformed Normalize Design Vector data\n" ));
1420       error = FT_THROW( Invalid_File_Format );
1421       goto Exit;
1422     }
1423
1424     blend->builtBV = FALSE;
1425
1426     vs = &blend->font->vstore;
1427
1428     /* VStore and fvar must be consistent */
1429     if ( lenNDV != 0 && lenNDV != vs->axisCount )
1430     {
1431       FT_TRACE4(( " cff_blend_build_vector: Axis count mismatch\n" ));
1432       error = FT_THROW( Invalid_File_Format );
1433       goto Exit;
1434     }
1435
1436     if ( vsindex >= vs->dataCount )
1437     {
1438       FT_TRACE4(( " cff_blend_build_vector: vsindex out of range\n" ));
1439       error = FT_THROW( Invalid_File_Format );
1440       goto Exit;
1441     }
1442
1443     /* select the item variation data structure */
1444     varData = &vs->varData[vsindex];
1445
1446     /* prepare buffer for the blend vector */
1447     len = varData->regionIdxCount + 1;    /* add 1 for default component */
1448     if ( FT_QRENEW_ARRAY( blend->BV, blend->lenBV, len ) )
1449       goto Exit;
1450
1451     blend->lenBV = len;
1452
1453     /* outer loop steps through master designs to be blended */
1454     for ( master = 0; master < len; master++ )
1455     {
1456       FT_UInt         j;
1457       FT_UInt         idx;
1458       CFF_VarRegion*  varRegion;
1459
1460
1461       /* default factor is always one */
1462       if ( master == 0 )
1463       {
1464         blend->BV[master] = FT_FIXED_ONE;
1465         FT_TRACE4(( "   build blend vector len %d\n", len ));
1466         FT_TRACE4(( "   [ %f ", blend->BV[master] / 65536.0 ));
1467         continue;
1468       }
1469
1470       /* VStore array does not include default master, so subtract one */
1471       idx       = varData->regionIndices[master - 1];
1472       varRegion = &vs->varRegionList[idx];
1473
1474       if ( idx >= vs->regionCount )
1475       {
1476         FT_TRACE4(( " cff_blend_build_vector:"
1477                     " region index out of range\n" ));
1478         error = FT_THROW( Invalid_File_Format );
1479         goto Exit;
1480       }
1481
1482       /* Note: `lenNDV' could be zero.                              */
1483       /*       In that case, build default blend vector (1,0,0...). */
1484       if ( !lenNDV )
1485       {
1486         blend->BV[master] = 0;
1487         continue;
1488       }
1489
1490       /* In the normal case, initialize each component to 1 */
1491       /* before inner loop.                                 */
1492       blend->BV[master] = FT_FIXED_ONE; /* default */
1493
1494       /* inner loop steps through axes in this region */
1495       for ( j = 0; j < lenNDV; j++ )
1496       {
1497         CFF_AxisCoords*  axis = &varRegion->axisList[j];
1498         FT_Fixed         axisScalar;
1499
1500
1501         /* compute the scalar contribution of this axis; */
1502         /* ignore invalid ranges                         */
1503         if ( axis->startCoord > axis->peakCoord ||
1504              axis->peakCoord > axis->endCoord   )
1505           axisScalar = FT_FIXED_ONE;
1506
1507         else if ( axis->startCoord < 0 &&
1508                   axis->endCoord > 0   &&
1509                   axis->peakCoord != 0 )
1510           axisScalar = FT_FIXED_ONE;
1511
1512         /* peak of 0 means ignore this axis */
1513         else if ( axis->peakCoord == 0 )
1514           axisScalar = FT_FIXED_ONE;
1515
1516         /* ignore this region if coords are out of range */
1517         else if ( NDV[j] < axis->startCoord ||
1518                   NDV[j] > axis->endCoord   )
1519           axisScalar = 0;
1520
1521         /* calculate a proportional factor */
1522         else
1523         {
1524           if ( NDV[j] == axis->peakCoord )
1525             axisScalar = FT_FIXED_ONE;
1526           else if ( NDV[j] < axis->peakCoord )
1527             axisScalar = FT_DivFix( NDV[j] - axis->startCoord,
1528                                     axis->peakCoord - axis->startCoord );
1529           else
1530             axisScalar = FT_DivFix( axis->endCoord - NDV[j],
1531                                     axis->endCoord - axis->peakCoord );
1532         }
1533
1534         /* take product of all the axis scalars */
1535         blend->BV[master] = FT_MulFix( blend->BV[master], axisScalar );
1536       }
1537
1538       FT_TRACE4(( ", %f ",
1539                   blend->BV[master] / 65536.0 ));
1540     }
1541
1542     FT_TRACE4(( "]\n" ));
1543
1544     /* record the parameters used to build the blend vector */
1545     blend->lastVsindex = vsindex;
1546
1547     if ( lenNDV != 0 )
1548     {
1549       /* user has set a normalized vector */
1550       if ( FT_QRENEW_ARRAY( blend->lastNDV, blend->lenNDV, lenNDV ) )
1551         goto Exit;
1552
1553       FT_MEM_COPY( blend->lastNDV,
1554                    NDV,
1555                    lenNDV * sizeof ( *NDV ) );
1556     }
1557
1558     blend->lenNDV  = lenNDV;
1559     blend->builtBV = TRUE;
1560
1561   Exit:
1562     return error;
1563   }
1564
1565
1566   /* `lenNDV' is zero for default vector;           */
1567   /* return TRUE if blend vector needs to be built. */
1568   FT_LOCAL_DEF( FT_Bool )
1569   cff_blend_check_vector( CFF_Blend  blend,
1570                           FT_UInt    vsindex,
1571                           FT_UInt    lenNDV,
1572                           FT_Fixed*  NDV )
1573   {
1574     if ( !blend->builtBV                                ||
1575          blend->lastVsindex != vsindex                  ||
1576          blend->lenNDV != lenNDV                        ||
1577          ( lenNDV                                     &&
1578            ft_memcmp( NDV,
1579                       blend->lastNDV,
1580                       lenNDV * sizeof ( *NDV ) ) != 0 ) )
1581     {
1582       /* need to build blend vector */
1583       return TRUE;
1584     }
1585
1586     return FALSE;
1587   }
1588
1589
1590 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1591
1592   FT_LOCAL_DEF( FT_Error )
1593   cff_get_var_blend( FT_Face      face,             /* CFF_Face */
1594                      FT_UInt     *num_coords,
1595                      FT_Fixed*   *coords,
1596                      FT_Fixed*   *normalizedcoords,
1597                      FT_MM_Var*  *mm_var )
1598   {
1599     CFF_Face                 cffface = (CFF_Face)face;
1600     FT_Service_MultiMasters  mm      = (FT_Service_MultiMasters)cffface->mm;
1601
1602
1603     return mm->get_var_blend( face,
1604                               num_coords,
1605                               coords,
1606                               normalizedcoords,
1607                               mm_var );
1608   }
1609
1610
1611   FT_LOCAL_DEF( void )
1612   cff_done_blend( FT_Face  face )    /* CFF_Face */
1613   {
1614     CFF_Face                 cffface = (CFF_Face)face;
1615     FT_Service_MultiMasters  mm      = (FT_Service_MultiMasters)cffface->mm;
1616
1617
1618     if ( mm )
1619       mm->done_blend( face );
1620   }
1621
1622 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
1623
1624
1625   static void
1626   cff_encoding_done( CFF_Encoding  encoding )
1627   {
1628     encoding->format = 0;
1629     encoding->offset = 0;
1630     encoding->count  = 0;
1631   }
1632
1633
1634   static FT_Error
1635   cff_encoding_load( CFF_Encoding  encoding,
1636                      CFF_Charset   charset,
1637                      FT_UInt       num_glyphs,
1638                      FT_Stream     stream,
1639                      FT_ULong      base_offset,
1640                      FT_ULong      offset )
1641   {
1642     FT_Error   error = FT_Err_Ok;
1643     FT_UInt    count;
1644     FT_UInt    j;
1645     FT_UShort  glyph_sid;
1646     FT_UInt    glyph_code;
1647
1648
1649     /* Check for charset->sids.  If we do not have this, we fail. */
1650     if ( !charset->sids )
1651     {
1652       error = FT_THROW( Invalid_File_Format );
1653       goto Exit;
1654     }
1655
1656     /* Note: The encoding table in a CFF font is indexed by glyph index;  */
1657     /* the first encoded glyph index is 1.  Hence, we read the character  */
1658     /* code (`glyph_code') at index j and make the assignment:            */
1659     /*                                                                    */
1660     /*    encoding->codes[glyph_code] = j + 1                             */
1661     /*                                                                    */
1662     /* We also make the assignment:                                       */
1663     /*                                                                    */
1664     /*    encoding->sids[glyph_code] = charset->sids[j + 1]               */
1665     /*                                                                    */
1666     /* This gives us both a code to GID and a code to SID mapping.        */
1667
1668     if ( offset > 1 )
1669     {
1670       /* Zero out the code to gid/sid mappings. */
1671       FT_ARRAY_ZERO( encoding->sids,  256 );
1672       FT_ARRAY_ZERO( encoding->codes, 256 );
1673
1674       encoding->offset = base_offset + offset;
1675
1676       /* we need to parse the table to determine its size */
1677       if ( FT_STREAM_SEEK( encoding->offset ) ||
1678            FT_READ_BYTE( encoding->format )   ||
1679            FT_READ_BYTE( count )              )
1680         goto Exit;
1681
1682       switch ( encoding->format & 0x7F )
1683       {
1684       case 0:
1685         {
1686           FT_Byte*  p;
1687
1688
1689           /* By convention, GID 0 is always ".notdef" and is never */
1690           /* coded in the font.  Hence, the number of codes found  */
1691           /* in the table is `count+1'.                            */
1692           /*                                                       */
1693           encoding->count = count + 1;
1694
1695           if ( FT_FRAME_ENTER( count ) )
1696             goto Exit;
1697
1698           p = (FT_Byte*)stream->cursor;
1699
1700           for ( j = 1; j <= count; j++ )
1701           {
1702             glyph_code = *p++;
1703
1704             /* Make sure j is not too big. */
1705             if ( j < num_glyphs )
1706             {
1707               /* Assign code to GID mapping. */
1708               encoding->codes[glyph_code] = (FT_UShort)j;
1709
1710               /* Assign code to SID mapping. */
1711               encoding->sids[glyph_code] = charset->sids[j];
1712             }
1713           }
1714
1715           FT_FRAME_EXIT();
1716         }
1717         break;
1718
1719       case 1:
1720         {
1721           FT_UInt  nleft;
1722           FT_UInt  i = 1;
1723           FT_UInt  k;
1724
1725
1726           encoding->count = 0;
1727
1728           /* Parse the Format1 ranges. */
1729           for ( j = 0;  j < count; j++, i += nleft )
1730           {
1731             /* Read the first glyph code of the range. */
1732             if ( FT_READ_BYTE( glyph_code ) )
1733               goto Exit;
1734
1735             /* Read the number of codes in the range. */
1736             if ( FT_READ_BYTE( nleft ) )
1737               goto Exit;
1738
1739             /* Increment nleft, so we read `nleft + 1' codes/sids. */
1740             nleft++;
1741
1742             /* compute max number of character codes */
1743             if ( (FT_UInt)nleft > encoding->count )
1744               encoding->count = nleft;
1745
1746             /* Fill in the range of codes/sids. */
1747             for ( k = i; k < nleft + i; k++, glyph_code++ )
1748             {
1749               /* Make sure k is not too big. */
1750               if ( k < num_glyphs && glyph_code < 256 )
1751               {
1752                 /* Assign code to GID mapping. */
1753                 encoding->codes[glyph_code] = (FT_UShort)k;
1754
1755                 /* Assign code to SID mapping. */
1756                 encoding->sids[glyph_code] = charset->sids[k];
1757               }
1758             }
1759           }
1760
1761           /* simple check; one never knows what can be found in a font */
1762           if ( encoding->count > 256 )
1763             encoding->count = 256;
1764         }
1765         break;
1766
1767       default:
1768         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1769         error = FT_THROW( Invalid_File_Format );
1770         goto Exit;
1771       }
1772
1773       /* Parse supplemental encodings, if any. */
1774       if ( encoding->format & 0x80 )
1775       {
1776         FT_UInt  gindex;
1777
1778
1779         /* count supplements */
1780         if ( FT_READ_BYTE( count ) )
1781           goto Exit;
1782
1783         for ( j = 0; j < count; j++ )
1784         {
1785           /* Read supplemental glyph code. */
1786           if ( FT_READ_BYTE( glyph_code ) )
1787             goto Exit;
1788
1789           /* Read the SID associated with this glyph code. */
1790           if ( FT_READ_USHORT( glyph_sid ) )
1791             goto Exit;
1792
1793           /* Assign code to SID mapping. */
1794           encoding->sids[glyph_code] = glyph_sid;
1795
1796           /* First, look up GID which has been assigned to */
1797           /* SID glyph_sid.                                */
1798           for ( gindex = 0; gindex < num_glyphs; gindex++ )
1799           {
1800             if ( charset->sids[gindex] == glyph_sid )
1801             {
1802               encoding->codes[glyph_code] = (FT_UShort)gindex;
1803               break;
1804             }
1805           }
1806         }
1807       }
1808     }
1809     else
1810     {
1811       /* We take into account the fact a CFF font can use a predefined */
1812       /* encoding without containing all of the glyphs encoded by this */
1813       /* encoding (see the note at the end of section 12 in the CFF    */
1814       /* specification).                                               */
1815
1816       switch ( (FT_UInt)offset )
1817       {
1818       case 0:
1819         /* First, copy the code to SID mapping. */
1820         FT_ARRAY_COPY( encoding->sids, cff_standard_encoding, 256 );
1821         goto Populate;
1822
1823       case 1:
1824         /* First, copy the code to SID mapping. */
1825         FT_ARRAY_COPY( encoding->sids, cff_expert_encoding, 256 );
1826
1827       Populate:
1828         /* Construct code to GID mapping from code to SID mapping */
1829         /* and charset.                                           */
1830
1831         encoding->offset = offset; /* used in cff_face_init */
1832         encoding->count  = 0;
1833
1834         error = cff_charset_compute_cids( charset, num_glyphs,
1835                                           stream->memory );
1836         if ( error )
1837           goto Exit;
1838
1839         for ( j = 0; j < 256; j++ )
1840         {
1841           FT_UInt  sid = encoding->sids[j];
1842           FT_UInt  gid = 0;
1843
1844
1845           if ( sid )
1846             gid = cff_charset_cid_to_gindex( charset, sid );
1847
1848           if ( gid != 0 )
1849           {
1850             encoding->codes[j] = (FT_UShort)gid;
1851             encoding->count    = j + 1;
1852           }
1853           else
1854           {
1855             encoding->codes[j] = 0;
1856             encoding->sids [j] = 0;
1857           }
1858         }
1859         break;
1860
1861       default:
1862         FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1863         error = FT_THROW( Invalid_File_Format );
1864         goto Exit;
1865       }
1866     }
1867
1868   Exit:
1869
1870     /* Clean up if there was an error. */
1871     return error;
1872   }
1873
1874
1875   /* Parse private dictionary; first call is always from `cff_face_init', */
1876   /* so NDV has not been set for CFF2 variation.                          */
1877   /*                                                                      */
1878   /* `cff_slot_load' must call this function each time NDV changes.       */
1879   FT_LOCAL_DEF( FT_Error )
1880   cff_load_private_dict( CFF_Font     font,
1881                          CFF_SubFont  subfont,
1882                          FT_UInt      lenNDV,
1883                          FT_Fixed*    NDV )
1884   {
1885     FT_Error         error  = FT_Err_Ok;
1886     CFF_ParserRec    parser;
1887     CFF_FontRecDict  top    = &subfont->font_dict;
1888     CFF_Private      priv   = &subfont->private_dict;
1889     FT_Stream        stream = font->stream;
1890     FT_UInt          stackSize;
1891
1892
1893     /* store handle needed to access memory, vstore for blend;    */
1894     /* we need this for clean-up even if there is no private DICT */
1895     subfont->blend.font   = font;
1896     subfont->blend.usedBV = FALSE;  /* clear state */
1897
1898     if ( !top->private_offset || !top->private_size )
1899       goto Exit2;       /* no private DICT, do nothing */
1900
1901     /* set defaults */
1902     FT_ZERO( priv );
1903
1904     priv->blue_shift       = 7;
1905     priv->blue_fuzz        = 1;
1906     priv->lenIV            = -1;
1907     priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
1908     priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
1909
1910     /* provide inputs for blend calculations */
1911     priv->subfont   = subfont;
1912     subfont->lenNDV = lenNDV;
1913     subfont->NDV    = NDV;
1914
1915     /* add 1 for the operator */
1916     stackSize = font->cff2 ? font->top_font.font_dict.maxstack + 1
1917                            : CFF_MAX_STACK_DEPTH + 1;
1918
1919     if ( cff_parser_init( &parser,
1920                           font->cff2 ? CFF2_CODE_PRIVATE : CFF_CODE_PRIVATE,
1921                           priv,
1922                           font->library,
1923                           stackSize,
1924                           top->num_designs,
1925                           top->num_axes ) )
1926       goto Exit;
1927
1928     if ( FT_STREAM_SEEK( font->base_offset + top->private_offset ) ||
1929          FT_FRAME_ENTER( top->private_size )                       )
1930       goto Exit;
1931
1932     FT_TRACE4(( " private dictionary:\n" ));
1933     error = cff_parser_run( &parser,
1934                             (FT_Byte*)stream->cursor,
1935                             (FT_Byte*)stream->limit );
1936     FT_FRAME_EXIT();
1937
1938     if ( error )
1939       goto Exit;
1940
1941     /* ensure that `num_blue_values' is even */
1942     priv->num_blue_values &= ~1;
1943
1944     /* sanitize `initialRandomSeed' to be a positive value, if necessary;  */
1945     /* this is not mandated by the specification but by our implementation */
1946     if ( priv->initial_random_seed < 0 )
1947       priv->initial_random_seed = -priv->initial_random_seed;
1948     else if ( priv->initial_random_seed == 0 )
1949       priv->initial_random_seed = 987654321;
1950
1951     /* some sanitizing to avoid overflows later on; */
1952     /* the upper limits are ad-hoc values           */
1953     if ( priv->blue_shift > 1000 || priv->blue_shift < 0 )
1954     {
1955       FT_TRACE2(( "cff_load_private_dict:"
1956                   " setting unlikely BlueShift value %ld to default (7)\n",
1957                   priv->blue_shift ));
1958       priv->blue_shift = 7;
1959     }
1960
1961     if ( priv->blue_fuzz > 1000 || priv->blue_fuzz < 0 )
1962     {
1963       FT_TRACE2(( "cff_load_private_dict:"
1964                   " setting unlikely BlueFuzz value %ld to default (1)\n",
1965                   priv->blue_fuzz ));
1966       priv->blue_fuzz = 1;
1967     }
1968
1969   Exit:
1970     /* clean up */
1971     cff_blend_clear( subfont ); /* clear blend stack */
1972     cff_parser_done( &parser ); /* free parser stack */
1973
1974   Exit2:
1975     /* no clean up (parser not initialized) */
1976     return error;
1977   }
1978
1979
1980   /* There are 3 ways to call this function, distinguished by code.  */
1981   /*                                                                 */
1982   /* . CFF_CODE_TOPDICT for either a CFF Top DICT or a CFF Font DICT */
1983   /* . CFF2_CODE_TOPDICT for CFF2 Top DICT                           */
1984   /* . CFF2_CODE_FONTDICT for CFF2 Font DICT                         */
1985
1986   static FT_Error
1987   cff_subfont_load( CFF_SubFont  subfont,
1988                     CFF_Index    idx,
1989                     FT_UInt      font_index,
1990                     FT_Stream    stream,
1991                     FT_ULong     base_offset,
1992                     FT_UInt      code,
1993                     CFF_Font     font,
1994                     CFF_Face     face )
1995   {
1996     FT_Error         error;
1997     CFF_ParserRec    parser;
1998     FT_Byte*         dict = NULL;
1999     FT_ULong         dict_len;
2000     CFF_FontRecDict  top  = &subfont->font_dict;
2001     CFF_Private      priv = &subfont->private_dict;
2002
2003     PSAux_Service  psaux = (PSAux_Service)face->psaux;
2004
2005     FT_Bool  cff2      = FT_BOOL( code == CFF2_CODE_TOPDICT  ||
2006                                   code == CFF2_CODE_FONTDICT );
2007     FT_UInt  stackSize = cff2 ? CFF2_DEFAULT_STACK
2008                               : CFF_MAX_STACK_DEPTH;
2009
2010
2011     /* Note: We use default stack size for CFF2 Font DICT because        */
2012     /*       Top and Font DICTs are not allowed to have blend operators. */
2013     error = cff_parser_init( &parser,
2014                              code,
2015                              top,
2016                              font->library,
2017                              stackSize,
2018                              0,
2019                              0 );
2020     if ( error )
2021       goto Exit;
2022
2023     /* set defaults */
2024     FT_ZERO( top );
2025
2026     top->underline_position  = -( 100L << 16 );
2027     top->underline_thickness = 50L << 16;
2028     top->charstring_type     = 2;
2029     top->font_matrix.xx      = 0x10000L;
2030     top->font_matrix.yy      = 0x10000L;
2031     top->cid_count           = 8720;
2032
2033     /* we use the implementation specific SID value 0xFFFF to indicate */
2034     /* missing entries                                                 */
2035     top->version             = 0xFFFFU;
2036     top->notice              = 0xFFFFU;
2037     top->copyright           = 0xFFFFU;
2038     top->full_name           = 0xFFFFU;
2039     top->family_name         = 0xFFFFU;
2040     top->weight              = 0xFFFFU;
2041     top->embedded_postscript = 0xFFFFU;
2042
2043     top->cid_registry        = 0xFFFFU;
2044     top->cid_ordering        = 0xFFFFU;
2045     top->cid_font_name       = 0xFFFFU;
2046
2047     /* set default stack size */
2048     top->maxstack            = cff2 ? CFF2_DEFAULT_STACK : 48;
2049
2050     if ( idx->count )   /* count is nonzero for a real index */
2051       error = cff_index_access_element( idx, font_index, &dict, &dict_len );
2052     else
2053     {
2054       /* CFF2 has a fake top dict index;     */
2055       /* simulate `cff_index_access_element' */
2056
2057       /* Note: macros implicitly use `stream' and set `error' */
2058       if ( FT_STREAM_SEEK( idx->data_offset )       ||
2059            FT_FRAME_EXTRACT( idx->data_size, dict ) )
2060         goto Exit;
2061
2062       dict_len = idx->data_size;
2063     }
2064
2065     if ( !error )
2066     {
2067       FT_TRACE4(( " top dictionary:\n" ));
2068       error = cff_parser_run( &parser, dict, FT_OFFSET( dict, dict_len ) );
2069     }
2070
2071     /* clean up regardless of error */
2072     if ( idx->count )
2073       cff_index_forget_element( idx, &dict );
2074     else
2075       FT_FRAME_RELEASE( dict );
2076
2077     if ( error )
2078       goto Exit;
2079
2080     /* if it is a CID font, we stop there */
2081     if ( top->cid_registry != 0xFFFFU )
2082       goto Exit;
2083
2084     /* Parse the private dictionary, if any.                   */
2085     /*                                                         */
2086     /* CFF2 does not have a private dictionary in the Top DICT */
2087     /* but may have one in a Font DICT.  We need to parse      */
2088     /* the latter here in order to load any local subrs.       */
2089     error = cff_load_private_dict( font, subfont, 0, 0 );
2090     if ( error )
2091       goto Exit;
2092
2093     if ( !cff2 )
2094     {
2095       /*
2096        * Initialize the random number generator.
2097        *
2098        * - If we have a face-specific seed, use it.
2099        *   If non-zero, update it to a positive value.
2100        *
2101        * - Otherwise, use the seed from the CFF driver.
2102        *   If non-zero, update it to a positive value.
2103        *
2104        * - If the random value is zero, use the seed given by the subfont's
2105        *   `initialRandomSeed' value.
2106        *
2107        */
2108       if ( face->root.internal->random_seed == -1 )
2109       {
2110         PS_Driver  driver = (PS_Driver)FT_FACE_DRIVER( face );
2111
2112
2113         subfont->random = (FT_UInt32)driver->random_seed;
2114         if ( driver->random_seed )
2115         {
2116           do
2117           {
2118             driver->random_seed =
2119               (FT_Int32)psaux->cff_random( (FT_UInt32)driver->random_seed );
2120
2121           } while ( driver->random_seed < 0 );
2122         }
2123       }
2124       else
2125       {
2126         subfont->random = (FT_UInt32)face->root.internal->random_seed;
2127         if ( face->root.internal->random_seed )
2128         {
2129           do
2130           {
2131             face->root.internal->random_seed =
2132               (FT_Int32)psaux->cff_random(
2133                 (FT_UInt32)face->root.internal->random_seed );
2134
2135           } while ( face->root.internal->random_seed < 0 );
2136         }
2137       }
2138
2139       if ( !subfont->random )
2140         subfont->random = (FT_UInt32)priv->initial_random_seed;
2141     }
2142
2143     /* read the local subrs, if any */
2144     if ( priv->local_subrs_offset )
2145     {
2146       if ( FT_STREAM_SEEK( base_offset + top->private_offset +
2147                            priv->local_subrs_offset ) )
2148         goto Exit;
2149
2150       error = cff_index_init( &subfont->local_subrs_index, stream, 1, cff2 );
2151       if ( error )
2152         goto Exit;
2153
2154       error = cff_index_get_pointers( &subfont->local_subrs_index,
2155                                       &subfont->local_subrs, NULL, NULL );
2156       if ( error )
2157         goto Exit;
2158     }
2159
2160   Exit:
2161     cff_parser_done( &parser ); /* free parser stack */
2162
2163     return error;
2164   }
2165
2166
2167   static void
2168   cff_subfont_done( FT_Memory    memory,
2169                     CFF_SubFont  subfont )
2170   {
2171     if ( subfont )
2172     {
2173       cff_index_done( &subfont->local_subrs_index );
2174       FT_FREE( subfont->local_subrs );
2175
2176       FT_FREE( subfont->blend.lastNDV );
2177       FT_FREE( subfont->blend.BV );
2178       FT_FREE( subfont->blend_stack );
2179     }
2180   }
2181
2182
2183   FT_LOCAL_DEF( FT_Error )
2184   cff_font_load( FT_Library library,
2185                  FT_Stream  stream,
2186                  FT_Int     face_index,
2187                  CFF_Font   font,
2188                  CFF_Face   face,
2189                  FT_Bool    pure_cff,
2190                  FT_Bool    cff2 )
2191   {
2192     static const FT_Frame_Field  cff_header_fields[] =
2193     {
2194 #undef  FT_STRUCTURE
2195 #define FT_STRUCTURE  CFF_FontRec
2196
2197       FT_FRAME_START( 3 ),
2198         FT_FRAME_BYTE( version_major ),
2199         FT_FRAME_BYTE( version_minor ),
2200         FT_FRAME_BYTE( header_size ),
2201       FT_FRAME_END
2202     };
2203
2204     FT_Error         error;
2205     FT_Memory        memory = stream->memory;
2206     FT_ULong         base_offset;
2207     CFF_FontRecDict  dict;
2208     CFF_IndexRec     string_index;
2209     FT_UInt          subfont_index;
2210
2211
2212     FT_ZERO( font );
2213     FT_ZERO( &string_index );
2214
2215     dict        = &font->top_font.font_dict;
2216     base_offset = FT_STREAM_POS();
2217
2218     font->library     = library;
2219     font->stream      = stream;
2220     font->memory      = memory;
2221     font->cff2        = cff2;
2222     font->base_offset = base_offset;
2223
2224     /* read CFF font header */
2225     if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
2226       goto Exit;
2227
2228     if ( cff2 )
2229     {
2230       if ( font->version_major != 2 ||
2231            font->header_size < 5    )
2232       {
2233         FT_TRACE2(( "  not a CFF2 font header\n" ));
2234         error = FT_THROW( Unknown_File_Format );
2235         goto Exit;
2236       }
2237
2238       if ( FT_READ_USHORT( font->top_dict_length ) )
2239         goto Exit;
2240     }
2241     else
2242     {
2243       FT_Byte  absolute_offset;
2244
2245
2246       if ( FT_READ_BYTE( absolute_offset ) )
2247         goto Exit;
2248
2249       if ( font->version_major != 1 ||
2250            font->header_size < 4    ||
2251            absolute_offset > 4      )
2252       {
2253         FT_TRACE2(( "  not a CFF font header\n" ));
2254         error = FT_THROW( Unknown_File_Format );
2255         goto Exit;
2256       }
2257     }
2258
2259     /* skip the rest of the header */
2260     if ( FT_STREAM_SEEK( base_offset + font->header_size ) )
2261     {
2262       /* For pure CFFs we have read only four bytes so far.  Contrary to */
2263       /* other formats like SFNT those bytes doesn't define a signature; */
2264       /* it is thus possible that the font isn't a CFF at all.           */
2265       if ( pure_cff )
2266       {
2267         FT_TRACE2(( "  not a CFF file\n" ));
2268         error = FT_THROW( Unknown_File_Format );
2269       }
2270       goto Exit;
2271     }
2272
2273     if ( cff2 )
2274     {
2275       /* For CFF2, the top dict data immediately follow the header    */
2276       /* and the length is stored in the header `offSize' field;      */
2277       /* there is no index for it.                                    */
2278       /*                                                              */
2279       /* Use the `font_dict_index' to save the current position       */
2280       /* and length of data, but leave count at zero as an indicator. */
2281       FT_ZERO( &font->font_dict_index );
2282
2283       font->font_dict_index.data_offset = FT_STREAM_POS();
2284       font->font_dict_index.data_size   = font->top_dict_length;
2285
2286       /* skip the top dict data for now, we will parse it later */
2287       if ( FT_STREAM_SKIP( font->top_dict_length ) )
2288         goto Exit;
2289
2290       /* next, read the global subrs index */
2291       if ( FT_SET_ERROR( cff_index_init( &font->global_subrs_index,
2292                                          stream, 1, cff2 ) ) )
2293         goto Exit;
2294     }
2295     else
2296     {
2297       /* for CFF, read the name, top dict, string and global subrs index */
2298       if ( FT_SET_ERROR( cff_index_init( &font->name_index,
2299                                          stream, 0, cff2 ) ) )
2300       {
2301         if ( pure_cff )
2302         {
2303           FT_TRACE2(( "  not a CFF file\n" ));
2304           error = FT_THROW( Unknown_File_Format );
2305         }
2306         goto Exit;
2307       }
2308
2309       /* if we have an empty font name,      */
2310       /* it must be the only font in the CFF */
2311       if ( font->name_index.count > 1                          &&
2312            font->name_index.data_size < font->name_index.count )
2313       {
2314         /* for pure CFFs, we still haven't checked enough bytes */
2315         /* to be sure that it is a CFF at all                   */
2316         error = pure_cff ? FT_THROW( Unknown_File_Format )
2317                          : FT_THROW( Invalid_File_Format );
2318         goto Exit;
2319       }
2320
2321       if ( FT_SET_ERROR( cff_index_init( &font->font_dict_index,
2322                                          stream, 0, cff2 ) )                 ||
2323            FT_SET_ERROR( cff_index_init( &string_index,
2324                                          stream, 1, cff2 ) )                 ||
2325            FT_SET_ERROR( cff_index_init( &font->global_subrs_index,
2326                                          stream, 1, cff2 ) )                 ||
2327            FT_SET_ERROR( cff_index_get_pointers( &string_index,
2328                                                  &font->strings,
2329                                                  &font->string_pool,
2330                                                  &font->string_pool_size ) ) )
2331         goto Exit;
2332
2333       /* there must be a Top DICT index entry for each name index entry */
2334       if ( font->name_index.count > font->font_dict_index.count )
2335       {
2336         FT_ERROR(( "cff_font_load:"
2337                    " not enough entries in Top DICT index\n" ));
2338         error = FT_THROW( Invalid_File_Format );
2339         goto Exit;
2340       }
2341     }
2342
2343     font->num_strings = string_index.count;
2344
2345     if ( pure_cff )
2346     {
2347       /* well, we don't really forget the `disabled' fonts... */
2348       subfont_index = (FT_UInt)( face_index & 0xFFFF );
2349
2350       if ( face_index > 0 && subfont_index >= font->name_index.count )
2351       {
2352         FT_ERROR(( "cff_font_load:"
2353                    " invalid subfont index for pure CFF font (%d)\n",
2354                    subfont_index ));
2355         error = FT_THROW( Invalid_Argument );
2356         goto Exit;
2357       }
2358
2359       font->num_faces = font->name_index.count;
2360     }
2361     else
2362     {
2363       subfont_index = 0;
2364
2365       if ( font->name_index.count > 1 )
2366       {
2367         FT_ERROR(( "cff_font_load:"
2368                    " invalid CFF font with multiple subfonts\n" ));
2369         FT_ERROR(( "              "
2370                    " in SFNT wrapper\n" ));
2371         error = FT_THROW( Invalid_File_Format );
2372         goto Exit;
2373       }
2374     }
2375
2376     /* in case of a font format check, simply exit now */
2377     if ( face_index < 0 )
2378       goto Exit;
2379
2380     /* now, parse the top-level font dictionary */
2381     FT_TRACE4(( "parsing top-level\n" ));
2382     error = cff_subfont_load( &font->top_font,
2383                               &font->font_dict_index,
2384                               subfont_index,
2385                               stream,
2386                               base_offset,
2387                               cff2 ? CFF2_CODE_TOPDICT : CFF_CODE_TOPDICT,
2388                               font,
2389                               face );
2390     if ( error )
2391       goto Exit;
2392
2393     if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
2394       goto Exit;
2395
2396     error = cff_index_init( &font->charstrings_index, stream, 0, cff2 );
2397     if ( error )
2398       goto Exit;
2399
2400     /* now, check for a CID or CFF2 font */
2401     if ( dict->cid_registry != 0xFFFFU ||
2402          cff2                          )
2403     {
2404       CFF_IndexRec  fd_index;
2405       CFF_SubFont   sub = NULL;
2406       FT_UInt       idx;
2407
2408
2409       /* for CFF2, read the Variation Store if available;                 */
2410       /* this must follow the Top DICT parse and precede any Private DICT */
2411       error = cff_vstore_load( &font->vstore,
2412                                stream,
2413                                base_offset,
2414                                dict->vstore_offset );
2415       if ( error )
2416         goto Exit;
2417
2418       /* this is a CID-keyed font, we must now allocate a table of */
2419       /* sub-fonts, then load each of them separately              */
2420       if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )
2421         goto Exit;
2422
2423       error = cff_index_init( &fd_index, stream, 0, cff2 );
2424       if ( error )
2425         goto Exit;
2426
2427       /* Font Dicts are not limited to 256 for CFF2. */
2428       /* TODO: support this for CFF2                 */
2429       if ( fd_index.count > CFF_MAX_CID_FONTS )
2430       {
2431         FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" ));
2432         goto Fail_CID;
2433       }
2434
2435       /* allocate & read each font dict independently */
2436       font->num_subfonts = fd_index.count;
2437       if ( FT_NEW_ARRAY( sub, fd_index.count ) )
2438         goto Fail_CID;
2439
2440       /* set up pointer table */
2441       for ( idx = 0; idx < fd_index.count; idx++ )
2442         font->subfonts[idx] = sub + idx;
2443
2444       /* now load each subfont independently */
2445       for ( idx = 0; idx < fd_index.count; idx++ )
2446       {
2447         sub = font->subfonts[idx];
2448         FT_TRACE4(( "parsing subfont %u\n", idx ));
2449         error = cff_subfont_load( sub,
2450                                   &fd_index,
2451                                   idx,
2452                                   stream,
2453                                   base_offset,
2454                                   cff2 ? CFF2_CODE_FONTDICT
2455                                        : CFF_CODE_TOPDICT,
2456                                   font,
2457                                   face );
2458         if ( error )
2459           goto Fail_CID;
2460       }
2461
2462       /* now load the FD Select array;               */
2463       /* CFF2 omits FDSelect if there is only one FD */
2464       if ( !cff2 || fd_index.count > 1 )
2465         error = CFF_Load_FD_Select( &font->fd_select,
2466                                     font->charstrings_index.count,
2467                                     stream,
2468                                     base_offset + dict->cid_fd_select_offset );
2469
2470     Fail_CID:
2471       cff_index_done( &fd_index );
2472
2473       if ( error )
2474         goto Exit;
2475     }
2476     else
2477       font->num_subfonts = 0;
2478
2479     /* read the charstrings index now */
2480     if ( dict->charstrings_offset == 0 )
2481     {
2482       FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
2483       error = FT_THROW( Invalid_File_Format );
2484       goto Exit;
2485     }
2486
2487     font->num_glyphs = font->charstrings_index.count;
2488
2489     error = cff_index_get_pointers( &font->global_subrs_index,
2490                                     &font->global_subrs, NULL, NULL );
2491
2492     if ( error )
2493       goto Exit;
2494
2495     /* read the Charset and Encoding tables if available */
2496     if ( !cff2 && font->num_glyphs > 0 )
2497     {
2498       FT_Bool  invert = FT_BOOL( dict->cid_registry != 0xFFFFU && pure_cff );
2499
2500
2501       error = cff_charset_load( &font->charset, font->num_glyphs, stream,
2502                                 base_offset, dict->charset_offset, invert );
2503       if ( error )
2504         goto Exit;
2505
2506       /* CID-keyed CFFs don't have an encoding */
2507       if ( dict->cid_registry == 0xFFFFU )
2508       {
2509         error = cff_encoding_load( &font->encoding,
2510                                    &font->charset,
2511                                    font->num_glyphs,
2512                                    stream,
2513                                    base_offset,
2514                                    dict->encoding_offset );
2515         if ( error )
2516           goto Exit;
2517       }
2518     }
2519
2520     /* get the font name (/CIDFontName for CID-keyed fonts, */
2521     /* /FontName otherwise)                                 */
2522     font->font_name = cff_index_get_name( font, subfont_index );
2523
2524   Exit:
2525     cff_index_done( &string_index );
2526
2527     return error;
2528   }
2529
2530
2531   FT_LOCAL_DEF( void )
2532   cff_font_done( CFF_Font  font )
2533   {
2534     FT_Memory  memory = font->memory;
2535     FT_UInt    idx;
2536
2537
2538     cff_index_done( &font->global_subrs_index );
2539     cff_index_done( &font->font_dict_index );
2540     cff_index_done( &font->name_index );
2541     cff_index_done( &font->charstrings_index );
2542
2543     /* release font dictionaries, but only if working with */
2544     /* a CID keyed CFF font or a CFF2 font                 */
2545     if ( font->num_subfonts > 0 )
2546     {
2547       for ( idx = 0; idx < font->num_subfonts; idx++ )
2548         cff_subfont_done( memory, font->subfonts[idx] );
2549
2550       /* the subfonts array has been allocated as a single block */
2551       FT_FREE( font->subfonts[0] );
2552     }
2553
2554     cff_encoding_done( &font->encoding );
2555     cff_charset_done( &font->charset, font->stream );
2556     cff_vstore_done( &font->vstore, memory );
2557
2558     cff_subfont_done( memory, &font->top_font );
2559
2560     CFF_Done_FD_Select( &font->fd_select, font->stream );
2561
2562     FT_FREE( font->font_info );
2563
2564     FT_FREE( font->font_name );
2565     FT_FREE( font->global_subrs );
2566     FT_FREE( font->strings );
2567     FT_FREE( font->string_pool );
2568
2569     if ( font->cf2_instance.finalizer )
2570     {
2571       font->cf2_instance.finalizer( font->cf2_instance.data );
2572       FT_FREE( font->cf2_instance.data );
2573     }
2574
2575     FT_FREE( font->font_extra );
2576   }
2577
2578
2579 /* END */