PascalType.Tables.OpenType.Substitution.ReverseChainedContext.pas

unit PascalType.Tables.OpenType.Substitution.ReverseChainedContext;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  Version: MPL 1.1 or LGPL 2.1 with linking exception                       //
//                                                                            //
//  The contents of this file are subject to the Mozilla Public License       //
//  Version 1.1 (the "License"); you may not use this file except in          //
//  compliance with the License. You may obtain a copy of the License at      //
//  http://www.mozilla.org/MPL/                                               //
//                                                                            //
//  Software distributed under the License is distributed on an "AS IS"       //
//  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the   //
//  License for the specific language governing rights and limitations under  //
//  the License.                                                              //
//                                                                            //
//  Alternatively, the contents of this file may be used under the terms of   //
//  the Free Pascal modified version of the GNU Lesser General Public         //
//  License Version 2.1 (the "FPC modified LGPL License"), in which case the  //
//  provisions of this license are applicable instead of those above.         //
//  Please see the file LICENSE.txt for additional information concerning     //
//  this license.                                                             //
//                                                                            //
//  The code is part of the PascalType Project                                //
//                                                                            //
//  The initial developer of this code is Christian-W. Budde                  //
//                                                                            //
//  Portions created by Christian-W. Budde are Copyright (C) 2010-2017        //
//  by Christian-W. Budde. All Rights Reserved.                               //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

uses
  Generics.Collections,
  Generics.Defaults,
  Classes,
  PascalType.Classes,
  PascalType.Types,
  PascalType.GlyphString,
  PascalType.Tables.OpenType.Lookup,
  PascalType.Tables.OpenType.Substitution,
  PascalType.Tables.OpenType.ClassDefinition,
  PascalType.Tables.OpenType.Coverage;

//------------------------------------------------------------------------------
//
//      TOpenTypeSubstitutionLookupTableReverseChainedContext
//
//------------------------------------------------------------------------------
// LookupType 8: Reverse Chaining Contextual Single Substitution Subtable
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/gsub#lookuptype-8-reverse-chaining-contextual-single-substitution-subtable
//------------------------------------------------------------------------------
type
  TOpenTypeSubstitutionLookupTableReverseChainedContext = class(TCustomOpenTypeSubstitutionLookupTable)
  public type
    TGlyphContextSubstitution = (
      grccsInvalid        = 0,
      grccsCoverage       = 1
    );
  protected
    function GetSubTableClass(ASubFormat: Word): TOpenTypeLookupSubTableClass; override;
    function GetUseReverseDirection: boolean; override;
  public
  end;


//------------------------------------------------------------------------------
//
//      TOpenTypeSubstitutionSubTableReverseChainedContextCoverage
//
//------------------------------------------------------------------------------
// Reverse Chaining Contextual Single Substitution Format 1: Coverage-based Glyph Contexts
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/gsub#81-reverse-chaining-contextual-single-substitution-format-1-coverage-based-glyph-contexts
// https://learn.microsoft.com/en-us/typography/opentype/spec/gsub#RCCS
//------------------------------------------------------------------------------
type
  TOpenTypeSubstitutionSubTableReverseChainedContextCoverage = class(TCustomOpenTypeLookupSubTable)
  private type
    TCoverageTables = TCustomOpenTypeLookupSubTable.TCoverageTables;
    TContextCoverageTables = TCustomOpenTypeLookupSubTable.TContextCoverageTables;

  private
    FCoverageTables: TContextCoverageTables;
    FSubstituteGlyphIDs: TGlyphString;

  protected
    procedure SetCoverageTables(Index: TContextPart; Value: TCoverageTables);

  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;

    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    function Apply(var AGlyphIterator: TPascalTypeGlyphIterator): boolean; override;

    property BacktrackCoverageTables: TCoverageTables index cpBacktrack read FCoverageTables[cpBacktrack] write SetCoverageTables;
    property InputCoverageTables: TCoverageTables index cpInput read FCoverageTables[cpInput] write SetCoverageTables;
    property LookaheadCoverageTables: TCoverageTables index cpLookahead read FCoverageTables[cpLookahead] write SetCoverageTables;
    property Substitution: TGlyphString read FSubstituteGlyphIDs write FSubstituteGlyphIDs;
  end;


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

