PascalType.Tables.OpenType.Optional.pas

unit PascalType.Tables.OpenType.Optional;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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
  Classes, PascalType.Types, PascalType.Classes, PascalType.Tables;

type
  // table 'DSIG'
  TPascalTypeDigitalSignatureBlock = class(TCustomPascalTypeTable)
  private
    FFormat   : Cardinal;
    FReserved : array [0..1] of Word; // Reserved for later use; 0 for now
    FSignature: array of Byte; // PKCS#7 packet
    function GetSignatureByte(Index: Integer): Byte;
    function GetSignatureLength: Cardinal;
    procedure SetReserved(const Index: Integer; const Value: Word);
    procedure SetFormat(const Value: Cardinal);
  protected
    procedure FormatChanged; virtual;
    procedure ReservedChanged; virtual;
  public
    procedure Assign(Source: TPersistent); override;

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

    property SignatureLength: Cardinal read GetSignatureLength;
    property SignatureByte[Index: Integer]: Byte read GetSignatureByte;
    property Reserved1: Word index 0 read FReserved[0] write SetReserved;
    property Reserved2: Word index 1 read FReserved[1] write SetReserved;
    property Format: Cardinal read FFormat write SetFormat;
  end;


  TPascalTypeDigitalSignatureTable = class(TCustomPascalTypeNamedTable)
  strict private type
    TDigitalSignatureDirectory = packed record
      Format: Cardinal; // Format of the signature
      Length: Cardinal; // Length of signature in bytes
      Offset: Cardinal; // Offset to the signature block from the beginning of the table
    end;
  private
    FVersion: Cardinal; // Version number of the DSIG table (0x00000001)
    FFlags  : TDigitalSignatureFlags; // Permission flags: Bit 0: cannot be resigned, Bits 1-7: Reserved (Set to 0)
    FSignatures: TPascalTypeTableList<TPascalTypeDigitalSignatureBlock>;
    procedure SetVersion(const Value: Cardinal);
    procedure SetFlags(const Value: TDigitalSignatureFlags);
    function GetSignatureCount: Integer;
    function GetSignatureBlock(Index: Integer): TPascalTypeDigitalSignatureBlock;
  protected
    procedure FlagsChanged; virtual;
    procedure VersionChanged; virtual;
  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    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: Cardinal read FVersion write SetVersion;
    property Flags: TDigitalSignatureFlags read FFlags write SetFlags;
    property SignatureCount: Integer read GetSignatureCount;
    property SignatureBlock[Index: Integer]: TPascalTypeDigitalSignatureBlock read GetSignatureBlock;
  end;


  // table 'LTSH'

  TPascalTypeLinearThresholdTable = class(TCustomPascalTypeNamedTable)
  private
    FVersion     : Word;
    FVerticalPels: array of Byte; // The vertical pel height at which the glyph can be assumed to scale linearly. On a per glyph basis.
    function GetVerticalPelCount: Integer;
    function GetVerticalPel(Index: Integer): Byte;
    procedure SetVersion(const Value: Word);
  protected
    procedure VersionChanged; virtual;
  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 SetVersion;
    property VerticalPelCount: Integer read GetVerticalPelCount;
    property VerticalPel[Index: Integer]: Byte read GetVerticalPel;
  end;

implementation

uses
  SysUtils,
  PascalType.ResourceStrings;


{ TPascalTypeDigitalSignatureBlock }

procedure TPascalTypeDigitalSignatureBlock.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeDigitalSignatureBlock then
  begin
    FFormat := TPascalTypeDigitalSignatureBlock(Source).FFormat;
    FReserved := TPascalTypeDigitalSignatureBlock(Source).FReserved;
    FSignature := Copy(TPascalTypeDigitalSignatureBlock(Source).FSignature);
  end;
end;

function TPascalTypeDigitalSignatureBlock.GetSignatureByte(Index: Integer): Byte;
begin
  if (Index < 0) or (Index > High(FSignature)) then
    raise EPascalTypeError.CreateFmt(RCStrIndexOutOfBounds, [Index]);
  Result := FSignature[Index];
end;

function TPascalTypeDigitalSignatureBlock.GetSignatureLength: Cardinal;
begin
  Result := Length(FSignature);
end;

procedure TPascalTypeDigitalSignatureBlock.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;

  // check (minimum) table size
  if Stream.Position + 8 > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  FReserved[0] := BigEndianValue.ReadWord(Stream);
  FReserved[1] := BigEndianValue.ReadWord(Stream);
  SetLength(FSignature, BigEndianValue.ReadCardinal(Stream));

  // check if table contains the entire signature
  if Stream.Position + Length(FSignature) > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  Stream.Read(FSignature[0], Length(FSignature));
end;

