PascalType.Tables.TrueType.cvar.pas

unit PascalType.Tables.TrueType.cvar;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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.Variation;

type
  TPascalTypeCVTVariationTable = class(TCustomPascalTypeNamedTable)
  private
    FMajorVersion: Word;
    FMinorVersion: Word;
    FData: TArray<Byte>;
  public
    class function GetTableType: TTableType; override;

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

    function GetCVTDeltas(const NormalizedCoords: TArray<TFixedPoint>; NumCVTs: Integer): TArray<Single>;
  end;

implementation

uses
  PascalType.Tables.Apple;

{ TPascalTypeCVTVariationTable }

class function TPascalTypeCVTVariationTable.GetTableType: TTableType;
begin
  Result.AsAnsiChar := 'cvar';
end;

procedure TPascalTypeCVTVariationTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  FMajorVersion := BigEndianValue.ReadWord(Stream);
  FMinorVersion := BigEndianValue.ReadWord(Stream);

  var DataSize := Size - 4;
  if DataSize > 0 then
  begin
    SetLength(FData, DataSize);
    Stream.Read(FData[0], DataSize);
  end;
end;

function TPascalTypeCVTVariationTable.GetCVTDeltas(const NormalizedCoords: TArray<TFixedPoint>; NumCVTs: Integer): TArray<Single>;
begin
  SetLength(Result, NumCVTs);
  for var i := 0 to NumCVTs - 1 do
    Result[i] := 0;

  if Length(FData) = 0 then
    Exit;

  var fvarTable := TPascalTypeFontVariationTable(FontFace.GetTableByTableType('fvar'));
  if (fvarTable = nil) then
    Exit;

  var AxisCount := fvarTable.AxisCount;

  var Stream := TMemoryStream.Create;
  try
    Stream.Write(FData[0], Length(FData));
    Stream.Position := 0;

    var TupleCountWord := BigEndianValue.ReadWord(Stream);
    var TupleCount := TupleCountWord and COUNT_MASK;
    var HasSharedPointNumbers := (TupleCountWord and SHARED_POINT_NUMBERS <> 0);
    var DataOffset := BigEndianValue.ReadWord(Stream);
    var DataStartPos: Int64 := DataOffset;

    var Headers := TObjectList<TTupleVariationHeader>.Create(True);
    try
      for var i := 0 to TupleCount - 1 do
      begin
        var Header := TTupleVariationHeader.Create(Self);
        Headers.Add(Header);
        // sharedTuples is nil as per spec for cvar
        Header.LoadFromStream(Stream, AxisCount, nil);
      end;

      Stream.Position := DataStartPos;

      var SharedPoints: TArray<Integer> := nil;
      if HasSharedPointNumbers then
        SharedPoints := DecodePackedPoints(Stream, NumCVTs);

      for var i := 0 to Headers.Count - 1 do
      begin
        var Header := Headers[i];
        var Scalar := Header.CalculateScalar(NormalizedCoords);

        if Header.VariationDataSize = 0 then
          continue;

        var NextDataPos := Stream.Position + Header.VariationDataSize;

        if Scalar <> 0 then
        begin
          var Points: TArray<Integer>;
          if (Header.TupleIndex and PRIVATE_POINT_NUMBERS <> 0) then
            Points := DecodePackedPoints(Stream, NumCVTs)
          else
            Points := SharedPoints;

          if (Length(Points) = 0) then
          begin
            // All points
            var Deltas := DecodePackedDeltas(Stream, NumCVTs);
            for var j := 0 to NumCVTs - 1 do
              Result[j] := Result[j] + Deltas[j] * Scalar;
          end else
          begin
            // Specified points
            var Deltas := DecodePackedDeltas(Stream, Length(Points));
            for var j := 0 to High(Points) do
            begin
              var k := Points[j];
              if k < NumCVTs then
                Result[k] := Result[k] + Deltas[j] * Scalar;
            end;
          end;
        end;

        Stream.Position := NextDataPos;
      end;
    finally
      Headers.Free;
    end;
  finally
    Stream.Free;
  end;
end;

procedure TPascalTypeCVTVariationTable.SaveToStream(Stream: TStream);
begin
  raise EPascalTypeNotImplemented.Create('Not implemented');
end;

initialization

  PascalTypeTableClasses.RegisterTables([TPascalTypeCVTVariationTable]);

end.