int16 TTCOffsetTableOffset(
/* 0 */ CONST unsigned char * puchSrcBuffer, /* input TTF or TTC buffer */
/* 1 */ CONST unsigned long ulSrcBufferSize, /* size of input TTF or TTC buffer data */
/* 6 */ CONST unsigned short usTTCIndex, /* TTC Index, only used if TTC bit set */
uint32 *pulOffsetTableOffset)
{
CONST_TTFACC_FILEBUFFERINFO InputBufferInfo;
int16 errCode = NO_ERROR;
TTC_HEADER TTCHeader;
uint16 usBytesRead;
uint32 ulOffset;
InputBufferInfo.puchBuffer = puchSrcBuffer;
InputBufferInfo.ulBufferSize = ulSrcBufferSize;
InputBufferInfo.ulOffsetTableOffset = *pulOffsetTableOffset = 0;
InputBufferInfo.lpfnReAllocate = NULL; /* can't reallocate input buffer */
if ((errCode = ReadGeneric((TTFACC_FILEBUFFERINFO *) &InputBufferInfo, (uint8 *) &TTCHeader, SIZEOF_TTC_HEADER, TTC_HEADER_CONTROL, 0, &usBytesRead)) != NO_ERROR)
return(errCode);
ulOffset = usBytesRead;
if (TTCHeader.TTCTag != TTC_LONG_TAG) /* this isn't a ttc */
return ERR_NOT_TTC; /* offset set correctly for ttf */
if (usTTCIndex >= TTCHeader.DirectoryCount)
return ERR_INVALID_TTC_INDEX;
ulOffset += GetGenericSize(LONG_CONTROL) * usTTCIndex;
if ((errCode = ReadLong((TTFACC_FILEBUFFERINFO *) &InputBufferInfo, pulOffsetTableOffset, ulOffset)) != NO_ERROR)
return(errCode);
return errCode;
}
int16 MortAutoMap(TTFACC_FILEBUFFERINFO * pInputBufferInfo, /* ttfacc info */
uint8 * pabKeepGlyphs, /* binary list of glyphs to keep - to be updated here */
uint16 usnGlyphs, /* number of glyphs in list */
uint16 fKeepFlag)
{
MORTBINSRCHHEADER MortBinSrchHeader;
MORTLOOKUPSINGLE MortLookup;
uint16 nEntries;
uint16 usBytesRead;
uint32 ulOffset;
uint32 ulLength;
uint32 ulLastOffset;
int16 errCode = NO_ERROR;
ulOffset = TTTableOffset( pInputBufferInfo, MORT_TAG );
ulLength = TTTableLength( pInputBufferInfo, MORT_TAG );
ulLastOffset = ulOffset+ulLength;
if (ulOffset == DIRECTORY_ERROR || ulLength == 0) /* nothing to map, we're done */
return NO_ERROR;
ulOffset += GetGenericSize(MORTHEADER_CONTROL); /* skip over mortheader */
if ((errCode = ReadGeneric( pInputBufferInfo, (uint8 *)&MortBinSrchHeader, SIZEOF_MORTBINSRCHHEADER, MORTBINSRCHHEADER_CONTROL, ulOffset, &usBytesRead ) )!= NO_ERROR)
return errCode;
ulOffset += usBytesRead;
for ( nEntries = MortBinSrchHeader.nEntries; nEntries > 0 && ulOffset < ulLastOffset; nEntries--)
{
if ((errCode = ReadGeneric( pInputBufferInfo, (uint8 *)&MortLookup, SIZEOF_MORTLOOKUPSINGLE, MORTLOOKUPSINGLE_CONTROL, ulOffset, &usBytesRead ) )!= NO_ERROR)
return errCode;
ulOffset += usBytesRead;
if ( MortLookup.glyphid1 < usnGlyphs && pabKeepGlyphs[MortLookup.glyphid1] == fKeepFlag && MortLookup.glyphid2 < usnGlyphs && pabKeepGlyphs[MortLookup.glyphid2] == 0)
pabKeepGlyphs[MortLookup.glyphid2] = (uint8)(fKeepFlag + 1); /* set this value too */
}
return NO_ERROR;
}
PRIVATE int16 GetGlyphStats( TTFACC_FILEBUFFERINFO * pInputBufferInfo,
uint16 usGlyphIdx,
int16 * psnContours,
uint16 * pusnPoints,
uint16 * pusnInstructions,
uint16 indexToLocFormat,
uint32 ulLocaOffset,
uint32 ulGlyfOffset,
BOOL *bStatus )
{
uint32 ulOffset;
uint16 usLength;
GLYF_HEADER GlyfHeader;
uint32 ulLastPointOffset;
int16 errCode;
*psnContours = 0;
*pusnPoints = 0;
*pusnInstructions = 0;
*bStatus = FALSE; /* assume no glyph there */
if ((errCode = GetGlyphHeader( pInputBufferInfo, usGlyphIdx, indexToLocFormat, ulLocaOffset, ulGlyfOffset, &GlyfHeader, &ulOffset, &usLength )) != NO_ERROR)
return errCode;
if ( usLength == 0 )
return( NO_ERROR );
*psnContours = GlyfHeader.numberOfContours;
if (*psnContours > 0)
{
/* calculate offset of last point */
ulLastPointOffset = ulOffset + GetGenericSize( GLYF_HEADER_CONTROL ) + (*psnContours-1) * sizeof( uint16 );
if ((errCode = ReadWord( pInputBufferInfo, pusnPoints, ulLastPointOffset)) != NO_ERROR)
return errCode;
(*pusnPoints)++;
if ((errCode = ReadWord( pInputBufferInfo, pusnInstructions, ulLastPointOffset + sizeof(uint16))) != NO_ERROR)
return errCode;
}
*bStatus = TRUE;
return( NO_ERROR );
}
int16 ModVDMX(CONST_TTFACC_FILEBUFFERINFO * pInputBufferInfo,
TTFACC_FILEBUFFERINFO * pOutputBufferInfo,
CONST uint16 usFormat,
uint32 *pulNewOutOffset)
{
VDMX Vdmx;
uint32 ulSrcOffset; /* offset to Src VDMX table */
uint32 ulSrcLength; /* length of Src VDMX table */
uint32 ulDestOffset; /* offset to Dest VDMX table */
uint32 ulDestLength; /* length of Dest VDMX table */
uint32 ulSrcOffsetRatios; /* absolute offset to Ratios in Src file */
uint32 ulSrcOffsetOffsets; /* absolute offset to Offsets in Src file */
uint32 ulSrcOffsetGroups; /* absolute offset to Groups in Src file */
uint32 ulDestOffsetRatios; /* absolute offset to Ratios in Dest file */
uint32 ulDestOffsetOffsets; /* absolute offset to Offsets in Dest file */
uint32 ulDestOffsetGroups; /* absolute offset to Groups in Dest file */
uint16 usCurrGroupSrcOffset; /* relative offset from beginning of VDMX table */
uint16 usCurrGroupDestOffset; /* relative offset from beginning of VDMX table */
uint32 ulCurrGroupDestOffset=0; /* relative offset from beginning of VDMX table - long value */
uint16 usGroupDestOffset; /* relative offset from beginning of VDMX table, local copy for writing */
uint16 ----cRatioIndex,usDestRatioIndex;
uint16 i;
uint16 usBytesRead;
uint16 usBytesWritten;
uint32 ulBytesRead;
int16 errCode=NO_ERROR;
VDMXRatio *SrcRatioArray=NULL;
int8 *KeepSrcRatioArray = NULL; /* parallel array to SrcRatioArray */
VDMXGroup GroupHeader;
uint8 * pGroupBuffer=NULL;
uint32 ulGroupBufferLength; /* total length of the Group Buffer (from source file) */
uint32 ulGroupLength; /* length of individual group to be read */
uint16 usGroupCount = 0;
uint16 usKeepRatioCount = 0;
uint16 usRatioSize;
uint16 xRatio, yRatio; /* for reducing the ratios */
int16 Found1to1;
GROUPOFFSETRECORDKEEPER keeper;
TTFACC_FILEBUFFERINFO * pUnCONSTInputBufferInfo;
if (usFormat == TTFDELTA_DELTA) /* only formats for which this is not valid */
{
MarkTableForDeletion(pOutputBufferInfo, VDMX_TAG);
return errCode;
}
pUnCONSTInputBufferInfo = (TTFACC_FILEBUFFERINFO *) pInputBufferInfo; /* used for Read functions ONLY. Not for Write */
/* get input buffer information */
ulSrcOffset = TTTableOffset( pUnCONSTInputBufferInfo, VDMX_TAG );
if ( ulSrcOffset == 0L )
return NO_ERROR;
ulSrcLength = TTTableLength( pUnCONSTInputBufferInfo, VDMX_TAG );
if ( ulSrcLength == 0L )
{
MarkTableForDeletion(pOutputBufferInfo, VDMX_TAG);
return NO_ERROR;
}
/* get output buffer information */
if ((errCode = ZeroLongWordAlign(pOutputBufferInfo, *pulNewOutOffset, &ulDestOffset)) != NO_ERROR)
return errCode;
if ((errCode = ReadGeneric( pUnCONSTInputBufferInfo, (uint8 *) &Vdmx, SIZEOF_VDMX, VDMX_CONTROL, ulSrcOffset, &usBytesRead )) != NO_ERROR)
return errCode;
if (Vdmx.numRatios == 0)
{
MarkTableForDeletion(pOutputBufferInfo, VDMX_TAG);
return NO_ERROR;
}
ulSrcOffsetRatios = ulSrcOffset + usBytesRead;
ulSrcOffsetOffsets = ulSrcOffsetRatios + GetGenericSize(VDMXRATIO_CONTROL) * Vdmx.numRatios;
ulSrcOffsetGroups = ulSrcOffsetOffsets + sizeof(uint16) * Vdmx.numRatios;
memset(&keeper, 0, sizeof(keeper));
SrcRatioArray = (VDMXRatio *)Mem_Alloc(Vdmx.numRatios * sizeof(VDMXRatio));
if (SrcRatioArray == NULL)
errCode = ERR_MEM;
else
{
KeepSrcRatioArray = (int8 *)Mem_Alloc(Vdmx.numRatios * sizeof(int8));
if (KeepSrcRatioArray == NULL)
errCode = ERR_MEM;
else
errCode = ReadGenericRepeat(pUnCONSTInputBufferInfo, (uint8 *) SrcRatioArray, VDMXRATIO_CONTROL, ulSrcOffsetRatios, &ulBytesRead, Vdmx.numRatios, SIZEOF_VDMXRATIO );
}
while (errCode == NO_ERROR) /* while is so we can break out. Only go once through */
{
Found1to1 = FALSE;
for (i = 0; i < Vdmx.numRatios ; ++i) /* keep all 1:1 aspect ratios */
{
KeepSrcRatioArray[i] = 1; /* assume we'll keep it */
xRatio = SrcRatioArray[i].xRatio;
yRatio = SrcRatioArray[i].yStartRatio;
ReduceRatio(&xRatio,&yRatio);
if (xRatio == yRatio)
{
if (SrcRatioArray[i].xRatio == 0) /* anything after 0:0 is ignored */
{
if (!Found1to1) /* need to keep this one */
++usKeepRatioCount;
break;
}
if (Found1to1) /* already have one */
KeepSrcRatioArray[i] = 0; /* don't keep this one */
else
{
Found1to1 = TRUE;
++usKeepRatioCount;
}
}
else if (xRatio == EGA_X_RATIO && yRatio == EGA_Y_RATIO)
KeepSrcRatioArray[i] = 0; /* don't keep this one */
else
++usKeepRatioCount;
}
if ((usKeepRatioCount == 0) || (usKeepRatioCount == Vdmx.numRatios))
{ /* don't change a thing */
Mem_Free(SrcRatioArray);
Mem_Free(KeepSrcRatioArray);
return CopyTableOver(pOutputBufferInfo, pInputBufferInfo, VDMX_TAG, pulNewOutOffset);
}
ulDestOffsetRatios = ulDestOffset + usBytesRead;
/* figure out offset for the Offset array */
ulDestOffsetOffsets = ulDestOffsetRatios + GetGenericSize(VDMXRATIO_CONTROL) * usKeepRatioCount;
ulDestOffsetGroups = ulDestOffsetOffsets + sizeof(uint16) * usKeepRatioCount;
usRatioSize = GetGenericSize(VDMXRATIO_CONTROL);
ulCurrGroupDestOffset = ulDestOffsetGroups - ulDestOffset; /* calculate offset from start of VDMX table */
if ((errCode = InitGroupOffsetArray(&keeper,usKeepRatioCount)) != NO_ERROR) /* initialize structure to track offset re-use */
break;
ulGroupBufferLength = ulSrcLength - (ulSrcOffsetGroups - ulSrcOffset); /* calculate the length of the group section */
pGroupBuffer = (uint8 *)Mem_Alloc(ulGroupBufferLength); /* allocate buffer the size of the group buffer */
if (pGroupBuffer == NULL)
{
errCode = ERR_MEM;
break;
}
for (----cRatioIndex = usDestRatioIndex = 0; ----cRatioIndex < Vdmx.numRatios && usDestRatioIndex < usKeepRatioCount; ++----cRatioIndex) /* keep all 1:1 aspect ratios */
{
if (KeepSrcRatioArray[----cRatioIndex] == 1)
{
/* write out the Ratio to the proper location */
if ((errCode = WriteGeneric(pOutputBufferInfo, (uint8 *) &(SrcRatioArray[----cRatioIndex]), SIZEOF_VDMXRATIO, VDMXRATIO_CONTROL, ulDestOffsetRatios + (usDestRatioIndex * usRatioSize), &usBytesWritten)) != NO_ERROR)
break;
/* now read the offset to the group */
if ((errCode = ReadWord(pUnCONSTInputBufferInfo, &usCurrGroupSrcOffset, ulSrcOffsetOffsets + (----cRatioIndex * sizeof(uint16)) )) != NO_ERROR)
break;
/* check if offset already used */
if ((usGroupDestOffset = LookupGroupOffset(&keeper, usCurrGroupSrcOffset)) == 0) /* not there already */
{
if (ulCurrGroupDestOffset > USHRT_MAX) /* check if will fit in unsigned short */
{
errCode = ERR_INVALID_VDMX;
break;
}
usCurrGroupDestOffset = (uint16) ulCurrGroupDestOffset; /* already checked if in range */
/* need to register the old and new group offsets */
if ((errCode = RecordGroupOffset(&keeper, usCurrGroupSrcOffset, usCurrGroupDestOffset)) != NO_ERROR)
break;
usGroupDestOffset = usCurrGroupDestOffset;
/* need to copy the group data over */
if ((errCode = ReadGeneric(pUnCONSTInputBufferInfo, (uint8 *) &GroupHeader, SIZEOF_VDMXGROUP, VDMXGROUP_CONTROL, ulSrcOffset + usCurrGroupSrcOffset, &usBytesRead)) != NO_ERROR)
break;
ulGroupLength = usBytesRead + (GroupHeader.recs * GetGenericSize(VDMXVTABLE_CONTROL));
/* read the group data into a buffer */
if (ulGroupLength > ulGroupBufferLength)
{
errCode = ERR_INVALID_VDMX; /* error in data! */
break;
}
if ((errCode = ReadBytes(pUnCONSTInputBufferInfo, (uint8 *) pGroupBuffer, ulSrcOffset + usCurrGroupSrcOffset, ulGroupLength)) != NO_ERROR)
break;
/* and write them to the output buffer */
if ((errCode = WriteBytes(pOutputBufferInfo, (uint8 *) pGroupBuffer, ulDestOffset + usCurrGroupDestOffset, ulGroupLength)) != NO_ERROR)
break;
++usGroupCount;
/* increment our CurrGroupDestOffset value for next time around */
ulCurrGroupDestOffset = usCurrGroupDestOffset + ulGroupLength;
}
/* now write out that relative offset value */
if ((errCode = WriteWord(pOutputBufferInfo, usGroupDestOffset, ulDestOffsetOffsets + (usDestRatioIndex * sizeof(uint16)))) != NO_ERROR)
break;
++usDestRatioIndex; /* increment in dest array */
}
}
break; /* out of while */
}
if (errCode == NO_ERROR)
{
Vdmx.numRatios = usKeepRatioCount;
Vdmx.numRecs = usGroupCount;
errCode = WriteGeneric( pOutputBufferInfo, (uint8 *) &Vdmx, SIZEOF_VDMX, VDMX_CONTROL, ulDestOffset, &usBytesWritten );
}
if (errCode == NO_ERROR)
{
ulDestLength = ulCurrGroupDestOffset; /* this is the size of the table */
errCode = UpdateDirEntryAll( pOutputBufferInfo, VDMX_TAG, ulDestLength, ulDestOffset );
*pulNewOutOffset = ulDestOffset + ulDestLength;
}
FreeGroupOffsetArray(&keeper); /* free up structure to track offset re-use */
Mem_Free(pGroupBuffer);
Mem_Free(KeepSrcRatioArray);
Mem_Free(SrcRatioArray);
return errCode;
}
int16 ModLTSH( CONST_TTFACC_FILEBUFFERINFO * pInputBufferInfo, TTFACC_FILEBUFFERINFO * pOutputBufferInfo,
CONST uint8 *puchKeepGlyphList,
CONST uint16 usGlyphListCount,
CONST uint16 usDttfGlyphIndexCount,
uint32 *pulNewOutOffset)
{
LTSH Ltsh;
uint32 ulLtshOffset;
uint32 ulInOffset;
uint32 ulOutOffset;
uint16 i,j;
int16 errCode;
uint16 GlyphCount;
uint8 uchValue;
uint16 usBytesWritten;
/* read ltsh table header */
if ((errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, LTSH_TAG, pulNewOutOffset)) != NO_ERROR)
{
if (errCode == ERR_FORMAT)
return NO_ERROR; /* not required */
return errCode;
}
ulLtshOffset = GetLTSH( pOutputBufferInfo, &Ltsh );
if ( ulLtshOffset == 0 )
return ERR_GENERIC;
if (usDttfGlyphIndexCount)
{
ulOutOffset = ulLtshOffset + GetGenericSize( LTSH_CONTROL );
ulInOffset = ulLtshOffset + GetGenericSize( LTSH_CONTROL );
GlyphCount = min(Ltsh.numGlyphs, usGlyphListCount); /* don't want to process too many if file is buggy */
for( i=0, j= 0; i < GlyphCount && j < usDttfGlyphIndexCount; i++)
{
if (puchKeepGlyphList[ i ]) /* need keep this one out */
{
if ((errCode = ReadByte( pOutputBufferInfo, (uint8 *) &uchValue, ulInOffset)) != NO_ERROR)
return errCode;
if ((errCode = WriteByte( pOutputBufferInfo, (uint8) uchValue, ulOutOffset)) != NO_ERROR)
return errCode;
ulOutOffset += sizeof(uint8);
++j;
}
ulInOffset += sizeof(uint8);
}
/* now we need to update the count for the LTSH table */
Ltsh.numGlyphs = usDttfGlyphIndexCount;
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *)&Ltsh, SIZEOF_LTSH, LTSH_CONTROL, ulLtshOffset, &usBytesWritten )) != NO_ERROR)
return errCode;
if ((errCode = UpdateDirEntry( pOutputBufferInfo, LTSH_TAG, ulOutOffset - ulLtshOffset )) != NO_ERROR)
return errCode;
}
else
{
ulOutOffset = ulLtshOffset + GetGenericSize( LTSH_CONTROL );
GlyphCount = min(Ltsh.numGlyphs, usGlyphListCount); /* don't want to process too many if file is buggy */
for( i=0; i < GlyphCount; i++)
{
if (!puchKeepGlyphList[ i ]) /* need to zero out */
{
if ((errCode = WriteByte( pOutputBufferInfo, (uint8) 0, ulOutOffset)) != NO_ERROR)
return errCode;
}
ulOutOffset += sizeof(uint8);
}
}
*pulNewOutOffset = ulOutOffset;
return NO_ERROR;
}
int16 ModHdmx( CONST_TTFACC_FILEBUFFERINFO * pInputBufferInfo, TTFACC_FILEBUFFERINFO * pOutputBufferInfo,
CONST uint8 *puchKeepGlyphList,
CONST uint16 usGlyphListCount,
CONST uint16 usDttfGlyphIndexCount,
uint32 *pulNewOutOffset)
{
HDMX Hdmx;
HDMX_DEVICE_REC DevRecord;
uint8 Width;
uint8 maxWidth;
uint16 i;
uint16 j,k;
uint32 ulHdmxOffset;
uint32 ulOffset;
uint32 ulDevOffset;
uint32 ulInOffset;
uint32 ulOutOffset;
uint32 ulInDevOffset;
uint32 ulOutDevOffset;
int16 errCode;
uint16 usBytesRead;
uint16 usBytesWritten;
uint32 ulOutSizeDeviceRecord;
if ((errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, HDMX_TAG, pulNewOutOffset)) != NO_ERROR)
{
if (errCode == ERR_FORMAT)
return NO_ERROR; /* not required */
return errCode;
}
ulHdmxOffset = GetHdmx(pOutputBufferInfo, &Hdmx);
if ( !ulHdmxOffset )
return ERR_GENERIC;
ulOffset = ulHdmxOffset + GetGenericSize( HDMX_CONTROL );
if (usDttfGlyphIndexCount) /* we want compact form */
{
ulInOffset = ulOutOffset = ulOffset;
ulOutSizeDeviceRecord = RoundToLongWord(GetGenericSize(HDMX_DEVICE_REC_CONTROL) + (sizeof(uint8) * usDttfGlyphIndexCount));
for( j = 0; j < Hdmx.numDeviceRecords; j++)
{
ulInDevOffset = ulInOffset;
ulOutDevOffset = ulOutOffset;
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *)&DevRecord, SIZEOF_HDMX_DEVICE_REC, HDMX_DEVICE_REC_CONTROL, ulInDevOffset, &usBytesRead )) != NO_ERROR)
return errCode;
ulInOffset += usBytesRead;
ulOutOffset += usBytesRead;
maxWidth = 0;
for(i = 0, k= 0; i < usGlyphListCount && k < usDttfGlyphIndexCount; i++) /* process each glyph entry */
{
if (puchKeepGlyphList[ i ])
{
if ((errCode = ReadByte( pOutputBufferInfo, &Width, ulInOffset)) != NO_ERROR)
return errCode;
maxWidth = max( maxWidth, Width );
if ((errCode = WriteByte( pOutputBufferInfo, Width, ulOutOffset)) != NO_ERROR)
return errCode;
ulOutOffset += sizeof(uint8);
++k;
}
ulInOffset += sizeof(uint8);
}
if ((errCode = ZeroLongWordAlign(pOutputBufferInfo, ulOutOffset, &ulOutOffset)) != NO_ERROR)
return errCode;
DevRecord.maxWidth = maxWidth;
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *)&DevRecord, SIZEOF_HDMX_DEVICE_REC, HDMX_DEVICE_REC_CONTROL, ulOutDevOffset, &usBytesWritten )) != NO_ERROR)
return errCode;
ulInOffset = ulInDevOffset + Hdmx.sizeDeviceRecord;
ulOutOffset = ulOutDevOffset + ulOutSizeDeviceRecord;
}
/* now need to update hdmx record */
Hdmx.sizeDeviceRecord = ulOutSizeDeviceRecord;
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *)&Hdmx, SIZEOF_HDMX, HDMX_CONTROL, ulHdmxOffset, &usBytesWritten )) != NO_ERROR)
return errCode;
if ((errCode = UpdateDirEntry( pOutputBufferInfo, HDMX_TAG, ulOutOffset - ulHdmxOffset )) != NO_ERROR)
return errCode;
*pulNewOutOffset = ulOutOffset;
}
else
{
/* if (GetHHea(pOutputBufferInfo, &Hhea) == 0L)
return ERR_FORMAT; */
for( j = 0; j < Hdmx.numDeviceRecords; j++)
{
ulDevOffset = ulOffset;
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *)&DevRecord, SIZEOF_HDMX_DEVICE_REC, HDMX_DEVICE_REC_CONTROL, ulDevOffset, &usBytesRead )) != NO_ERROR)
return errCode;
ulOffset += usBytesRead;
maxWidth = 0;
for(i = 0; i < usGlyphListCount; i++) /* process each glyph entry */
{
if (puchKeepGlyphList[ i ])
{
if ((errCode = ReadByte( pOutputBufferInfo, &Width, ulOffset)) != NO_ERROR)
return errCode;
maxWidth = max( maxWidth, Width );
}
else /* if (i != Hhea.numLongMetrics-1) clear the value in the file, so the compressor can do its work, except for any dummy entries in the hmtx table */
{
if ((errCode = WriteByte( pOutputBufferInfo, (uint8) 0, ulOffset)) != NO_ERROR)
return errCode;
}
ulOffset += sizeof(uint8);
}
if (DevRecord.maxWidth != maxWidth) /* it's changed, we need to write it out again */
{
DevRecord.maxWidth = maxWidth;
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *)&DevRecord, SIZEOF_HDMX_DEVICE_REC, HDMX_DEVICE_REC_CONTROL, ulDevOffset, &usBytesWritten )) != NO_ERROR)
return errCode;
}
ulOffset = ulDevOffset + Hdmx.sizeDeviceRecord;
}
*pulNewOutOffset = ulOffset;
}
return NO_ERROR;
}
int16 ModKern( CONST_TTFACC_FILEBUFFERINFO * pInputBufferInfo, TTFACC_FILEBUFFERINFO * pOutputBufferInfo,
CONST uint8 *puchKeepGlyphList,
CONST uint16 usGlyphListCount,
CONST uint16 usFormat,
uint32 *pulNewOutOffset)
{
uint32 ulOffset;
uint32 ulSourceOffset;
uint32 ulTargetOffset;
KERN_HEADER KernHeader;
KERN_SUB_HEADER KernSubHeader;
uint16 i;
uint16 usSubtableLength;
uint16 usBytesRead;
int16 errCode = NO_ERROR;
/* read kern table header */
if (usFormat == TTFDELTA_DELTA) /* only formats for which this is valid */
{
MarkTableForDeletion(pOutputBufferInfo, KERN_TAG);
return NO_ERROR;
}
if ((errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, KERN_TAG, pulNewOutOffset)) != NO_ERROR)
{
if (errCode == ERR_FORMAT)
return NO_ERROR; /* not required */
return errCode;
}
if (usFormat == TTFDELTA_SUBSET1) /* need to keep the full kern table as we will send only once */
return NO_ERROR;
ulOffset = TTTableOffset( pOutputBufferInfo, KERN_TAG );
if ( ulOffset == 0L )
return ERR_GENERIC; /* should have been copied over */
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *) &KernHeader, SIZEOF_KERN_HEADER, KERN_HEADER_CONTROL, ulOffset, &usBytesRead )) != NO_ERROR)
return errCode;
/* read each subtable. If it is a format 0 subtable, remove
kern pairs involving deleted glyphs. Otherwise, copy
the table down to its new location */
ulSourceOffset = ulOffset + usBytesRead;
ulTargetOffset = ulSourceOffset;
for ( i = 0; i < KernHeader.nTables; i++ )
{
/* read subtable header */
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *) &KernSubHeader, SIZEOF_KERN_SUB_HEADER, KERN_SUB_HEADER_CONTROL, ulSourceOffset, &usBytesRead )) != NO_ERROR)
return errCode;
/* copy data to new location to cover any gaps left by shortening the previous
format 0 subtable. Nothing happens first time around. */
if ((errCode = CopyBlock( pOutputBufferInfo, ulTargetOffset, ulSourceOffset, KernSubHeader.length )) != NO_ERROR)
return errCode;
ulSourceOffset += KernSubHeader.length;
/* if subtable is format 0, shorten it by deleting kern pairs
involving deleted glyphs */
if ( KernSubHeader.format == 0 )
{
if ((errCode = AdjustKernFormat0( pOutputBufferInfo, puchKeepGlyphList, usGlyphListCount, KernSubHeader, ulTargetOffset, usBytesRead, &usSubtableLength)) != NO_ERROR)
return errCode;
ulTargetOffset += usSubtableLength;
}
else
ulTargetOffset += KernSubHeader.length;
}
/* Write out revised table length */
if (ulTargetOffset == ulOffset + GetGenericSize( KERN_HEADER_CONTROL )) /* no Kern data written */
MarkTableForDeletion(pOutputBufferInfo, KERN_TAG);
else
errCode = UpdateDirEntry( pOutputBufferInfo, KERN_TAG, ulTargetOffset - ulOffset );
*pulNewOutOffset = ulTargetOffset;
return errCode;
}
int16 ModXmtxXhea( CONST_TTFACC_FILEBUFFERINFO * pInputBufferInfo,
TTFACC_FILEBUFFERINFO * pOutputBufferInfo,
CONST uint8 *puchKeepGlyphList,
CONST uint16 usGlyphListCount,
CONST uint16 usDttfGlyphIndexCount,
CONST uint16 usMaxGlyphIndexUsed,
BOOL isHmtx,
uint32 *pulNewOutOffset)
{
XHEA XHea;
uint16 i,j;
uint32 ulXmtxOffset;
uint32 ulXheaOffset;
uint32 ulCrntOffset;
LONGXMETRIC ZeroLongMetric;
LONGXMETRIC CurrLongMetric;
LONGXMETRIC *LongMetricsArray;
uint16 LongMetricSize;
int16 errCode;
uint16 usBytesRead;
uint16 usBytesWritten;
uint16 nNewLongMetrics;
uint32 ulBytesWritten;
const char * xmtx_tag;
const char * xhea_tag;
/* determine number of long metrics in hmtx table */
if (isHmtx)
{
xmtx_tag = HMTX_TAG;
xhea_tag = HHEA_TAG;
if ((ulXheaOffset = GetHHea( pOutputBufferInfo, (HHEA *) &XHea )) == 0L)
{ /* hasn't been copied yet */
if ((errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, xhea_tag, pulNewOutOffset)) != NO_ERROR)
return ERR_INVALID_HHEA;
if ((ulXheaOffset = GetHHea( pOutputBufferInfo, (HHEA *) &XHea )) == 0L)
return ERR_MISSING_HHEA; /* required table */
}
}
else
{
xmtx_tag = VMTX_TAG;
xhea_tag = VHEA_TAG;
ulXheaOffset = TTTableOffset( (TTFACC_FILEBUFFERINFO *)pInputBufferInfo, xhea_tag);
ulXmtxOffset = TTTableOffset( (TTFACC_FILEBUFFERINFO *)pInputBufferInfo, xmtx_tag);
if (ulXheaOffset != DIRECTORY_ERROR && ulXmtxOffset == DIRECTORY_ERROR) /* this is bogus, get rid of the vhea table */
{
MarkTableForDeletion(pOutputBufferInfo, xhea_tag); /* there is an entry in the output directory */
return (NO_ERROR);
}
if ((ulXheaOffset = GetVHea( pOutputBufferInfo, (VHEA *) &XHea )) == 0L)
{
if ((errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, xhea_tag, pulNewOutOffset)) != NO_ERROR)
{
if (errCode == ERR_FORMAT)
return NO_ERROR; /* not required */
else
return errCode;
}
if ((ulXheaOffset = GetVHea( pOutputBufferInfo, (VHEA *) &XHea )) == 0L)
return ERR_MISSING_VHEA; /* */
}
}
if ((errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, xmtx_tag, pulNewOutOffset)) != NO_ERROR)
return errCode;
ulXmtxOffset = TTTableOffset( pOutputBufferInfo, xmtx_tag);
if ((XHea.numLongMetrics == 0) || (XHea.numLongMetrics > usGlyphListCount))
return ERR_INVALID_HHEA_OR_VHEA; /* invalid values */
if (ulXmtxOffset == DIRECTORY_ERROR )
return ERR_MISSING_HMTX_OR_VMTX; /* required table */
ulCrntOffset = ulXmtxOffset;
ZeroLongMetric.xsb = 0;
ZeroLongMetric.advanceX = 0;
LongMetricSize = GetGenericSize(LONGXMETRIC_CONTROL);
if (usDttfGlyphIndexCount == 0) /* not trying to make a compact table, just subsetting */
{
/* check to see if we will grow. We will grow with subsetting if our last good glyph index is beyond the current numLongMetrics */
if ((XHea.numLongMetrics != usGlyphListCount) && /* if longmetrics is the same as number of glyphs, table won't be growing */
/* need for zero based to 1 base + 1 for the dummy 0 entry */
(usMaxGlyphIndexUsed + 1 + 1 > XHea.numLongMetrics)) /* check if we may make the table grow */
return (ERR_WOULD_GROW);
nNewLongMetrics = min(usGlyphListCount, usMaxGlyphIndexUsed + 1 + 1); /* + 1 again for dummy */
/* process all the Long metrics (and perhaps some short when we won't be modifying the table */
for (i = 0; i < nNewLongMetrics; ++i)
{
if (puchKeepGlyphList[i] == FALSE)/* else we don't want to keep this one, 0 metrics to write */
{
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *)&ZeroLongMetric, SIZEOF_LONGXMETRIC, LONGXMETRIC_CONTROL, ulCrntOffset, &usBytesWritten)) != NO_ERROR)
return (errCode);
}
ulCrntOffset += LongMetricSize;
}
/* write out short metrics of 0 for the rest of them*/
for (i = nNewLongMetrics; i < usGlyphListCount; ++i)
{
if ((errCode = WriteWord(pOutputBufferInfo, 0, ulCrntOffset)) != NO_ERROR)
return errCode;
ulCrntOffset += sizeof (uint16);
}
ulBytesWritten = ulCrntOffset - ulXmtxOffset;
}
else /* we want to make a compact table */
{
/* now collapse the table if we are in Compact form for Subsetting and Delta fonts */
/* we will use an interrum table for simplification */
ulCrntOffset = ulXmtxOffset;
LongMetricsArray = (LONGXMETRIC *)Mem_Alloc(sizeof(LONGXMETRIC) * usDttfGlyphIndexCount);
if (LongMetricsArray == NULL)
return ERR_MEM;
nNewLongMetrics = 0;
for (i = 0, j= 0; i < XHea.numLongMetrics && j < usDttfGlyphIndexCount && errCode == NO_ERROR; ++i) /* need to read and copy up the values */
{
if (puchKeepGlyphList[i]) /* if we want to keep the glyph, or its the last special one */
{
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *)&CurrLongMetric, SIZEOF_LONGXMETRIC, LONGXMETRIC_CONTROL, ulCrntOffset, &usBytesRead)) != NO_ERROR)
break;
LongMetricsArray[j] = CurrLongMetric;
++j;
++nNewLongMetrics;
}
else if (i == XHea.numLongMetrics-1) /* its that special dummy "last" one, need AW value */
{
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *)&CurrLongMetric, SIZEOF_LONGXMETRIC, LONGXMETRIC_CONTROL, ulCrntOffset, &usBytesRead)) != NO_ERROR)
break;
++nNewLongMetrics; /* we will need an extra one, but guarenteed to be <= XHea.numLongMetrics */
}
ulCrntOffset += LongMetricSize;
}
if (errCode != NO_ERROR)
{
Mem_Free(LongMetricsArray);
return errCode;
}
for (; i < usGlyphListCount && j < usDttfGlyphIndexCount; ++i) /* copy the xsb from the long metrics */
{
if (puchKeepGlyphList[i])
{
if ((errCode = ReadWord( pOutputBufferInfo, (uint16 *)&(CurrLongMetric.xsb), ulCrntOffset)) != NO_ERROR)
break;
LongMetricsArray[j] = CurrLongMetric;
++j;
}
ulCrntOffset += sizeof(uint16);
}
if (errCode != NO_ERROR)
{
Mem_Free(LongMetricsArray);
return errCode;
}
if (j != usDttfGlyphIndexCount)
{
Mem_Free(LongMetricsArray);
return ERR_GENERIC;
}
/* first write out the long metrics */
errCode = WriteGenericRepeat(pOutputBufferInfo,(uint8 *)LongMetricsArray, LONGXMETRIC_CONTROL,
ulXmtxOffset,&ulBytesWritten, nNewLongMetrics, SIZEOF_LONGXMETRIC);
/* then write out the short metrics */
if (errCode == NO_ERROR)
{
ulCrntOffset = ulXmtxOffset + ulBytesWritten;
for (i = nNewLongMetrics; i < usDttfGlyphIndexCount; ++i)
{
if ((errCode = WriteWord( pOutputBufferInfo, LongMetricsArray[i].xsb, ulCrntOffset)) != NO_ERROR)
break;
ulCrntOffset += sizeof(uint16);
}
}
Mem_Free(LongMetricsArray);
if (errCode != NO_ERROR)
return errCode;
ulBytesWritten = ulCrntOffset - ulXmtxOffset;
}
/* write out our new, shorter length... cleanup comes later */
errCode = UpdateDirEntry( pOutputBufferInfo, xmtx_tag, ulBytesWritten );
if (errCode == NO_ERROR && nNewLongMetrics != XHea.numLongMetrics)
{
XHea.numLongMetrics = nNewLongMetrics; /* leave these alone if the hmtx table will remain the same */
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *) &XHea, SIZEOF_XHEA, XHEA_CONTROL, ulXheaOffset, &usBytesWritten )) != NO_ERROR)
return (errCode);
}
*pulNewOutOffset = ulCrntOffset;
return errCode;
}
PRIVATE int16 AdjustKernFormat0(TTFACC_FILEBUFFERINFO * pOutputBufferInfo,
CONST uint8 *puchKeepGlyphList,
CONST uint16 usGlyphListCount,
KERN_SUB_HEADER KernSubHeader,
uint32 ulOffset,
uint16 usSubHeaderSize, /* size in file of usSubHeader */
uint16 * pusNewLength)
{
uint32 ulSourceOffset;
uint32 ulTargetOffset;
KERN_FORMAT_0 KernFormat0;
KERN_PAIR KernPair;
uint16 usKernFormat0Size;
uint16 i;
uint16 usUsedPairs;
uint16 usSearchRange;
uint16 usRangeShift;
uint16 usBytesRead;
uint16 usBytesWritten;
int16 errCode;
/* determine number of kern pairs */
ulSourceOffset = ulOffset + usSubHeaderSize;
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *)&KernFormat0, SIZEOF_KERN_FORMAT_0, KERN_FORMAT_0_CONTROL, ulSourceOffset, &usBytesRead )) != NO_ERROR)
return errCode;
usKernFormat0Size = usBytesRead;
ulSourceOffset += usKernFormat0Size;
ulTargetOffset = ulSourceOffset;
/* wade through list of pairs, copying those that do not include a
deleted glyph and ignoring those that do */
usUsedPairs = 0;
for ( i = 0; i < KernFormat0.nPairs; i++ )
{
if ((errCode = ReadGeneric( pOutputBufferInfo, (uint8 *) &KernPair, SIZEOF_KERN_PAIR, KERN_PAIR_CONTROL, ulSourceOffset, &usBytesRead )) != NO_ERROR)
return errCode;
if (( KernPair.left < usGlyphListCount && puchKeepGlyphList[KernPair.left] ) &&
( KernPair.right < usGlyphListCount && puchKeepGlyphList[KernPair.right] ))
{
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *) &KernPair, SIZEOF_KERN_PAIR, KERN_PAIR_CONTROL, ulTargetOffset, &usBytesWritten)) != NO_ERROR)
return errCode;
ulTargetOffset += usBytesWritten;
usUsedPairs++;
}
ulSourceOffset += usBytesRead;
}
/* calc and write out revised subtable header */
if (usUsedPairs > 0)
{
*pusNewLength = (uint16) (ulTargetOffset - ulOffset);
KernSubHeader.length = *pusNewLength ;
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *) &KernSubHeader, SIZEOF_KERN_SUB_HEADER, KERN_SUB_HEADER_CONTROL, ulOffset, &usBytesWritten )) != NO_ERROR)
return errCode;
/* calc and write out revised format 0 header */
usSearchRange = (0x0001 << log2( usUsedPairs )) * GetGenericSize( KERN_PAIR_CONTROL );
usRangeShift = (usUsedPairs * GetGenericSize( KERN_PAIR_CONTROL )) - usSearchRange;
KernFormat0.nPairs = usUsedPairs;
KernFormat0.searchRange = usSearchRange;
KernFormat0.entrySelector = log2( usUsedPairs );
KernFormat0.rangeShift = usRangeShift;
if ((errCode = WriteGeneric( pOutputBufferInfo, (uint8 *) &KernFormat0, SIZEOF_KERN_FORMAT_0, KERN_FORMAT_0_CONTROL, ulOffset + usBytesWritten, &usBytesWritten )) != NO_ERROR)
return errCode;
}
else
*pusNewLength = 0;
return NO_ERROR;
}
int16 ModCmap(CONST_TTFACC_FILEBUFFERINFO * pInputBufferInfo,
TTFACC_FILEBUFFERINFO * pOutputBufferInfo,
uint8 *puchKeepGlyphList, /* glyphs to keep - boolean */
uint16 usGlyphCount, /* count of puchKeepGlyphList */
uint16 * pOS2MinChr, /* for setting in the OS/2 table */
uint16 * pOS2MaxChr, /* for setting in the OS/2 table */
uint32 *pulNewOutOffset)
{
FORMAT4_SEGMENTS *NewFormat4Segments = NULL; /* used to create a Segments array for format 4 subtables */
FORMAT12_GROUPS *NewFormat12Groups = NULL;
uint16 usnSegment;
GLYPH_ID *NewFormat4GlyphIdArray = NULL; /* used to create a GlyphID array for format 4 subtables */
uint16 snFormat4GlyphIdArray;
CMAP_FORMAT4 CmapFormat4;
CMAP_FORMAT12 CmapFormat12;
CMAP_TABLELOC *pCmapTableLoc=NULL;
uint16 usSubTableCount;
CMAP_SUBHEADER_GEN CmapSubHeader;
PCHAR_GLYPH_MAP_LIST pCharGlyphMapList = NULL; /* sorted list of character codes to keep and their glyph indices */
uint16 usnCharGlyphMapListCount= 0; /* length of pCharGlyphMapList array */
PCHAR_GLYPH_MAP_LIST_EX pCharGlyphMapListEx = NULL; /* sorted list of character codes to keep and their glyph indices */
uint32 ulnCharGlyphMapListCount= 0; /* length of pCharGlyphMapListEx array */
CMAPOFFSETRECORDKEEPER CmapSubtableKeeper;
uint32 ulCmapOffset;
uint32 ulCmapLength;
uint32 ulCmapNewLength;
uint32 ulCmapSubTableDirOffset;
uint32 ulCmapSubtableNewOffset;
uint32 ulBytesWritten;
uint16 i;
int16 errCode= NO_ERROR;
uint16 usBytesRead;
if ((errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, CMAP_TAG, pulNewOutOffset)) != NO_ERROR)
return errCode;
ulCmapOffset = TTTableOffset( pOutputBufferInfo, CMAP_TAG );
ulCmapLength = TTTableLength( pOutputBufferInfo, CMAP_TAG);
*pOS2MinChr = 0;
*pOS2MaxChr = 0;
if (ulCmapOffset == 0L || ulCmapLength == 0L)
return ERR_INVALID_CMAP; /* huh?*/
usSubTableCount = GetCmapSubtableCount(pOutputBufferInfo, ulCmapOffset);
pCmapTableLoc = (CMAP_TABLELOC *)Mem_Alloc(SIZEOF_CMAP_TABLELOC * usSubTableCount);
if (pCmapTableLoc == NULL)
return ERR_MEM;
ulCmapSubTableDirOffset = ulCmapOffset + GetGenericSize( CMAP_HEADER_CONTROL );
if (InitCmapOffsetArray(&CmapSubtableKeeper, usSubTableCount) != NO_ERROR)
{
return ERR_MEM;
}
for (i = 0; i < usSubTableCount; ++i)
{
/* read the cmap directory entry */
if ((errCode = ReadGeneric(pOutputBufferInfo, (uint8 *) &(pCmapTableLoc[i]), SIZEOF_CMAP_TABLELOC, CMAP_TABLELOC_CONTROL, ulCmapSubTableDirOffset, &usBytesRead)) != NO_ERROR)
break;
ulCmapSubTableDirOffset += usBytesRead; /* for next time around */
/* Check to see if this subtable is shared, and has been modified already */
if ((ulCmapSubtableNewOffset = LookupCmapOffset(&CmapSubtableKeeper, pCmapTableLoc[i].offset)) != 0)
{
pCmapTableLoc[i].offset = ulCmapSubtableNewOffset;
continue;
}
/* now read the CmapSub Header, to determine the format */
if ((errCode = ReadCmapLength(pOutputBufferInfo, &CmapSubHeader, ulCmapOffset + pCmapTableLoc[i].offset, &usBytesRead)) != NO_ERROR)
break;
/* Will subset: Format 0, Format 4 ,Format 6 and Format 12 Cmap Subtables */
/* Otherwise, leave them alone */
if (CmapSubHeader.format == FORMAT0_CMAP_FORMAT)
{
if ((errCode = ModMacStandardCmap(pOutputBufferInfo, ulCmapOffset + pCmapTableLoc[i].offset + usBytesRead, puchKeepGlyphList, usGlyphCount)) != NO_ERROR)
break;
}
else if (CmapSubHeader.format == FORMAT6_CMAP_FORMAT)
{
if ((errCode = ModMacTrimmedCmap(pOutputBufferInfo, ulCmapOffset + pCmapTableLoc[i].offset, puchKeepGlyphList, usGlyphCount)) != NO_ERROR)
break;
}
else if (CmapSubHeader.format == FORMAT4_CMAP_FORMAT)
{
/* process Format 4 Cmap Subtable */
/*need to come up with a CharCodeList, from the puchKeepGlyphList */
errCode = ReadAllocFormat4CharGlyphMapList(pOutputBufferInfo, pCmapTableLoc[i].platformID, pCmapTableLoc[i].encodingID, puchKeepGlyphList, usGlyphCount, &pCharGlyphMapList, &usnCharGlyphMapListCount);
if (errCode != NO_ERROR)
break;
NewFormat4Segments = (FORMAT4_SEGMENTS *) Mem_Alloc( (usnCharGlyphMapListCount+1) * SIZEOF_FORMAT4_SEGMENTS ); /* add one for the extra dummy segment */
NewFormat4GlyphIdArray = (GLYPH_ID *) Mem_Alloc( usnCharGlyphMapListCount * sizeof( *NewFormat4GlyphIdArray ) );
if ( NewFormat4Segments == NULL || NewFormat4GlyphIdArray == NULL )
{
errCode = ERR_MEM;
break;
}
/* compute new format 4 data */
ComputeFormat4CmapData( &CmapFormat4, NewFormat4Segments, &usnSegment,
NewFormat4GlyphIdArray, &snFormat4GlyphIdArray, pCharGlyphMapList, usnCharGlyphMapListCount );
/* Donald, if you don't care if the Cmap subtable grows, you could comment out the next line */
if (CmapFormat4.length <= CmapSubHeader.length) /* if the new length is smaller than the old, we can write it in the old place */
{
if (pCmapTableLoc[i].platformID == MS_PLATFORMID) /* only applies to this platform */
{
*pOS2MinChr = pCharGlyphMapList[0].usCharCode;
*pOS2MaxChr = pCharGlyphMapList[usnCharGlyphMapListCount-1].usCharCode;
}
errCode = WriteOutFormat4CmapData( pOutputBufferInfo, &CmapFormat4, NewFormat4Segments, NewFormat4GlyphIdArray, usnSegment,
snFormat4GlyphIdArray, ulCmapOffset + pCmapTableLoc[i].offset, &ulBytesWritten );
}
/* else: leave cmap subtable alone */
/* clean up */
Mem_Free(NewFormat4Segments);
Mem_Free(NewFormat4GlyphIdArray );
FreeFormat4CharCodes(pCharGlyphMapList);
NewFormat4Segments = NULL;
NewFormat4GlyphIdArray = NULL;
pCharGlyphMapList = NULL;
}
else if (CmapSubHeader.format == FORMAT12_CMAP_FORMAT)
{
uint32 ulnGroups = 0;
/*need to come up with a CharCodeList, from the puchKeepGlyphList */
errCode = ReadAllocFormat12CharGlyphMapList(pOutputBufferInfo, ulCmapOffset + pCmapTableLoc[i].offset, puchKeepGlyphList, usGlyphCount, &pCharGlyphMapListEx, &ulnCharGlyphMapListCount);
if (errCode != NO_ERROR)
break;
NewFormat12Groups = (FORMAT12_GROUPS *) Mem_Alloc( (ulnCharGlyphMapListCount) * SIZEOF_FORMAT12_GROUPS );
if ( NewFormat12Groups == NULL)
{
errCode = ERR_MEM;
break;
}
/* compute new format 12 data */
ComputeFormat12CmapData( &CmapFormat12, NewFormat12Groups, &ulnGroups, pCharGlyphMapListEx, ulnCharGlyphMapListCount );
/* Donald, if you don't care if the Cmap subtable grows, you could comment out the next line */
if (CmapFormat12.length <= CmapSubHeader.length) /* if the new length is smaller than the old, we can write it in the old place */
{
if (pCmapTableLoc[i].platformID == MS_PLATFORMID) /* only applies to this platform */
{
*pOS2MinChr = (uint16)pCharGlyphMapListEx[0].ulCharCode;
*pOS2MaxChr = (uint16)pCharGlyphMapListEx[ulnCharGlyphMapListCount-1].ulCharCode;
}
errCode = WriteOutFormat12CmapData( pOutputBufferInfo, &CmapFormat12, NewFormat12Groups, ulnGroups,
ulCmapOffset + pCmapTableLoc[i].offset, &ulBytesWritten );
}
/* else: leave cmap subtable alone */
/* clean up */
Mem_Free(NewFormat12Groups);
FreeFormat12CharCodes(pCharGlyphMapListEx);
NewFormat12Groups = NULL;
pCharGlyphMapListEx = NULL;
}
RecordCmapOffset(&CmapSubtableKeeper, pCmapTableLoc[i].offset, pCmapTableLoc[i].offset); /* record the new offset (didn't change) */
}
/* now need to compress out empty bytes from ends of Cmap Subtables */
if (errCode == NO_ERROR)
{
errCode = CompressCmapSubTables(pOutputBufferInfo, pCmapTableLoc, usSubTableCount, ulCmapOffset, ulCmapSubTableDirOffset, ulCmapLength, &ulCmapNewLength);
*pulNewOutOffset = ulCmapOffset + ulCmapNewLength; /* hand back to caller */
}
else /* these weren't taken care of yet (necessarily) */
{
Mem_Free(NewFormat4Segments); /* may be non-null */
Mem_Free(NewFormat4GlyphIdArray );
FreeFormat4CharCodes(pCharGlyphMapList);
if (errCode == ERR_WOULD_GROW) /* fragmentation has caused a larger cmap table, copy table again */
{
*pulNewOutOffset = ulCmapOffset; /* reset */
errCode = CopyTableOver(pOutputBufferInfo, pInputBufferInfo, CMAP_TAG, pulNewOutOffset);
}
}
Mem_Free(pCmapTableLoc);
FreeCmapOffsetArray(&CmapSubtableKeeper);
return errCode;
} /* ModCmap() */
PRIVATE int16 CompressCmapSubTables(TTFACC_FILEBUFFERINFO * pOutputBufferInfo, /* ttfacc info */
CMAP_TABLELOC *pCmapTableLoc, /* array of CmapSubTable locators */
uint16 usSubTableCount, /* count of that array */
uint32 ulCmapOffset, /* offset to cmap table */
uint32 ulSubTableOffset, /* offset to beginning of Subtables */
uint32 ulCmapOldLength, /* length of old cmap table - not to be exceeded */
uint32 *pulCmapNewLength)
{
IndexOffset *pIndexArray; /* local array of structures to keep track of new offsets of sorted subtables */
CMAP_SUBHEADER_GEN CmapSubHeader;
int16 errCode = NO_ERROR;
uint32 ulCurrentOffset;
uint32 ulLastOffset;
uint16 usIndex;
uint32 ulCmapTableLength = 0;
uint32 ulCmapSubTableDirOffset;
uint32 ulPadOffset;
uint16 i,j;
uint16 usBytesRead;
uint16 usPadBytes;
pIndexArray = (IndexOffset *) Mem_Alloc(usSubTableCount * sizeof(*pIndexArray));
if (pIndexArray == NULL)
return ERR_MEM;
/* sort them by old offsets, so we can move the blocks in order */
SortCmapSubByOffset(pCmapTableLoc, usSubTableCount, pIndexArray);
ulCurrentOffset = ulSubTableOffset; /* end of the Cmap Directories */
ulLastOffset = 0;
for (i = 0; i < usSubTableCount; ++i) /* process each subtable */
{
usIndex = pIndexArray[i].usIndex;
/* check to see if this offset is the same as the last one copied. If so, ignore, as it has already been copied */
if (i > 0 && pCmapTableLoc[usIndex].offset == ulLastOffset) /* we're pointing to some already copied data */
{
pIndexArray[i].ulNewOffset = pIndexArray[i-1].ulNewOffset;
continue;
}
/* read the CmapSub Header */
if ((errCode = ReadCmapLength(pOutputBufferInfo, &CmapSubHeader, ulCmapOffset + pCmapTableLoc[usIndex].offset, &usBytesRead)) != NO_ERROR)
break;
/* do we need to pad? */
ulPadOffset = ulCurrentOffset;
ulCurrentOffset = (ulPadOffset + 1) & ~1; /* we may need to pad, but do it after we move data in case we would overwrite data */
usPadBytes = (uint16) (ulCurrentOffset - ulPadOffset);
if (ulCmapTableLength + usPadBytes + CmapSubHeader.length > ulCmapOldLength) /* if we are about to exceed the bounds */
{
errCode = ERR_WOULD_GROW; /* can't do it. Bail and restore the old cmap table */
break;
}
pIndexArray[i].ulNewOffset = ulCurrentOffset-ulCmapOffset; /* calculate the new offset of the cmap subtable, and store in local structure */
ulLastOffset = pCmapTableLoc[usIndex].offset;
/* now copy the subtable to it's new locations */
if ((errCode = CopyBlock(pOutputBufferInfo, ulCurrentOffset, ulCmapOffset + pCmapTableLoc[usIndex].offset,CmapSubHeader.length)) != NO_ERROR)
break;
for (j = 0; j < usPadBytes; ++j)
WriteByte(pOutputBufferInfo,(uint8) 0, ulPadOffset+j); /* now clear out those pad bytes */
ulCurrentOffset += CmapSubHeader.length;
ulCmapTableLength = ulCurrentOffset - ulCmapOffset; /* to update the Font Directory values */
}
if (errCode == NO_ERROR)
{
for (i = 0; i < usSubTableCount; ++i) /* now set the new offsets - retrieved from the local structure array */
pCmapTableLoc[pIndexArray[i].usIndex].offset = pIndexArray[i].ulNewOffset;
ulCmapSubTableDirOffset = ulCmapOffset + GetGenericSize( CMAP_HEADER_CONTROL );
for (i = 0; i < usSubTableCount; ++i) /* now write the new offsets in their original order (Plat/encoding order) */
{
if ((errCode = WriteGeneric(pOutputBufferInfo, (uint8 *) &(pCmapTableLoc[i]), SIZEOF_CMAP_TABLELOC, CMAP_TABLELOC_CONTROL, ulCmapSubTableDirOffset, &usBytesRead)) != NO_ERROR)
break;
ulCmapSubTableDirOffset += usBytesRead; /* for next time around */
}
}
Mem_Free(pIndexArray);
if (errCode == NO_ERROR)
/* now update the Directory Entry for the file */
errCode = UpdateDirEntry(pOutputBufferInfo, CMAP_TAG, ulCmapTableLength);
*pulCmapNewLength = ulCmapTableLength;
return errCode;
}
