PascalType.Tables.OpenType.vdmx.pas

unit PascalType.Tables.OpenType.vdmx;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                      'VDMX' table type                                     //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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-2024        //
//  by Christian-W. Budde. All Rights Reserved.                               //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

uses
  Classes,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables;

//------------------------------------------------------------------------------
//
//              TPascalTypeVerticalDeviceMetricsTable
//
//------------------------------------------------------------------------------
// Vertical device metrics table
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/vdmx
//------------------------------------------------------------------------------
type
  TRatioRange = packed record
    bCharSet: Byte;
    xRatio: Byte;
    yStartRatio: Byte;
    yEndRatio: Byte;
  end;

  TVTable = packed record
    yPelHeight: Word;
    yMax: SmallInt;
    yMin: SmallInt;
  end;

  TVDMXGroup = record
    recs: Word;
    startSize: Byte;
    endSize: Byte;
    entries: array of TVTable;
  end;

  TPascalTypeVerticalDeviceMetricsTable = class(TCustomPascalTypeNamedTable)
  private
    FVersion: Word;
    FRatioRanges: array of TRatioRange;
    FGroups: array of TVDMXGroup;
    FGroupIndices: array of Integer;
  protected
  public
    class function GetTableType: TTableType; override;

    procedure Assign(Source: TPersistent); override;

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

    property Version: Word read FVersion write FVersion;
  end;

implementation

uses
  SysUtils,
  Generics.Collections,
  PascalType.ResourceStrings;

{ TPascalTypeVerticalDeviceMetricsTable }

procedure TPascalTypeVerticalDeviceMetricsTable.Assign(Source: TPersistent);
var
  i: Integer;
begin
  inherited;
  if Source is TPascalTypeVerticalDeviceMetricsTable then
  begin
    FVersion := TPascalTypeVerticalDeviceMetricsTable(Source).FVersion;
    FRatioRanges := Copy(TPascalTypeVerticalDeviceMetricsTable(Source).FRatioRanges);
    FGroupIndices := Copy(TPascalTypeVerticalDeviceMetricsTable(Source).FGroupIndices);
    SetLength(FGroups, Length(TPascalTypeVerticalDeviceMetricsTable(Source).FGroups));
    for i := 0 to High(FGroups) do
    begin
      FGroups[i].recs := TPascalTypeVerticalDeviceMetricsTable(Source).FGroups[i].recs;
      FGroups[i].startSize := TPascalTypeVerticalDeviceMetricsTable(Source).FGroups[i].startSize;
      FGroups[i].endSize := TPascalTypeVerticalDeviceMetricsTable(Source).FGroups[i].endSize;
      FGroups[i].entries := Copy(TPascalTypeVerticalDeviceMetricsTable(Source).FGroups[i].entries);
    end;
  end;
end;

class function TPascalTypeVerticalDeviceMetricsTable.GetTableType: TTableType;
begin
  Result.AsAnsiChar := 'VDMX';
end;

procedure TPascalTypeVerticalDeviceMetricsTable.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  numRecs, numRatios: Word;
  i, j: Integer;
  UniqueOffsets: TDictionary<Word, Integer>;
  Offsets: array of Word;
begin
  StartPos := Stream.Position;
  inherited;

  FVersion := BigEndianValue.ReadWord(Stream);
  numRecs := BigEndianValue.ReadWord(Stream);
  numRatios := BigEndianValue.ReadWord(Stream);

  SetLength(FRatioRanges, numRatios);
  for i := 0 to numRatios - 1 do
    Stream.Read(FRatioRanges[i], SizeOf(TRatioRange));

  SetLength(Offsets, numRatios);
  UniqueOffsets := TDictionary<Word, Integer>.Create;
  try
    for i := 0 to numRatios - 1 do
    begin
      Offsets[i] := BigEndianValue.ReadWord(Stream);
      if not UniqueOffsets.ContainsKey(Offsets[i]) then
        UniqueOffsets.Add(Offsets[i], 0);
    end;

    // Sort unique offsets to load groups in order
    var SortedOffsets := UniqueOffsets.Keys.ToArray;
    TArray.Sort<Word>(SortedOffsets);

    SetLength(FGroups, numRecs);
    for i := 0 to High(SortedOffsets) do
    begin
      Stream.Position := StartPos + SortedOffsets[i];
      if i < Length(FGroups) then
      begin
        FGroups[i].recs := BigEndianValue.ReadWord(Stream);
        FGroups[i].startSize := BigEndianValue.ReadByte(Stream);
        FGroups[i].endSize := BigEndianValue.ReadByte(Stream);
        SetLength(FGroups[i].entries, FGroups[i].recs);
        for j := 0 to FGroups[i].recs - 1 do
        begin
          FGroups[i].entries[j].yPelHeight := BigEndianValue.ReadWord(Stream);
          FGroups[i].entries[j].yMax := BigEndianValue.ReadSmallInt(Stream);
          FGroups[i].entries[j].yMin := BigEndianValue.ReadSmallInt(Stream);
        end;
        UniqueOffsets[SortedOffsets[i]] := i;
      end;
    end;

    SetLength(FGroupIndices, numRatios);
    for i := 0 to numRatios - 1 do
      FGroupIndices[i] := UniqueOffsets[Offsets[i]];

  finally
    UniqueOffsets.Free;
  end;
end;

procedure TPascalTypeVerticalDeviceMetricsTable.SaveToStream(Stream: TStream);
var
  StartPos: Int64;
  numRecs, numRatios: Word;
  i, j: Integer;
  GroupOffsets: array of Word;
  OffsetPos: Int64;
begin
  StartPos := Stream.Position;
  inherited;

  numRecs := Length(FGroups);
  numRatios := Length(FRatioRanges);

  BigEndianValue.WriteWord(Stream, FVersion);
  BigEndianValue.WriteWord(Stream, numRecs);
  BigEndianValue.WriteWord(Stream, numRatios);

  for i := 0 to numRatios - 1 do
    Stream.Write(FRatioRanges[i], SizeOf(TRatioRange));

  OffsetPos := Stream.Position;
  Stream.Seek(numRatios * SizeOf(Word), soFromCurrent);

  SetLength(GroupOffsets, numRecs);
  for i := 0 to numRecs - 1 do
  begin
    GroupOffsets[i] := Word(Stream.Position - StartPos);

    BigEndianValue.WriteWord(Stream, Word(Length(FGroups[i].entries)));
    BigEndianValue.WriteByte(Stream, FGroups[i].startSize);
    BigEndianValue.WriteByte(Stream, FGroups[i].endSize);
    for j := 0 to High(FGroups[i].entries) do
    begin
      BigEndianValue.WriteWord(Stream, FGroups[i].entries[j].yPelHeight);
      BigEndianValue.WriteSmallInt(Stream, FGroups[i].entries[j].yMax);
      BigEndianValue.WriteSmallInt(Stream, FGroups[i].entries[j].yMin);
    end;
  end;

  var SavePos := Stream.Position;
  Stream.Position := OffsetPos;
  for i := 0 to numRatios - 1 do
  begin
    if (i < Length(FGroupIndices)) and (FGroupIndices[i] >= 0) and (FGroupIndices[i] < numRecs) then
      BigEndianValue.WriteWord(Stream, GroupOffsets[FGroupIndices[i]])
    else
      BigEndianValue.WriteWord(Stream, 0);
  end;
  Stream.Position := SavePos;
end;

initialization
  PascalTypeTableClasses.RegisterTable(TPascalTypeVerticalDeviceMetricsTable);

end.