implementation

uses
  SysUtils,
  PascalType.Unicode,
  PascalType.ResourceStrings,
  PascalType.Tables.OpenType.GSUB;

//------------------------------------------------------------------------------
//
//              TOpenTypeSubstitutionLookupTableReverseChainedContext
//
//------------------------------------------------------------------------------
function TOpenTypeSubstitutionLookupTableReverseChainedContext.GetSubTableClass(ASubFormat: Word): TOpenTypeLookupSubTableClass;
begin
  case TGlyphContextSubstitution(ASubFormat) of

    grccsCoverage:
      Result := TOpenTypeSubstitutionSubTableReverseChainedContextCoverage;

  else
    Result := nil;
  end;
end;

function TOpenTypeSubstitutionLookupTableReverseChainedContext.GetUseReverseDirection: boolean;
begin
  Result := True;
end;


//------------------------------------------------------------------------------
//
//              TOpenTypeSubstitutionSubTableReverseChainedContextCoverage
//
//------------------------------------------------------------------------------
constructor TOpenTypeSubstitutionSubTableReverseChainedContextCoverage.Create(AParent: TCustomPascalTypeTable);
var
  Part: TContextPart;
begin
  inherited;

  for Part := Low(TContextPart) to High(TContextPart) do
    FCoverageTables[Part] := TObjectList<TCustomOpenTypeCoverageTable>.Create;
end;

destructor TOpenTypeSubstitutionSubTableReverseChainedContextCoverage.Destroy;
var
  Part: TContextPart;
begin
  for Part := Low(TContextPart) to High(TContextPart) do
    FCoverageTables[Part].Free;

  inherited;
end;

procedure TOpenTypeSubstitutionSubTableReverseChainedContextCoverage.Assign(Source: TPersistent);
var
  Part: TContextPart;
begin
  inherited;
  if Source is TOpenTypeSubstitutionSubTableReverseChainedContextCoverage then
  begin
    FSubstituteGlyphIDs := Copy(TOpenTypeSubstitutionSubTableReverseChainedContextCoverage(Source).Substitution);
    // Assignment via property setter makes a copy
    for Part := Low(TContextPart) to High(TContextPart) do
      SetCoverageTables(Part, TOpenTypeSubstitutionSubTableReverseChainedContextCoverage(Source).FCoverageTables[Part]);
  end;
end;

procedure TOpenTypeSubstitutionSubTableReverseChainedContextCoverage.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  Part: TContextPart;
  i: integer;
  CoverageOffsets: array[TContextPart] of array of Word;
  CoverageTable: TCustomOpenTypeCoverageTable;