procedure TPascalTypeDigitalSignatureBlock.SaveToStream(Stream: TStream);
begin
  inherited;

  BigEndianValue.WriteWord(Stream, FReserved[0]);
  BigEndianValue.WriteWord(Stream, FReserved[1]);
  BigEndianValue.WriteCardinal(Stream, Length(FSignature));
  Stream.Write(FSignature[0], Length(FSignature));
end;

procedure TPascalTypeDigitalSignatureBlock.SetFormat(const Value: Cardinal);
begin
  if FFormat <> Value then
  begin
    FFormat := Value;
    FormatChanged;
  end;
end;

procedure TPascalTypeDigitalSignatureBlock.SetReserved(const Index: Integer;
  const Value: Word);
begin
  if FReserved[Index] <> Value then
  begin
    FReserved[Index] := Value;
    ReservedChanged;
  end;
end;

procedure TPascalTypeDigitalSignatureBlock.ReservedChanged;
begin
  Changed;
end;

procedure TPascalTypeDigitalSignatureBlock.FormatChanged;
begin
  Changed;
end;


{ TPascalTypeDigitalSignatureTable }

constructor TPascalTypeDigitalSignatureTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited;
  FVersion := 1;
  FSignatures := TPascalTypeTableList<TPascalTypeDigitalSignatureBlock>.Create;
end;

destructor TPascalTypeDigitalSignatureTable.Destroy;
begin
  FreeAndNil(FSignatures);
  inherited;
end;

procedure TPascalTypeDigitalSignatureTable.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeDigitalSignatureTable then
  begin
    FVersion := TPascalTypeDigitalSignatureTable(Source).FVersion;
    FFlags := TPascalTypeDigitalSignatureTable(Source).FFlags;
    FSignatures.Assign(TPascalTypeDigitalSignatureTable(Source).FSignatures);
  end;
end;

class function TPascalTypeDigitalSignatureTable.GetTableType: TTableType;
begin
  Result.AsAnsiChar := 'DSIG';
end;

function TPascalTypeDigitalSignatureTable.GetSignatureBlock(Index: Integer): TPascalTypeDigitalSignatureBlock;
begin
  if (Index < 0) or (Index >= FSignatures.Count) then
    raise EPascalTypeError.CreateFmt(RCStrIndexOutOfBounds, [Index]);
  Result := FSignatures[Index];
end;

function TPascalTypeDigitalSignatureTable.GetSignatureCount: Integer;
begin
  Result := FSignatures.Count;
end;

procedure TPascalTypeDigitalSignatureTable.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos : Int64;
  i : Integer;
  Directory: TArray<TDigitalSignatureDirectory>;
  SigBlock : TPascalTypeDigitalSignatureBlock;
begin
  // store stream start position
  StartPos := Stream.Position;

  inherited;

  // +----------+-----------+-------------------------------------------------------------------------+
  // | Type     | Name      | Description                                                             |
  // +==========+===========+=========================================================================+
  // | uint32   | ulVersion | Version number of the DSIG table (0x00000001).                          |
  // +----------+-----------+-------------------------------------------------------------------------+
  // | uint16   | usNumSigs | Number of signatures in the table.                                      |
  // +----------+-----------+-------------------------------------------------------------------------+
  // | uint16   | usFlag    | Permission flags.                                                       |
  // +----------+-----------+-------------------------------------------------------------------------+

  // check (minimum) table size
  if Stream.Position + 8 > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  FVersion := BigEndianValue.ReadCardinal(Stream);

  if Version <> 1 then
    raise EPascalTypeError.Create(RCStrUnsupportedVersion);

  SetLength(Directory, BigEndianValue.ReadWord(Stream));

  FFlags := WordToDigitalSignatureFlags(BigEndianValue.ReadWord(Stream));

  if Stream.Position + Length(Directory) * SizeOf(TDigitalSignatureDirectory) > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  // read directory entry
  for i := 0 to High(Directory) do
  begin
    Directory[i].Format := BigEndianValue.ReadCardinal(Stream);
    Directory[i].Length := BigEndianValue.ReadCardinal(Stream);
    Directory[i].Offset := BigEndianValue.ReadCardinal(Stream);
  end;

  // clear existing signatures
  FSignatures.Clear;

  // read digital signatures
  for i := 0 to High(Directory) do
  begin
    Stream.Position := StartPos + Directory[i].Offset;

    // check if table contains the entire signature
    if Stream.Position + Directory[i].Length > Stream.Size then
      raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

    // load digital signature from stream
    SigBlock := FSignatures.Add;
    SigBlock.LoadFromStream(Stream);
  end;
end;

