PascalType.Tables.OpenType.Common.Variation.pas

unit PascalType.Tables.OpenType.Common.Variation;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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 Anders Melander                     //
//                                                                            //
//  Portions created by Anders Melander are Copyright (C) 2025-2026           //
//  by Anders Melander. All Rights Reserved.                                  //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

uses
  Classes,
  SysUtils,
  Generics.Collections,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables,
  PascalType.Tables.OpenType.Common.ValueRecord;

type
  TRegionAxisCoordinates = record
    StartCoord: TShortFrac;
    PeakCoord: TShortFrac;
    EndCoord: TShortFrac;
  end;

  TVariationRegion = TArray<TRegionAxisCoordinates>;

  TVariationRegionList = class(TCustomPascalTypeTable)
  private
    FRegions: TArray<TVariationRegion>;
    function GetRegionCount: Integer;
    function GetAxisCount: Word;
  public
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    function CalculateScalar(RegionIndex: Integer; const NormalizedCoords: TArray<TFixedPoint>): Single;

    property AxisCount: Word read GetAxisCount;
    property RegionCount: Integer read GetRegionCount;
  end;

  TItemVariationData = class(TCustomPascalTypeTable)
  private
    FRegionIndices: TArray<Word>;
    FDeltas: TArray<TArray<SmallInt>>;
    function GetRegionIndexCount: Integer;
    function GetRegionIndex(Index: Integer): Word;
    function GetItemCount: Word;
  public
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    function GetDelta(ItemIndex: Integer; RegionIndex: Integer; RegionList: TVariationRegionList; const NormalizedCoords: TArray<TFixedPoint>): Single;
    function GetItemDelta(ItemIndex: Integer; RegionList: TVariationRegionList; const NormalizedCoords: TArray<TFixedPoint>): Single;

    property ItemCount: Word read GetItemCount;
    property RegionIndexCount: Integer read GetRegionIndexCount;
    property RegionIndices[Index: Integer]: Word read GetRegionIndex;
  end;

  TItemVariationStore = class(TCustomPascalTypeTable)
  private
    FFormat: Word;
    FRegionList: TVariationRegionList;
    FDataSets: TObjectList<TItemVariationData>;
    function GetDataSetCount: Integer;
    function GetDataSet(Index: Integer): TItemVariationData;
  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

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

    function GetDelta(OuterIndex, InnerIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;

    property RegionList: TVariationRegionList read FRegionList;
    property DataSetCount: Integer read GetDataSetCount;
    property DataSets[Index: Integer]: TItemVariationData read GetDataSet;
  end;

  TTupleVariationHeader = class(TCustomPascalTypeTable)
  private
    FVariationDataSize: Word;
    FTupleIndex: Word;
    FPeakTuple: TArray<TShortFrac>;
    FIntermediateStartTuple: TArray<TShortFrac>;
    FIntermediateEndTuple: TArray<TShortFrac>;
  public
    procedure LoadFromStream(Stream: TStream; AxisCount: Integer; SharedTuples: TArray<TArray<TShortFrac>>); reintroduce; virtual;
    function CalculateScalar(const NormalizedCoords: TArray<TFixedPoint>): Single;

    property VariationDataSize: Word read FVariationDataSize;
    property TupleIndex: Word read FTupleIndex;
  end;

  TDeltaSetIndexMap = class(TCustomPascalTypeTable)
  private
    FFormat: Byte;
    FEntryFormat: Word;
    FMapData: TArray<Cardinal>;
  public
    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    function GetIndex(GlyphIndex: Word; out Outer, Inner: Word): Boolean;
  end;

  procedure ResolveVariationIndices(Stream: TStream; BasePos: Int64; var ValueRecord: TOpenTypeValueRecord);

  function DecodePackedPoints(Stream: TStream; NumPointsInGlyph: Integer): TArray<Integer>;
  function DecodePackedDeltas(Stream: TStream; NumPoints: Integer): TArray<Integer>;


(*
** https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuplevariationheader
**
** tupleIndex format
*)
const
  EMBEDDED_PEAK_TUPLE   = $8000;// Flag indicating that this tuple variation
                                // header includes an embedded peak tuple
                                // record, immediately after the tupleIndex
                                // field. If set, the low 12 bits of the
                                // tupleIndex value are ignored.
                                // Note that this must always be set within the
                                // 'cvar' table.

  INTERMEDIATE_REGION   = $4000;// Flag indicating that this tuple variation
                                // table applies to an intermediate region
                                // within the variation space. If set, the
                                // header includes the two intermediate-region,
                                // start and end tuple records, immediately
                                // after the peak tuple record (if present).

  PRIVATE_POINT_NUMBERS = $2000;// Flag indicating that the serialized data for
                                // this tuple variation table includes packed
                                // "point" number data. If set, this tuple
                                // variation table uses that number data; if
                                // clear, this tuple variation table uses
                                // shared number data found at the start of the
                                // serialized data for this glyph variation
                                // data or 'cvar' table.

  TUPLE_INDEX_MASK      = $0FFF;// Mask for the low 12 bits to give the shared
                                // tuple records index.

(*
** https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuple-variation-store-header
**
** tupleVariationCount format
*)
const
  SHARED_POINT_NUMBERS  = $8000;// Flag indicating that some or all tuple
                                // variation tables reference a shared set of
                                // "point" numbers. These shared numbers are
                                // represented as packed point number data at
                                // the start of the serialized data.

  COUNT_MASK            = $0FFF;// Mask for the low bits to give the number of
                                // tuple variation tables.


(*
** https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#associating-target-items-to-variation-data
**
** entryFormat field masks
*)
const
  INNER_INDEX_BIT_COUNT_MASK    = $0F;  // Mask for the low 4 bits, which give
                                        // the count of bits minus one that are
                                        // used in each entry for the inner-
                                        // level index.

  MAP_ENTRY_SIZE_MASK           = $30;  // Mask for bits that indicate the size
                                        // in bytes minus one of each entry.

(*
** https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#packed-point-numbers
**
** Point number data run control byte
*)
const
  POINTS_ARE_WORDS = $80;       // Flag indicating the data type used for point
                                // numbers in this run. If set, the point numbers
                                // are stored as unsigned 16-bit values (uint16);
                                // if clear, the point numbers are stored as
                                // unsigned bytes (uint8).

  POINT_RUN_COUNT_MASK = $7F;   // Mask for the low 7 bits of the control byte to
                                // give the number of point number elements, minus 1.


(*
** https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#packed-point-numbers
**
** Packaed delta control byte
*)
const
  DELTAS_ARE_ZERO       = $80;  // Flag indicating that this run contains no
                                // data (no explicit delta values are stored),
                                // and that all of the deltas for this run are
                                // zero.

  DELTAS_ARE_WORDS      = $40;  // Flag indicating the data type for delta
                                // values in the run. If set, the run contains
                                // 16-bit signed deltas (int16); if clear, the
                                // run contains 8-bit signed deltas (int8).

  DELTA_RUN_COUNT_MASK  = $3F;  // Mask for the low 6 bits to provide the
                                // number of delta values in the run, minus one.

implementation

uses
  PascalType.ResourceStrings;

{ TVariationRegionList }

function TVariationRegionList.GetAxisCount: Word;
begin
  if (Length(FRegions) > 0) then
    Result := Length(FRegions[0])
  else
    Result := 0;
end;

function TVariationRegionList.GetRegionCount: Integer;
begin
  Result := Length(FRegions);
end;

procedure TVariationRegionList.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  var AxisCount := BigEndianValue.ReadWord(Stream);
  var RegionCount := BigEndianValue.ReadWord(Stream);

  SetLength(FRegions, RegionCount);

  for var i := 0 to RegionCount - 1 do
  begin
    SetLength(FRegions[i], AxisCount);

    for var j := 0 to AxisCount - 1 do
    begin
      FRegions[i][j].StartCoord := BigEndianValue.ReadSmallInt(Stream);
      FRegions[i][j].PeakCoord := BigEndianValue.ReadSmallInt(Stream);
      FRegions[i][j].EndCoord := BigEndianValue.ReadSmallInt(Stream);
    end;
  end;
end;

procedure TVariationRegionList.SaveToStream(Stream: TStream);
begin
  raise EPascalTypeNotImplemented.Create(RCStrNotImplemented);
end;

function TVariationRegionList.CalculateScalar(RegionIndex: Integer; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  if (RegionIndex < 0) or (RegionIndex > High(FRegions)) then
    Exit(0);

  var Region := FRegions[RegionIndex];
  Result := 1.0;

  for var i := 0 to High(Region) do
  begin
    var V: Single;
    if i >= Length(NormalizedCoords) then
      V := 0
    else
      V := NormalizedCoords[i].AsSingle;

    var AxisScalar: Single;
    if (Region[i].PeakCoord = 0) then
      AxisScalar := 1.0
    else
    if (V = Region[i].PeakCoord / 16384.0) then
      AxisScalar := 1.0
    else
    if (V <= Region[i].StartCoord / 16384.0) or (V >= Region[i].EndCoord / 16384.0) then
      AxisScalar := 0.0
    else
    if (V < Region[i].PeakCoord / 16384.0) then
      AxisScalar := (V - Region[i].StartCoord / 16384.0) / (Region[i].PeakCoord / 16384.0 - Region[i].StartCoord / 16384.0)
    else
      AxisScalar := (Region[i].EndCoord / 16384.0 - V) / (Region[i].EndCoord / 16384.0 - Region[i].PeakCoord / 16384.0);

    Result := Result * AxisScalar;
    if Result = 0 then
      break;
  end;
end;

{ TItemVariationData }

procedure TItemVariationData.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  var ItemCount := BigEndianValue.ReadWord(Stream);
  var ShortDeltaCount := BigEndianValue.ReadWord(Stream);
  var RegionIndexCount := BigEndianValue.ReadWord(Stream);

  SetLength(FRegionIndices, RegionIndexCount);
  for var i := 0 to High(FRegionIndices) do
    FRegionIndices[i] := BigEndianValue.ReadWord(Stream);

  SetLength(FDeltas, ItemCount);
  for var i := 0 to High(FDeltas) do
  begin
    SetLength(FDeltas[i], RegionIndexCount);

    for var j := 0 to ShortDeltaCount - 1 do
      FDeltas[i][j] := BigEndianValue.ReadSmallInt(Stream);

    for var j := ShortDeltaCount to RegionIndexCount - 1 do
      FDeltas[i][j] := ShortInt(BigEndianValue.ReadByte(Stream));
  end;
end;

procedure TItemVariationData.SaveToStream(Stream: TStream);
begin
  raise EPascalTypeNotImplemented.Create(RCStrNotImplemented);
end;

function TItemVariationData.GetRegionIndexCount: Integer;
begin
  Result := Length(FRegionIndices);
end;

function TItemVariationData.GetRegionIndex(Index: Integer): Word;
begin
  Result := FRegionIndices[Index];
end;

function TItemVariationData.GetDelta(ItemIndex: Integer; RegionIndex: Integer; RegionList: TVariationRegionList; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  if (ItemIndex < 0) or (ItemIndex > High(FDeltas)) or (RegionIndex < 0) or (RegionIndex >= Length(FRegionIndices)) then
    Exit(0);

  Result := FDeltas[ItemIndex][RegionIndex] * RegionList.CalculateScalar(FRegionIndices[RegionIndex], NormalizedCoords);
end;

function TItemVariationData.GetItemCount: Word;
begin
  Result := Length(FDeltas);
end;

function TItemVariationData.GetItemDelta(ItemIndex: Integer; RegionList: TVariationRegionList; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  if (Length(FDeltas) = 0) or (ItemIndex > High(FDeltas)) then
    Exit(0);

  Result := 0;
  for var i := 0 to High(FRegionIndices) do
    Result := Result + FDeltas[ItemIndex][i] * RegionList.CalculateScalar(FRegionIndices[i], NormalizedCoords);
end;

{ TItemVariationStore }

constructor TItemVariationStore.Create(AParent: TCustomPascalTypeTable);
begin
  inherited;
  FRegionList := TVariationRegionList.Create(Self);
  FDataSets := TObjectList<TItemVariationData>.Create(True);
end;

destructor TItemVariationStore.Destroy;
begin
  FDataSets.Free;
  FRegionList.Free;
  inherited;
end;

procedure TItemVariationStore.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  var StartPos := Stream.Position;

  FFormat := BigEndianValue.ReadWord(Stream);
  if FFormat <> 1 then
    raise EPascalTypeError.Create(RCStrUnsupportedVersion);

  var RegionListOffset := BigEndianValue.ReadCardinal(Stream);
  var ItemVariationDataCount := BigEndianValue.ReadWord(Stream);

  var Offsets: TArray<Cardinal>;
  SetLength(Offsets, ItemVariationDataCount);
  for var i := 0 to ItemVariationDataCount - 1 do
    Offsets[i] := BigEndianValue.ReadCardinal(Stream);

  Stream.Position := StartPos + RegionListOffset;
  FRegionList.LoadFromStream(Stream);

  for var i := 0 to ItemVariationDataCount - 1 do
  begin
    Stream.Position := StartPos + Offsets[i];
    var DataSet := TItemVariationData.Create(Self);
    FDataSets.Add(DataSet);
    DataSet.LoadFromStream(Stream);
  end;
end;

procedure TItemVariationStore.SaveToStream(Stream: TStream);
begin
  raise EPascalTypeNotImplemented.Create(RCStrNotImplemented);
end;

function TItemVariationStore.GetDataSetCount: Integer;
begin
  Result := FDataSets.Count;
end;

function TItemVariationStore.GetDataSet(Index: Integer): TItemVariationData;
begin
  Result := FDataSets[Index];
end;

function TItemVariationStore.GetDelta(OuterIndex, InnerIndex: Word; const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  if OuterIndex >= FDataSets.Count then
    Exit(0);

  Result := FDataSets[OuterIndex].GetItemDelta(InnerIndex, FRegionList, NormalizedCoords);
end;

{ TTupleVariationHeader }

procedure TTupleVariationHeader.LoadFromStream(Stream: TStream; AxisCount: Integer; SharedTuples: TArray<TArray<TShortFrac>>);
begin
  FVariationDataSize := BigEndianValue.ReadWord(Stream);
  FTupleIndex := BigEndianValue.ReadWord(Stream);

  // Embedded peak tuple
  if (FTupleIndex and EMBEDDED_PEAK_TUPLE <> 0) then
  begin
    SetLength(FPeakTuple, AxisCount);
    for var i := 0 to AxisCount - 1 do
      FPeakTuple[i] := BigEndianValue.ReadSmallInt(Stream);
  end else
  begin
    var SharedIndex := FTupleIndex and TUPLE_INDEX_MASK;
    if (SharedIndex < Length(SharedTuples)) then
      FPeakTuple := Copy(SharedTuples[SharedIndex])
    else
      SetLength(FPeakTuple, AxisCount);
  end;

  // Intermediate tuples
  if (FTupleIndex and INTERMEDIATE_REGION <> 0) then
  begin
    SetLength(FIntermediateStartTuple, AxisCount);
    for var i := 0 to AxisCount - 1 do
      FIntermediateStartTuple[i] := BigEndianValue.ReadSmallInt(Stream);
    SetLength(FIntermediateEndTuple, AxisCount);
    for var i := 0 to AxisCount - 1 do
      FIntermediateEndTuple[i] := BigEndianValue.ReadSmallInt(Stream);
  end;
end;

function TTupleVariationHeader.CalculateScalar(const NormalizedCoords: TArray<TFixedPoint>): Single;
begin
  Result := 1.0;
  for var i := 0 to High(FPeakTuple) do
  begin
    var V: Single;
    if i >= Length(NormalizedCoords) then
      V := 0
    else
      V := NormalizedCoords[i].AsSingle;

    var Peak := FPeakTuple[i] / 16384.0;

    var AxisScalar: Single;
    if Peak = 0 then
      AxisScalar := 1.0
    else if V = Peak then
      AxisScalar := 1.0
    else
    begin
      var Start, End_: Single;
      if Length(FIntermediateStartTuple) > 0 then
      begin
        Start := FIntermediateStartTuple[i] / 16384.0;
        End_ := FIntermediateEndTuple[i] / 16384.0;
      end else
      begin
        if Peak < 0 then
        begin
          Start := Peak;
          End_ := 0;
        end else
        begin
          Start := 0;
          End_ := Peak;
        end;
      end;

      if (V <= Start) or (V >= End_) then
        AxisScalar := 0
      else if V < Peak then
        AxisScalar := (V - Start) / (Peak - Start)
      else
        AxisScalar := (End_ - V) / (End_ - Peak);
    end;

    Result := Result * AxisScalar;
    if Result = 0 then
      Break;
  end;
end;

{ TDeltaSetIndexMap }

procedure TDeltaSetIndexMap.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  MapCount: Cardinal;
begin
  // A DeltaSetIndexMap table can be in one of two formats.
  // Format 0: format (uint8=0), entryFormat (uint8), mapCount (uint16), mapData (uint8[])
  // Format 1: format (uint8=1), entryFormat (uint8), mapCount (uint32), mapData (uint8[])
  FFormat := BigEndianValue.ReadByte(Stream);
  FEntryFormat := BigEndianValue.ReadByte(Stream);

  case FFormat of
    0: MapCount := BigEndianValue.ReadWord(Stream);
    1: MapCount := BigEndianValue.ReadCardinal(Stream);
  else
    raise EPascalTypeError.Create(RCStrUnknownFormat);
  end;

  var EntrySize := ((FEntryFormat and MAP_ENTRY_SIZE_MASK) shr 4) + 1;

  // Sanity check for mapCount if Size is provided
  if (Size > 0) then
  begin
    var HeaderSize: Cardinal;
    if (FFormat = 0) then
      HeaderSize := 4
    else
      HeaderSize := 6;

    if (HeaderSize + MapCount * EntrySize > Size) then
      MapCount := (Size - HeaderSize) div EntrySize;
  end;

  SetLength(FMapData, MapCount);

  for var i := 0 to High(FMapData) do
  begin
    case EntrySize of
      1: FMapData[i] := BigEndianValue.ReadByte(Stream);
      2: FMapData[i] := BigEndianValue.ReadWord(Stream);
      3: FMapData[i] := BigEndianValue.ReadUInt24(Stream);
      4: FMapData[i] := BigEndianValue.ReadCardinal(Stream);
    end;
  end;
end;

procedure TDeltaSetIndexMap.SaveToStream(Stream: TStream);
begin
  raise EPascalTypeNotImplemented.Create(RCStrNotImplemented);
end;

function TDeltaSetIndexMap.GetIndex(GlyphIndex: Word; out Outer, Inner: Word): Boolean;
begin
  if (Length(FMapData) = 0) then
  begin
    Outer := 0;
    Inner := GlyphIndex;
    Exit(True);
  end;

  (*
    https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#associating-target-items-to-variation-data

    "The mapCount field indicates the number of delta-set index mapping entries.
     The logical entries in the mapData array use a base-zero index. In the
     context in which a DeltaSetIndexMap table is used, if an index into the
     mapping array is used that is greater than or equal to mapCount, then the
     last logical entry of the mapping array is used."
  *)

  if (GlyphIndex > High(FMapData)) then
    // Repeat last entry
    GlyphIndex := High(FMapData);

  var EntryData := FMapData[GlyphIndex];

  var InnerBitCount := (FEntryFormat and INNER_INDEX_BIT_COUNT_MASK) + 1;
  Inner := EntryData and ((1 shl InnerBitCount) - 1);
  Outer := EntryData shr InnerBitCount;
  Result := True;
end;

function DecodePackedPoints(Stream: TStream; NumPointsInGlyph: Integer): TArray<Integer>;
begin
  var b := BigEndianValue.ReadByte(Stream);

  if (b = 0) then
  begin
    SetLength(Result, NumPointsInGlyph);
    for var i := 0 to High(Result) do
      Result[i] := i;
    Exit;
  end;

  var Count: Integer;
  if (b and POINTS_ARE_WORDS <> 0) then
    Count := ((b and POINT_RUN_COUNT_MASK) shl 8) or BigEndianValue.ReadByte(Stream)
  else
    Count := b;

  var Points := TList<Integer>.Create;
  try
    Points.Capacity := Count;

    var i := 0;
    while (i < Count) do
    begin
      var Control := BigEndianValue.ReadByte(Stream);
      var RunCount := (Control and POINT_RUN_COUNT_MASK) + 1;

      if (Control and POINTS_ARE_WORDS <> 0) then
      begin

        // 16-bit
        for var n := 0 to RunCount - 1 do
        begin
          var Val := BigEndianValue.ReadWord(Stream);
          if (i > 0) then
            Points.Add(Points[i-1] + Val)
          else
            Points.Add(Val);
          Inc(i);
        end;

      end else
      begin

        // 8-bit
        for var n := 0 to RunCount - 1 do
        begin
          var Val := BigEndianValue.ReadByte(Stream);
          if (i > 0) then
            Points.Add(Points[i-1] + Val)
          else
            Points.Add(Val);
          Inc(i);
        end;

      end;
    end;

    Result := Points.ToArray;
  finally
    Points.Free;
  end;
end;

function DecodePackedDeltas(Stream: TStream; NumPoints: Integer): TArray<Integer>;
begin
  SetLength(Result, NumPoints);
  var i := 0;
  while i < NumPoints do
  begin
    var Control := BigEndianValue.ReadByte(Stream);
    var RunCount := (Control and DELTA_RUN_COUNT_MASK) + 1;

    if (Control and DELTAS_ARE_ZERO <> 0) then
    begin

      // deltas are zero
      for var n := 0 to RunCount - 1 do
      begin
        if (i < NumPoints) then
          Result[i] := 0;
        Inc(i);
      end;

    end else
    if (Control and DELTAS_ARE_WORDS <> 0) then
    begin

      // 16-bit
      for var n := 0 to RunCount - 1 do
      begin
        if (i <= High(Result)) then
        begin
          var Val := BigEndianValue.ReadSmallInt(Stream);
          Result[i] := Val;
        end else
          Stream.Position := Stream.Position + SizeOf(SmallInt);

        Inc(i);
      end;

    end else
    begin

      // 8-bit
      for var n := 0 to RunCount - 1 do
      begin
        if (i <= High(Result)) then
        begin
          var Val := ShortInt(BigEndianValue.ReadByte(Stream));
          Result[i] := Val;
        end else
          Stream.Position := Stream.Position + 1;

        Inc(i);
      end;

    end;
  end;
end;

procedure ResolveVariationIndices(Stream: TStream; BasePos: Int64; var ValueRecord: TOpenTypeValueRecord);

  function ReadVarIndex(Offset: Word): Cardinal;
  begin
    Result := $FFFFFFFF;
    if Offset = 0 then
      Exit;

    var SavedPos := Stream.Position;
    Stream.Position := BasePos + Offset;
    var Outer := BigEndianValue.ReadWord(Stream);
    var Inner := BigEndianValue.ReadWord(Stream);
    var Format := BigEndianValue.ReadWord(Stream);
    if Format = $8000 then
      Result := (Cardinal(Outer) shl 16) or Inner;
    Stream.Position := SavedPos;
  end;

begin
  ValueRecord.xPlaVarIndex := ReadVarIndex(ValueRecord.xPlaDeviceOffset);
  ValueRecord.yPlaVarIndex := ReadVarIndex(ValueRecord.yPlaDeviceOffset);
  ValueRecord.xAdvVarIndex := ReadVarIndex(ValueRecord.xAdvDeviceOffset);
  ValueRecord.yAdvVarIndex := ReadVarIndex(ValueRecord.yAdvDeviceOffset);
end;

end.