begin
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | Type     | Name                                          | Description                                  |
  // +==========+===============================================+==============================================+
  // | uint16   | substFormat                                   | Format identifier: format = 1                |
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | Offset16 | coverageOffset                                | Offset to Coverage table, from beginning     |
  // |          |                                               | of substitution subtable.                    |
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | uint16   | backtrackGlyphCount                           | Number of glyphs in the backtrack sequence.  |
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | Offset16 | backtrackCoverageOffsets[backtrackGlyphCount] | Array of offsets to coverage tables in       |
  // |          |                                               | backtrack sequence, in glyph sequence        |
  // |          |                                               | order.                                       |
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | uint16   | lookaheadGlyphCount                           | Number of glyphs in lookahead sequence.      |
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | Offset16 | lookaheadCoverageOffsets[lookaheadGlyphCount] | Array of offsets to coverage tables in       |
  // |          |                                               | lookahead sequence, in glyph sequence order. |
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | uint16   | glyphCount                                    | Number of glyph IDs in the                   |
  // |          |                                               | substituteGlyphIDs array.                    |
  // +----------+-----------------------------------------------+----------------------------------------------+
  // | uint16   | substituteGlyphIDs[glyphCount]                | Array of substitute glyph IDs - ordered      |
  // |          |                                               | by Coverage index.                           |
  // +----------+-----------------------------------------------+----------------------------------------------+

  // Test font: "DejaVu Sans Mono with Numderline", Text: 1234 (every second block of 3 numbers becomes underlined)

  SetLength(FSubstituteGlyphIDs, 0);
  for Part := Low(FCoverageTables) to High(FCoverageTables) do
    FCoverageTables[Part].Clear;

  StartPos := Stream.Position;

  inherited;

  // Read coverage table offsets
  SetLength(CoverageOffsets[cpInput], 1);
  CoverageOffsets[cpInput][0] := BigEndianValue.ReadWord(Stream);

  SetLength(CoverageOffsets[cpBacktrack], BigEndianValue.ReadWord(Stream));
  for i := 0 to High(CoverageOffsets[cpBacktrack]) do
    CoverageOffsets[cpBacktrack][i] := BigEndianValue.ReadWord(Stream);

  SetLength(CoverageOffsets[cpLookahead], BigEndianValue.ReadWord(Stream));
  for i := 0 to High(CoverageOffsets[cpLookahead]) do
    CoverageOffsets[cpLookahead][i] := BigEndianValue.ReadWord(Stream);

  // Read substitution
  SetLength(FSubstituteGlyphIDs, BigEndianValue.ReadWord(Stream));
  for i := 0 to High(FSubstituteGlyphIDs) do
    FSubstituteGlyphIDs[i] := BigEndianValue.ReadWord(Stream);

  // Read the coverage tables
  for Part := Low(FCoverageTables) to High(FCoverageTables) do
  begin
    FCoverageTables[Part].Capacity := Length(CoverageOffsets[Part]);
    for i := 0 to High(CoverageOffsets[Part]) do
    begin
      Stream.Position := StartPos + CoverageOffsets[Part][i];
      CoverageTable := TCustomOpenTypeCoverageTable.CreateFromStream(Stream);
      FCoverageTables[Part].Add(CoverageTable);
    end;
  end;
end;

procedure TOpenTypeSubstitutionSubTableReverseChainedContextCoverage.SaveToStream(Stream: TStream);
var
  StartPos: Int64;
  SavePos: Int64;
  i, j: integer;
  CoverageOffsetPos: array [TContextPart] of Int64;
  CoverageOffsets: array [TContextPart] of array of Word;
  Part: TContextPart;
begin
  StartPos := Stream.Position;

  inherited;

  for Part := cpBacktrack to cpLookahead do
  begin
    if (Part = cpInput) then
      continue;

    BigEndianValue.WriteWord(Stream, FCoverageTables[Part].Count);

    CoverageOffsetPos[Part] := Stream.Position;
    Stream.Seek(FCoverageTables[Part].Count * SizeOf(Word), soFromCurrent);
  end;

  BigEndianValue.WriteWord(Stream, Length(FSubstituteGlyphIDs));
  for i := 0 to High(FSubstituteGlyphIDs) do
    BigEndianValue.WriteWord(Stream, FSubstituteGlyphIDs[i]);

  for Part := cpBacktrack to cpLookahead do
  begin
    if (Part = cpInput) then
      continue;

    for j := 0 to FCoverageTables[Part].Count - 1 do
    begin
      CoverageOffsets[Part, j] := Stream.Position - StartPos;
      FCoverageTables[Part][j].SaveToStream(Stream);
    end;
  end;

  SavePos := Stream.Position;

  for Part := cpBacktrack to cpLookahead do
  begin
    if (Part = cpInput) then
      continue;

    Stream.Position := CoverageOffsetPos[Part];

    for j := 0 to High(CoverageOffsets[Part]) do
      BigEndianValue.WriteWord(Stream, CoverageOffsets[Part, j]);
  end;

  Stream.Position := SavePos;