procedure TPascalTypeDigitalSignatureTable.SaveToStream(Stream: TStream);
var
  StartPos : Int64;
  DirPos : Int64;
  i : Integer;
  Directory: TArray<TDigitalSignatureDirectory>;
begin
  // store stream start position
  StartPos := Stream.Position;

  inherited;

  BigEndianValue.WriteWord(Stream, FVersion);
  BigEndianValue.WriteWord(Stream, FSignatures.Count);
  BigEndianValue.WriteWord(Stream, DigitalSignatureFlagsToWord(FFlags));
  SetLength(Directory, FSignatures.Count);

  // offset directory
  DirPos := Stream.Position;
  Stream.Seek(soFromCurrent, FSignatures.Count * 3 * SizeOf(Cardinal));

  // build directory and store signature
  for i := 0 to FSignatures.Count - 1 do
  begin
    Directory[i].Format := FSignatures[i].Format;
    Directory[i].Offset := Stream.Position - StartPos;
    FSignatures[i].SaveToStream(Stream);
    Directory[i].Length := (Stream.Position - StartPos) - Directory[i].Offset;
  end;

  // locate directory
  Stream.Position := DirPos;

  // write directory entries
  for i := 0 to High(Directory) do
  begin
    BigEndianValue.WriteCardinal(Stream, Directory[i].Format);
    BigEndianValue.WriteCardinal(Stream, Directory[i].Length);
    BigEndianValue.WriteCardinal(Stream, Directory[i].Offset);
  end;
end;

procedure TPascalTypeDigitalSignatureTable.SetFlags(const Value: TDigitalSignatureFlags);
begin
  if FFlags <> Value then
  begin
    FFlags := Value;
    FlagsChanged;
  end;
end;

procedure TPascalTypeDigitalSignatureTable.SetVersion(const Value: Cardinal);
begin
  if (Version <> Value) then
  begin
    Version := Value;
    VersionChanged;
  end;
end;

procedure TPascalTypeDigitalSignatureTable.FlagsChanged;
begin
  Changed;
end;

procedure TPascalTypeDigitalSignatureTable.VersionChanged;
begin
  Changed;
end;


{ TPascalTypeLinearThresholdTable }

procedure TPascalTypeLinearThresholdTable.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeLinearThresholdTable then
  begin
    FVersion := TPascalTypeLinearThresholdTable(Source).FVersion;
    FVerticalPels := Copy(TPascalTypeLinearThresholdTable(Source).FVerticalPels);
  end;
end;

class function TPascalTypeLinearThresholdTable.GetTableType: TTableType;
begin
  Result.AsAnsiChar := 'LTSH';
end;

function TPascalTypeLinearThresholdTable.GetVerticalPel(Index: Integer): Byte;
begin
  if (Index >= 0) and (Index < Length(FVerticalPels)) then
    Result := FVerticalPels[Index]
  else
    raise EPascalTypeError.CreateFmt(RCStrIndexOutOfBounds, [Index]);
end;

function TPascalTypeLinearThresholdTable.GetVerticalPelCount: Integer;
begin
  Result := Length(FVerticalPels);
end;

procedure TPascalTypeLinearThresholdTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;

  // +----------+-----------+-------------------------------------------------------------------------+
  // | Type     | Name      | Description                                                             |
  // +==========+===========+=========================================================================+
  // | uint16   | version   | Table version number (=0).                                              |
  // +----------+-----------+-------------------------------------------------------------------------+
  // | uint16   | numGlyphs | Number of glyphs in the font.                                           |
  // +----------+-----------+-------------------------------------------------------------------------+

  // check (minimum) table size
  if Stream.Position + 4 > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  Version := BigEndianValue.ReadWord(Stream);

  if Version <> 0 then
    raise EPascalTypeError.Create(RCStrUnsupportedVersion);

  SetLength(FVerticalPels, BigEndianValue.ReadWord(Stream));

  if Stream.Position + Length(FVerticalPels) > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  Stream.Read(FVerticalPels[0], Length(FVerticalPels));
end;

procedure TPascalTypeLinearThresholdTable.SaveToStream(Stream: TStream);
begin
  BigEndianValue.WriteWord(Stream, Version);
  BigEndianValue.WriteWord(Stream, Length(FVerticalPels));
  Stream.Write(FVerticalPels[0], Length(FVerticalPels));
end;

procedure TPascalTypeLinearThresholdTable.SetVersion(const Value: Word);
begin
  if FVersion <> Value then
  begin
    FVersion := Value;
    VersionChanged;
  end;
end;

procedure TPascalTypeLinearThresholdTable.VersionChanged;
begin
  Changed;
end;

initialization
  PascalTypeTableClasses.RegisterTables([
    TPascalTypeDigitalSignatureTable,
    TPascalTypeLinearThresholdTable]);

end.