end;

procedure TOpenTypeSubstitutionSubTableReverseChainedContextCoverage.SetCoverageTables(Index: TContextPart; Value: TCoverageTables);
var
  CoverageTable: TCustomOpenTypeCoverageTable;
  NewCoverageTable: TCustomOpenTypeCoverageTable;
begin
  FCoverageTables[Index].Clear;

  if (Value = nil) then
    exit;

  for CoverageTable in Value do
  begin
    NewCoverageTable := CoverageTable.Clone;
    FCoverageTables[Index].Add(NewCoverageTable);
  end;
end;

function TOpenTypeSubstitutionSubTableReverseChainedContextCoverage.Apply(var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
begin
  Result := False;

  Assert(LookupTable.UseReverseDirection);

  if (AGlyphIterator.EOF) then
    exit;

  // Quick short-circuit exit.
  // We can get away with not taking the iterator filters into account here
  // because the filters would only ever reduce the effective length of the
  // glyph string, so if the sequences are larger than the raw glyph string,
  // then they will also be larger than the filtered glyph string.
  //
  // 1) There needs to be enough glyphs to matching input+lookahead, starting
  //    at the current glyph.
  //    We use ">=" instead of ">" because we know that
  //    FCoverageTables[cpInput].Count = 1
  if (AGlyphIterator.Index + FCoverageTables[cpLookahead].Count >= AGlyphIterator.GlyphString.Count) then
    exit;
  // 2) There needs to be enough glyphs to match backtrack, before the
  //    current glyph.
  if (AGlyphIterator.Index < FCoverageTables[cpBacktrack].Count) then
    exit;

  var Iterator := AGlyphIterator.Clone;

  // Input
  // The coverage index we get here specifies the (single) replacement character index.
  // Note that we know there is just a single coverage table.
  var ReplacementIndex := FCoverageTables[cpInput][0].IndexOfGlyph(Iterator.Glyph.GlyphID);
  if (ReplacementIndex = -1) then
    exit;

  // The string is matched, character by character, against the backtrack and lookahead coverage tables.
  // The coverage index itself isn't used. We just need to determine if we should proceed.

  // Backtrack
  if (FCoverageTables[cpBacktrack].Count > 0) then
  begin
    // "The backtrack sequence is specified in glyph sequence order, with the first offset in
    //  the array (index 0) corresponding to the glyph in the sequence furthest from the input
    //  glyph."
    Iterator.Index := AGlyphIterator.Peek(-FCoverageTables[cpBacktrack].Count);

    // Note: We match *forwards* in the glyph string; Don't specify the [moBacktrack] option!
    if (not MatchCoverage(Iterator, FCoverageTables[cpBacktrack])) then
      exit;
  end;

  // Lookahead
  if (FCoverageTables[cpLookahead].Count > 0) then
  begin
    // Reset to after Input sequence (just a single glyph)...
    Iterator.Index := AGlyphIterator.Peek(1);

    if (not MatchCoverage(Iterator, FCoverageTables[cpLookahead])) then
      exit;
  end;

  // We have a match; Apply the substitution.
  Result := True;

  AGlyphIterator.Glyph.GlyphID := FSubstituteGlyphIDs[ReplacementIndex];

  // Previous instead of Next because we are the *Reverse* Chaining Contextual Single Substitution
  AGlyphIterator.Previous;
end;

//------------------------------------------------------------------------------

initialization
  TCustomOpenTypeSubstitutionLookupTable.RegisterSubstitutionFormat(gsReverseChainingContextSingle, TOpenTypeSubstitutionLookupTableReverseChainedContext);
end.