Grcov report - variable

1

#![deny(missing_docs)]

2

3

//! Common tables pertaining to variable fonts.

4

5

use std::borrow::Cow;

6

use std::fmt;

7

use std::marker::PhantomData;

8

9

use tinyvec::{tiny_vec, TinyVec};

10

11

use crate::binary::read::{

12

    DebugData, ReadArray, ReadBinary, ReadBinaryDep, ReadCtxt, ReadFixedSizeDep, ReadFrom,

13

    ReadScope, ReadUnchecked,

14

};

15

use crate::binary::write::{WriteBinary, WriteContext};

16

use crate::binary::{I16Be, I32Be, U16Be, U32Be, I8, U8};

17

use crate::error::{ParseError, WriteError};

18

use crate::tables::variable_fonts::cvar::CvarTable;

19

use crate::tables::variable_fonts::gvar::{GvarTable, NumPoints};

20

use crate::tables::{F2Dot14, Fixed};

21

use crate::SafeFrom;

22

23

pub mod avar;

24

pub mod cvar;

25

pub mod fvar;

26

pub mod gvar;

27

pub mod hvar;

28

pub mod mvar;

29

pub mod stat;

30

31

pub use crate::tables::variable_fonts::fvar::{OwnedTuple, Tuple};

32

33

/// Coordinate array specifying a position within the font’s variation space.

34

///

35

/// The number of elements must match the

36

/// [axis_count](fvar::FvarTable::axis_count()) specified in

37

/// the [FvarTable](fvar::FvarTable).

38

///

39

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuple-records>

40

#[derive(Debug, Clone)]

41

pub struct ReadTuple<'a>(ReadArray<'a, F2Dot14>);

42

43

/// Tuple in user coordinates

44

///

45

/// **Note:** The UserTuple record and ReadTuple record both describe a position in

46

/// the variation space but are distinct: UserTuple uses Fixed values to

47

/// represent user scale coordinates, while ReadTuple record uses F2Dot14 values to

48

/// represent normalized coordinates.

49

///

50

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/fvar#instancerecord>

51

#[derive(Debug)]

52

pub struct UserTuple<'a>(ReadArray<'a, Fixed>);

53

54

/// Phantom type for [TupleVariationStore] from a `gvar` table.

55

pub enum Gvar {}

56

/// Phantom type for [TupleVariationStore] from a `cvar` table.

57

pub enum Cvar {}

58

59

pub(crate) trait PeakTuple<'data> {

60

    type Table;

61

62

    fn peak_tuple<'a>(&'a self, table: &'a Self::Table) -> Result<ReadTuple<'data>, ParseError>;

63

64

65

/// Tuple Variation Store Header.

66

///

67

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuple-variation-store-header>

68

pub struct TupleVariationStore<'a, T> {

69

    /// The number of points in the glyph this store is for

70

    num_points: u32,

71

    /// The serialized data block begins with shared “point” number data,

72

    /// followed by the variation data for the tuple variation tables.

73

///

74

    /// The shared point number data is optional: it is present if the

75

    /// corresponding flag is set in the `tuple_variation_flags_and_count`

76

    /// field of the header.

77

    shared_point_numbers: Option<PointNumbers>,

78

    /// Array of tuple variation headers.

79

    tuple_variation_headers: Vec<TupleVariationHeader<'a, T>>,

80

81

82

/// Tuple variation header.

83

///

84

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#tuplevariationheader>

85

pub struct TupleVariationHeader<'a, T> {

86

    /// The size in bytes of the serialized data for this tuple variation table.

87

    variation_data_size: u16,

88

    /// A packed field. The high 4 bits are flags. The low 12 bits are an index

89

    /// into a shared tuple records array.

90

    tuple_flags_and_index: u16,

91

    /// Peak tuple record for this tuple variation table — optional, determined

92

    /// by flags in the tupleIndex value.

93

///

94

    /// Note that this must always be included in the `cvar` table.

95

    peak_tuple: Option<ReadTuple<'a>>,

96

    /// The start and end tuples for the intermediate region.

97

///

98

    /// Presence determined by flags in the `tuple_flags_and_index` value.

99

    intermediate_region: Option<(ReadTuple<'a>, ReadTuple<'a>)>,

100

    /// The serialized data for this Tuple Variation

101

    data: &'a [u8],

102

    variant: PhantomData<T>,

103

104

105

/// Glyph variation data.

106

///

107

/// (x, y) deltas for numbered points.

108

pub struct GvarVariationData<'a> {

109

    point_numbers: Cow<'a, PointNumbers>,

110

    x_coord_deltas: Vec<i16>,

111

    y_coord_deltas: Vec<i16>,

112

113

114

/// CVT variation data.

115

///

116

/// deltas for numbered CVTs.

117

pub struct CvarVariationData<'a> {

118

    point_numbers: Cow<'a, PointNumbers>,

119

    deltas: Vec<i16>,

120

121

122

#[derive(Clone)]

123

enum PointNumbers {

124

    All(u32),

125

    Specific(Vec<u16>),

126

127

128

/// A collection of point numbers that are shared between variations.

129

pub struct SharedPointNumbers<'a>(&'a PointNumbers);

130

131

/// Item variation store.

132

///

133

/// > Includes a variation region list, which defines the different regions of the font’s variation

134

/// > space for which variation data is defined. It also includes a set of itemVariationData

135

/// > sub-tables, each of which provides a portion of the total variation data. Each sub-table is

136

/// > associated with some subset of the defined regions, and will include deltas used for one or

137

/// > more target items.

138

///

139

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#variation-data>

140

#[derive(Clone)]

141

pub struct ItemVariationStore<'a> {

142

    /// The variation region list.

143

    pub variation_region_list: VariationRegionList<'a>,

144

    /// The item variation data

145

    pub item_variation_data: Vec<ItemVariationData<'a>>,

146

147

148

/// List of regions for which delta adjustments have effect.

149

#[derive(Clone)]

150

pub struct VariationRegionList<'a> {

151

    /// Array of variation regions.

152

    pub variation_regions: ReadArray<'a, VariationRegion<'a>>,

153

154

155

/// Variation data specified as regions of influence and delta values.

156

#[derive(Clone)]

157

pub struct ItemVariationData<'a> {

158

    /// The number of delta sets for distinct items.

159

    item_count: u16,

160

    /// A packed field: the high bit is a flag.

161

    word_delta_count: u16,

162

    /// The number of variation regions referenced.

163

    region_index_count: u16,

164

    /// Array of indices into the variation region list for the regions

165

    /// referenced by this item variation data table.

166

    region_indexes: ReadArray<'a, U16Be>,

167

    /// Delta-set rows.

168

    delta_sets: &'a [u8],

169

170

171

#[derive(Clone, Debug)]

172

/// A record of the variation regions for each axis in the font.

173

pub struct VariationRegion<'a> {

174

    /// Array of region axis coordinates records, in the order of axes given in

175

    /// the `fvar` table.

176

    region_axes: ReadArray<'a, RegionAxisCoordinates>,

177

178

179

#[derive(Copy, Clone, Debug)]

180

pub(crate) struct RegionAxisCoordinates {

181

    /// The region start coordinate value for the current axis.

182

    start_coord: F2Dot14,

183

    /// The region peak coordinate value for the current axis.

184

    peak_coord: F2Dot14,

185

    /// The region end coordinate value for the current axis.

186

    end_coord: F2Dot14,

187

188

189

/// A mapping to delta set indices.

190

pub struct DeltaSetIndexMap<'a> {

191

    /// A packed field that describes the compressed representation of delta-set

192

    /// indices.

193

    entry_format: u8,

194

    /// The number of mapping entries.

195

    map_count: u32,

196

    /// The delta-set index mapping data.

197

    map_data: &'a [u8],

198

199

200

/// An outer/inner index pair for looking up an entry in a `DeltaSetIndexMap` or

201

/// [ItemVariationStore].

202

///

203

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

204

#[derive(Debug, Copy, Clone)]

205

pub struct DeltaSetIndexMapEntry {

206

    /// Index into the outer table (row)

207

    pub outer_index: u16,

208

    /// Index into the inner table (column)

209

    pub inner_index: u16,

210

211

212

/// Contains owned versions of some variable font tables.

213

pub mod owned {

214

    use super::{DeltaSetIndexMapEntry, DeltaSetT, Tuple};

215

    use crate::error::ParseError;

216

    use crate::tables::F2Dot14;

217

218

    /// Owned version of [super::ItemVariationStore].

219

    pub struct ItemVariationStore {

220

        /// The variation region list.

221

        pub(super) variation_region_list: VariationRegionList,

222

        /// The item variation data

223

        pub(super) item_variation_data: Vec<ItemVariationData>,

224

225

226

    /// Owned version of [super::VariationRegionList].

227

    pub(super) struct VariationRegionList {

228

        /// Array of variation regions.

229

        pub(super) variation_regions: Vec<VariationRegion>,

230

231

232

    /// Owned version of [super::ItemVariationData].

233

    pub(super) struct ItemVariationData {

234

        /// A packed field: the high bit is a flag.

235

        pub(super) word_delta_count: u16,

236

        /// The number of variation regions referenced.

237

        pub(super) region_index_count: u16,

238

        /// Array of indices into the variation region list for the regions

239

        /// referenced by this item variation data table.

240

        pub(super) region_indexes: Vec<u16>,

241

        /// Delta-set rows.

242

        pub(super) delta_sets: Box<[u8]>,

243

244

245

    /// Owned version of [super::VariationRegion].

246

    pub(crate) struct VariationRegion {

247

        /// Array of region axis coordinates records, in the order of axes given in

248

        /// the `fvar` table.

249

        pub(super) region_axes: Vec<super::RegionAxisCoordinates>,

250

251

252

    impl ItemVariationStore {

253

        pub(crate) fn adjustment(

254

            &self,

255

            delta_set_entry: DeltaSetIndexMapEntry,

256

            instance: Tuple<'_>,

257

        ) -> Result<f32, ParseError> {

258

            let item_variation_data = self

259

                .item_variation_data

260

                .get(usize::from(delta_set_entry.outer_index))

261

                .ok_or(ParseError::BadIndex)?;

262

            let delta_set = item_variation_data

263

                .delta_set(delta_set_entry.inner_index)

264

                .ok_or(ParseError::BadIndex)?;

265

266

            let mut adjustment = 0.;

267

            for (delta, region_index) in delta_set

268

                .iter()

269

                .zip(item_variation_data.region_indexes.iter().copied())

270

271

                let region = self

272

                    .variation_region(region_index)

273

                    .ok_or(ParseError::BadIndex)?;

274

                if let Some(scalar) = region.scalar(instance.iter().copied()) {

275

                    adjustment += scalar * delta as f32;

276

277

278

            Ok(adjustment)

279

280

281

        fn variation_region(&self, region_index: u16) -> Option<&VariationRegion> {

282

            let region_index = usize::from(region_index);

283

            if region_index >= self.variation_region_list.variation_regions.len() {

284

                return None;

285

286

            self.variation_region_list

287

                .variation_regions

288

                .get(region_index)

289

290

291

292

    impl DeltaSetT for ItemVariationData {

293

        fn delta_sets(&self) -> &[u8] {

294

            self.delta_sets.as_ref()

295

296

297

        fn raw_word_delta_count(&self) -> u16 {

298

            self.word_delta_count

299

300

301

        fn region_index_count(&self) -> u16 {

302

            self.region_index_count

303

304

305

306

    impl ItemVariationData {

307

        pub fn delta_set(&self, index: u16) -> Option<super::DeltaSet<'_>> {

308

            self.delta_set_impl(index)

309

310

311

312

    impl VariationRegion {

313

        pub(crate) fn scalar(&self, tuple: impl Iterator<Item = F2Dot14>) -> Option<f32> {

314

            super::scalar(self.region_axes.iter().copied(), tuple)

315

316

317

318

319

impl<'a> UserTuple<'a> {

320

    /// Iterate over the axis values in this user tuple.

321

    pub fn iter(&self) -> impl ExactSizeIterator<Item = Fixed> + 'a {

322

        self.0.iter()

323

324

325

    /// Returns the number of values in this user tuple.

326

///

327

    /// Should be the same as the number of axes in the `fvar` table.

328

    pub fn len(&self) -> usize {

329

        self.0.len()

330

331

332

333

impl<'data, T> TupleVariationStore<'data, T> {

334

    /// Flag indicating that some or all tuple variation tables reference a

335

    /// shared set of “point” numbers.

336

///

337

    /// These shared numbers are represented as packed point number data at the

338

    /// start of the serialized data.

339

    const SHARED_POINT_NUMBERS: u16 = 0x8000;

340

341

    /// Mask for the low bits to give the number of tuple variation tables.

342

    const COUNT_MASK: u16 = 0x0FFF;

343

344

    /// Iterate over the tuple variation headers.

345

    pub fn headers(&self) -> impl Iterator<Item = &TupleVariationHeader<'data, T>> {

346

        self.tuple_variation_headers.iter()

347

348

349

    /// Get the shared point numbers for this variation store if present.

350

    pub fn shared_point_numbers(&self) -> Option<SharedPointNumbers<'_>> {

351

        self.shared_point_numbers.as_ref().map(SharedPointNumbers)

352

353

354

355

impl<'data, T> TupleVariationStore<'data, T> {

356

    pub(crate) fn determine_applicable<'a>(

357

        &'a self,

358

        table: &'a <TupleVariationHeader<'data, T> as PeakTuple<'data>>::Table,

359

        instance: &'a OwnedTuple,

360

    ) -> impl Iterator<Item = (f32, &'a TupleVariationHeader<'data, T>)> + 'a

361

    where

362

        TupleVariationHeader<'data, T>: PeakTuple<'data>,

363

364

        // Ok, now we have our tuple we need to get the relevant glyph variation records

365

//

366

        // > The tuple variation headers within the selected glyph variation data table will each

367

        // > specify a particular region of applicability within the font’s variation space. These will

368

        // > be compared with the coordinates for the selected variation instance to determine which of

369

        // > the tuple-variation data tables are applicable, and to calculate a scalar value for each.

370

        // > These comparisons and scalar calculations are done using normalized-scale coordinate values.

371

        // >

372

        // > The tuple variation headers within the selected glyph variation data table will each

373

        // > specify a particular region of applicability within the font’s variation space. These will

374

        // > be compared with the coordinates for the selected variation instance to determine which of

375

        // > the tuple-variation data tables are applicable, and to calculate a scalar value for each.

376

        // > These comparisons and scalar calculations are done using normalized-scale coordinate

377

        // > values.For each of the tuple-variation data tables that are applicable, the point number and

378

        // > delta data will be unpacked and processed. The data for applicable regions can be processed

379

        // > in any order. Derived delta values will correspond to particular point numbers derived from

380

        // > the packed point number data. For a given point number, the computed scalar is applied to

381

        // > the X coordinate and Y coordinate deltas as a coefficient, and then resulting delta

382

        // > adjustments applied to the X and Y coordinates of the point.

383

384

        // Determine which ones are applicable and return the scalar value for each one

385

        self.headers().filter_map(move |header| {

386

            // https://learn.microsoft.com/en-us/typography/opentype/spec/otvaroverview#algorithm-for-interpolation-of-instance-values

387

            let peak_coords = header.peak_tuple(table).ok()?;

388

            let (start_coords, end_coords) = match header.intermediate_region() {

389

                // NOTE(clone): Cheap as ReadTuple just contains ReadArray

390

                Some((start, end)) => (

391

                    Coordinates::Tuple(start.clone()),

392

                    Coordinates::Tuple(end.clone()),

393

),

394

                None => {

395

                    let mut start_coords = tiny_vec!();

396

                    let mut end_coords = tiny_vec!();

397

                    for peak in peak_coords.0.iter() {

398

                        match peak.raw_value().signum() {

399

                            // region is from peak to zero

400

                            -1 => {

401

                                start_coords.push(peak);

402

                                end_coords.push(F2Dot14::from(0));

403

404

                            // When a delta is provided for a region defined by n-tuples that have

405

                            // a peak value of 0 for some axis, then that axis does not factor into

406

                            // scalar calculations.

407

                            0 => {

408

                                start_coords.push(peak);

409

                                end_coords.push(peak);

410

411

                            // region is from zero to peak

412

                            1 => {

413

                                start_coords.push(F2Dot14::from(0));

414

                                end_coords.push(peak);

415

416

                            _ => unreachable!("unknown value from signum"),

417

418

419

420

                        Coordinates::Array(start_coords),

421

                        Coordinates::Array(end_coords),

422

423

424

};

425

426

            // Now determine the scalar:

427

//

428

            // > In calculation of scalars (S, AS) and of interpolated values (scaledDelta,

429

            // > netAdjustment, interpolatedValue), at least 16 fractional bits of precision should

430

            // > be maintained.

431

            let scalar = start_coords

432

                .iter()

433

                .zip(end_coords.iter())

434

                .zip(instance.iter().copied())

435

                .zip(peak_coords.0.iter())

436

                .map(|(((start, end), instance), peak)| {

437

                    calculate_scalar(instance, start, peak, end)

438

})

439

                .fold(1., |scalar, axis_scalar| scalar * axis_scalar);

440

441

            (scalar != 0.).then_some((scalar, header))

442

})

443

444

445

446

impl TupleVariationStore<'_, Gvar> {

447

    /// Retrieve the variation data for the variation tuple at the given index.

448

    pub fn variation_data(&self, index: u16) -> Result<GvarVariationData<'_>, ParseError> {

449

        let header = self

450

            .tuple_variation_headers

451

            .get(usize::from(index))

452

            .ok_or(ParseError::BadIndex)?;

453

        header.variation_data(

454

            NumPoints::from_raw(self.num_points),

455

            self.shared_point_numbers(),

456

457

458

459

460

impl<T> ReadBinaryDep for TupleVariationStore<'_, T> {

461

    type Args<'a> = (u16, u32, ReadScope<'a>);

462

    type HostType<'a> = TupleVariationStore<'a, T>;

463

464

    fn read_dep<'a>(

465

        ctxt: &mut ReadCtxt<'a>,

466

        (axis_count, num_points, table_scope): (u16, u32, ReadScope<'a>),

467

    ) -> Result<Self::HostType<'a>, ParseError> {

468

        let axis_count = usize::from(axis_count);

469

        let tuple_variation_flags_and_count = ctxt.read_u16be()?;

470

        let tuple_variation_count = usize::from(tuple_variation_flags_and_count & Self::COUNT_MASK);

471

        let data_offset = ctxt.read_u16be()?;

472

473

        // Now read the TupleVariationHeaders

474

        let mut tuple_variation_headers = (0..tuple_variation_count)

475

            .map(|_| ctxt.read_dep::<TupleVariationHeader<'_, T>>(axis_count))

476

            .collect::<Result<Vec<_>, _>>()?;

477

478

        // Read the serialized data for each tuple variation header

479

        let mut data_ctxt = table_scope.offset(usize::from(data_offset)).ctxt();

480

481

        // Read shared point numbers if the flag indicates they are present

482

        let shared_point_numbers = ((tuple_variation_flags_and_count & Self::SHARED_POINT_NUMBERS)

483

            == Self::SHARED_POINT_NUMBERS)

484

            .then(|| read_packed_point_numbers(&mut data_ctxt, num_points))

485

            .transpose()?;

486

487

        // Populate the data slices on the headers

488

        for header in tuple_variation_headers.iter_mut() {

489

            header.data = data_ctxt.read_slice(header.variation_data_size.into())?;

490

491

492

        Ok(TupleVariationStore {

493

            num_points,

494

            shared_point_numbers,

495

            tuple_variation_headers,

496

})

497

498

499

500

impl PointNumbers {

501

    /// Flag indicating the data type used for point numbers in this run.

502

///

503

    /// If set, the point numbers are stored as unsigned 16-bit values (uint16);

504

    /// if clear, the point numbers are stored as unsigned bytes (uint8).

505

    const POINTS_ARE_WORDS: u8 = 0x80;

506

507

    /// Mask for the low 7 bits of the control byte to give the number of point

508

    /// number elements, minus 1.

509

    const POINT_RUN_COUNT_MASK: u8 = 0x7F;

510

511

    /// Returns the number of point numbers contained by this value

512

    pub fn len(&self) -> usize {

513

        match self {

514

            PointNumbers::All(n) => usize::safe_from(*n),

515

            PointNumbers::Specific(vec) => vec.len(),

516

517

518

519

    /// Iterate over the point numbers contained by this value.

520

    fn iter(&self) -> impl Iterator<Item = u32> + '_ {

521

        (0..self.len()).map(move |index| {

522

            match self {

523

                // NOTE(cast): Safe as len is from `n`, which is a u32

524

                PointNumbers::All(_n) => index as u32,

525

                // NOTE(unwrap): Safe as index is bounded by `len`

526

                PointNumbers::Specific(numbers) => {

527

                    numbers.get(index).copied().map(u32::from).unwrap()

528

529

530

})

531

532

533

534

/// Read packed point numbers for a glyph with `num_points` points.

535

///

536

/// `num_points` is expected to already have the four "phantom points" added to

537

/// it.

538

///

539

/// <https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#packed-point-numbers>

540

fn read_packed_point_numbers(

541

    ctxt: &mut ReadCtxt<'_>,

542

    num_points: u32,

543

) -> Result<PointNumbers, ParseError> {

544

    let count = read_count(ctxt)?;

545

    // If the first byte is 0, then a second count byte is not used. This value has

546

    // a special meaning: the tuple variation data provides deltas for all glyph

547

    // points (including the “phantom” points), or for all CVTs.

548

    if count == 0 {

549

        return Ok(PointNumbers::All(num_points));

550

551

552

    let mut num_read = 0;

553

    let mut point_numbers = Vec::with_capacity(usize::from(count));

554

    while num_read < count {

555

        let control_byte = ctxt.read_u8()?;

556

        let point_run_count = u16::from(control_byte & PointNumbers::POINT_RUN_COUNT_MASK) + 1;

557

        let last_point_number = point_numbers.last().copied().unwrap_or(0);

558

        if (control_byte & PointNumbers::POINTS_ARE_WORDS) == PointNumbers::POINTS_ARE_WORDS {

559

            // Points are words (2 bytes)

560

            let array = ctxt.read_array::<U16Be>(point_run_count.into())?;

561

            point_numbers.extend(array.iter().scan(last_point_number, |prev, diff| {

562

                let number = *prev + diff;

563

                *prev = number;

564

                Some(number)

565

            }));

566

        } else {

567

            // Points are single bytes

568

            let array = ctxt.read_array::<U8>(point_run_count.into())?;

569

            point_numbers.extend(array.iter().scan(last_point_number, |prev, diff| {

570

                let number = *prev + u16::from(diff);

571

                *prev = number;

572

                Some(number)

573

            }));

574

575

        num_read += point_run_count;

576

577

    Ok(PointNumbers::Specific(point_numbers))

578

579

580

// The count may be stored in one or two bytes:

581

//

582

// * If the first byte is 0, then a second count byte is not used. This value

583

//   has a special meaning: the tuple variation data provides deltas for all

584

//   glyph points (including the “phantom” points), or for all CVTs.

585

// * If the first byte is non-zero and the high bit is clear (value is 1 to

586

//   127), then a second count byte is not used. The point count is equal to the

587

//   value of the first byte.

588

// * If the high bit of the first byte is set, then a second byte is used. The

589

//   count is read from interpreting the two bytes as a big-endian uint16 value

590

//   with the high-order bit masked out.

591

fn read_count(ctxt: &mut ReadCtxt<'_>) -> Result<u16, ParseError> {

592

    let count1 = u16::from(ctxt.read_u8()?);

593

    let count = match count1 {

594

        0 => 0,

595

        1..=127 => count1,

596

        128.. => {

597

            let count2 = ctxt.read_u8()?;

598

            ((count1 & 0x7F) << 8) | u16::from(count2)

599

600

};

601

    Ok(count)

602

603

604

mod packed_deltas {

605

606

    use crate::binary::read::ReadCtxt;

607

    use crate::binary::{I16Be, I8};

608

    use crate::error::ParseError;

609

    use crate::SafeFrom;

610

611

    /// Flag indicating that this run contains no data (no explicit delta values

612

    /// are stored), and that the deltas for this run are all zero.

613

    const DELTAS_ARE_ZERO: u8 = 0x80;

614

    /// Flag indicating the data type for delta values in the run.

615

///

616

    /// If set, the run contains 16-bit signed deltas (int16); if clear, the run

617

    /// contains 8-bit signed deltas (int8).

618

    const DELTAS_ARE_WORDS: u8 = 0x40;

619

    /// Mask for the low 6 bits to provide the number of delta values in the

620

    /// run, minus one.

621

    const DELTA_RUN_COUNT_MASK: u8 = 0x3F;

622

623

    /// Read `num_deltas` packed deltas.

624

///

625

    /// <https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats#packed-deltas>

626

    pub(super) fn read(ctxt: &mut ReadCtxt<'_>, num_deltas: u32) -> Result<Vec<i16>, ParseError> {

627

        let mut deltas_read = 0;

628

        let mut deltas = Vec::with_capacity(usize::safe_from(num_deltas));

629

630

        while deltas_read < usize::safe_from(num_deltas) {

631

            let control_byte = ctxt.read_u8()?;

632

            let count = usize::from(control_byte & DELTA_RUN_COUNT_MASK) + 1; // value is stored - 1

633

            deltas.reserve(count);

634

            if (control_byte & DELTAS_ARE_ZERO) == DELTAS_ARE_ZERO {

635

                deltas.extend(std::iter::repeat_n(0, count));

636

            } else if (control_byte & DELTAS_ARE_WORDS) == DELTAS_ARE_WORDS {

637

                // Points are words (2 bytes)

638

                let array = ctxt.read_array::<I16Be>(count)?;

639

                deltas.extend(array.iter())

640

            } else {

641

                // Points are single bytes

642

                let array = ctxt.read_array::<I8>(count)?;

643

                deltas.extend(array.iter().map(i16::from));

644

};

645

            deltas_read += count;

646

647

648

        Ok(deltas)

649

650

651

652

impl GvarVariationData<'_> {

653

    /// Iterates over the point numbers and (x, y) deltas.

654

    pub fn iter(&self) -> impl Iterator<Item = (u32, (i16, i16))> + '_ {

655

        let deltas = self

656

            .x_coord_deltas

657

            .iter()

658

            .copied()

659

            .zip(self.y_coord_deltas.iter().copied());

660

        self.point_numbers.iter().zip(deltas)

661

662

663

    /// Returns the number of point numbers.

664

    pub fn len(&self) -> usize {

665

        self.point_numbers.len()

666

667

668

669

impl CvarVariationData<'_> {

670

    /// Iterates over the cvt indexes and deltas.

671

    pub fn iter(&self) -> impl Iterator<Item = (u32, i16)> + '_ {

672

        self.point_numbers.iter().zip(self.deltas.iter().copied())

673

674

675

    /// Returns the number of cvt indexes.

676

    pub fn len(&self) -> usize {

677

        self.point_numbers.len()

678

679

680

681

impl<'data> TupleVariationHeader<'data, Gvar> {

682

    /// Read the variation data for `gvar`.

683

///

684

    /// `num_points` is the number of points in the glyph this variation relates

685

    /// to.

686

    pub fn variation_data<'a>(

687

        &'a self,

688

        num_points: NumPoints,

689

        shared_point_numbers: Option<SharedPointNumbers<'a>>,

690

    ) -> Result<GvarVariationData<'a>, ParseError> {

691

        let mut ctxt = ReadScope::new(self.data).ctxt();

692

693

        let point_numbers =

694

            self.read_point_numbers(&mut ctxt, num_points.get(), shared_point_numbers)?;

695

        let num_deltas = u32::try_from(point_numbers.len()).map_err(ParseError::from)?;

696

697

        // The deltas are stored X, followed by Y but the delta runs can span the

698

        // boundary of the two so they need to be read as a single span of

699

        // packed deltas and then split.

700

        let mut x_coord_deltas = packed_deltas::read(&mut ctxt, 2 * num_deltas)?;

701

        let y_coord_deltas = x_coord_deltas.split_off(usize::safe_from(num_deltas));

702

703

        Ok(GvarVariationData {

704

            point_numbers,

705

            x_coord_deltas,

706

            y_coord_deltas,

707

})

708

709

710

    /// Returns the index of the shared tuple that this header relates to.

711

///

712

    /// The tuple index is an index into the shared tuples of the `Gvar` table.

713

    /// Pass this value to the [shared_tuple](gvar::GvarTable::shared_tuple)

714

    /// method to retrieve the tuple.

715

///

716

    /// The value returned from this method will be `None` if the header has an

717

    /// embedded peak tuple.

718

    pub fn tuple_index(&self) -> Option<u16> {

719

        self.peak_tuple

720

            .is_none()

721

            .then_some(self.tuple_flags_and_index & Self::TUPLE_INDEX_MASK)

722

723

724

    /// Returns the peak tuple for this tuple variation record.

725

///

726

    /// If the record contains an embedded peak tuple then that is returned,

727

    /// otherwise the referenced shared peak tuple is returned.

728

    pub fn peak_tuple<'a>(

729

        &'a self,

730

        gvar: &'a GvarTable<'data>,

731

    ) -> Result<ReadTuple<'data>, ParseError> {

732

        match self.peak_tuple.as_ref() {

733

            // NOTE(clone): cheap as ReadTuple is just a wrapper around ReadArray

734

            Some(tuple) => Ok(tuple.clone()),

735

            None => {

736

                let shared_index = self.tuple_flags_and_index & Self::TUPLE_INDEX_MASK;

737

                gvar.shared_tuple(shared_index)

738

739

740

741

742

743

impl<'data> PeakTuple<'data> for TupleVariationHeader<'data, Gvar> {

744

    type Table = GvarTable<'data>;

745

746

    fn peak_tuple<'a>(&'a self, table: &'a Self::Table) -> Result<ReadTuple<'data>, ParseError> {

747

        self.peak_tuple(table)

748

749

750

751

impl<'data> TupleVariationHeader<'data, Cvar> {

752

    /// Read the variation data for `cvar`.

753

///

754

    /// `num_cvts` is the number of CVTs in the CVT table.

755

    fn variation_data<'a>(

756

        &'a self,

757

        num_cvts: u32,

758

        shared_point_numbers: Option<SharedPointNumbers<'a>>,

759

    ) -> Result<CvarVariationData<'a>, ParseError> {

760

        let mut ctxt = ReadScope::new(self.data).ctxt();

761

762

        let point_numbers = self.read_point_numbers(&mut ctxt, num_cvts, shared_point_numbers)?;

763

        let num_deltas = u32::try_from(point_numbers.len()).map_err(ParseError::from)?;

764

        let deltas = packed_deltas::read(&mut ctxt, num_deltas)?;

765

766

        Ok(CvarVariationData {

767

            point_numbers,

768

            deltas,

769

})

770

771

772

    /// Returns the embedded peak tuple if present.

773

///

774

    /// The peak tuple is meant to always be present in `cvar` tuple variations,

775

    /// so `None` indicates an invalid font.

776

    pub fn peak_tuple(&self) -> Option<ReadTuple<'data>> {

777

        self.peak_tuple.clone()

778

779

780

781

impl<'data> PeakTuple<'data> for TupleVariationHeader<'data, Cvar> {

782

    type Table = CvarTable<'data>;

783

784

    fn peak_tuple<'a>(&'a self, _table: &'a Self::Table) -> Result<ReadTuple<'data>, ParseError> {

785

        self.peak_tuple().ok_or(ParseError::MissingValue)

786

787

788

789

impl<'data, T> TupleVariationHeader<'data, T> {

790

    /// Flag indicating that this tuple variation header includes an embedded

791

    /// peak tuple record, immediately after the tupleIndex field.

792

///

793

    /// If set, the low 12 bits of the tupleIndex value are ignored.

794

///

795

    /// Note that this must always be set within the `cvar` table.

796

    const EMBEDDED_PEAK_TUPLE: u16 = 0x8000;

797

798

    /// Flag indicating that this tuple variation table applies to an

799

    /// intermediate region within the variation space.

800

///

801

    /// If set, the header includes the two intermediate-region, start and end

802

    /// tuple records, immediately after the peak tuple record (if present).

803

    const INTERMEDIATE_REGION: u16 = 0x4000;

804

805

    /// Flag indicating that the serialized data for this tuple variation table

806

    /// includes packed “point” number data.

807

///

808

    /// If set, this tuple variation table uses that number data; if clear, this

809

    /// tuple variation table uses shared number data found at the start of

810

    /// the serialized data for this glyph variation data or 'cvar' table.

811

    const PRIVATE_POINT_NUMBERS: u16 = 0x2000;

812

813

    /// Mask for the low 12 bits to give the shared tuple records index.

814

    const TUPLE_INDEX_MASK: u16 = 0x0FFF;

815

816

    /// Read the point numbers for this tuple.

817

///

818

    /// This method will return either the embedded private point numbers or the

819

    /// shared numbers if private points are not present.

820

    fn read_point_numbers<'a>(

821

        &'a self,

822

        ctxt: &mut ReadCtxt<'data>,

823

        num_points: u32,

824

        shared_point_numbers: Option<SharedPointNumbers<'a>>,

825

    ) -> Result<Cow<'a, PointNumbers>, ParseError> {

826

        // Read private point numbers if the flag indicates they are present

827

        let private_point_numbers = if (self.tuple_flags_and_index & Self::PRIVATE_POINT_NUMBERS)

828

            == Self::PRIVATE_POINT_NUMBERS

829

830

            read_packed_point_numbers(ctxt, num_points).map(Some)?

831

        } else {

832

            None

833

};

834

835

        // If there are private point numbers then we need to read that many points

836

        // otherwise we need to read as many points are specified by the shared points.

837

//

838

        // Either private or shared point numbers should be present. If both are missing

839

        // that's invalid.

840

        private_point_numbers

841

            .map(Cow::Owned)

842

            .or_else(|| shared_point_numbers.map(|shared| Cow::Borrowed(shared.0)))

843

            .ok_or(ParseError::MissingValue)

844

845

846

    /// Returns the intermediate region of the tuple variation space that this

847

    /// variation applies to.

848

///

849

    /// If an intermediate region is not specified (the region is implied by the

850

    /// peak tuple) then this will be `None`.

851

    pub fn intermediate_region(&self) -> Option<(ReadTuple<'data>, ReadTuple<'data>)> {

852

        // NOTE(clone): Cheap as ReadTuple just contains ReadArray

853

        self.intermediate_region.clone()

854

855

856

857

impl<T> ReadBinaryDep for TupleVariationHeader<'_, T> {

858

    type Args<'a> = usize;

859

    type HostType<'a> = TupleVariationHeader<'a, T>;

860

861

    fn read_dep<'a>(

862

        ctxt: &mut ReadCtxt<'a>,

863

        axis_count: usize,

864

    ) -> Result<Self::HostType<'a>, ParseError> {

865

        // The size in bytes of the serialized data for this tuple variation table.

866

        let variation_data_size = ctxt.read_u16be()?;

867

        // A packed field. The high 4 bits are flags. The low 12 bits are an index into

868

        // a shared tuple records array.

869

        let tuple_flags_and_index = ctxt.read_u16be()?;

870

        // If this is absent then `tuple_flags_and_index` contains the index to one of

871

        // the shared tuple records to use instead:

872

//

873

        // > Every tuple variation table has a peak n-tuple indicated either by an

874

        // > embedded tuple

875

        // > record (always true in the 'cvar' table) or by an index into a shared tuple

876

        // > records

877

        // > array (only in the 'gvar' table).

878

        let peak_tuple = ((tuple_flags_and_index & Self::EMBEDDED_PEAK_TUPLE)

879

            == Self::EMBEDDED_PEAK_TUPLE)

880

            .then(|| ctxt.read_array(axis_count).map(ReadTuple))

881

            .transpose()?;

882

        let intermediate_region =

883

            if (tuple_flags_and_index & Self::INTERMEDIATE_REGION) == Self::INTERMEDIATE_REGION {

884

                let start = ctxt.read_array(axis_count).map(ReadTuple)?;

885

                let end = ctxt.read_array(axis_count).map(ReadTuple)?;

886

                Some((start, end))

887

            } else {

888

                None

889

};

890

        Ok(TupleVariationHeader {

891

            variation_data_size,

892

            tuple_flags_and_index,

893

            peak_tuple,

894

            intermediate_region,

895

            data: &[], // filled in later

896

            variant: PhantomData,

897

})

898

899

900

901

impl fmt::Debug for TupleVariationHeader<'_, Gvar> {

902

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

903

        let mut debug_struct = f.debug_struct("TupleVariationHeader");

904

        match &self.peak_tuple {

905

            Some(peak) => debug_struct.field("peak_tuple", peak),

906

            None => debug_struct.field("shared_tuple_index", &self.tuple_index()),

907

};

908

        debug_struct

909

            .field("intermediate_region", &self.intermediate_region)

910

            .finish()

911

912

913

914

impl<'a> ItemVariationStore<'a> {

915

    /// Retrieve the scaled delta adjustment at the supplied `delta_set_entry` according to the

916

    /// user tuple `instance`.

917

    pub fn adjustment(

918

        &self,

919

        delta_set_entry: DeltaSetIndexMapEntry,

920

        instance: &OwnedTuple,

921

    ) -> Result<f32, ParseError> {

922

        let item_variation_data = self

923

            .item_variation_data

924

            .get(usize::from(delta_set_entry.outer_index))

925

            .ok_or(ParseError::BadIndex)?;

926

        let delta_set = item_variation_data

927

            .delta_set(delta_set_entry.inner_index)

928

            .ok_or(ParseError::BadIndex)?;

929

930

        let mut adjustment = 0.;

931

        for (delta, region_index) in delta_set

932

            .iter()

933

            .zip(item_variation_data.region_indexes.iter())

934

935

            let region = self

936

                .variation_region(region_index)

937

                .ok_or(ParseError::BadIndex)?;

938

            if let Some(scalar) = region.scalar(instance.iter().copied()) {

939

                adjustment += scalar * delta as f32;

940

941

942

        Ok(adjustment)

943

944

945

    /// Iterate over the variation regions of the ItemVariationData at `index`.

946

    pub fn regions(

947

        &self,

948

        index: u16,

949

    ) -> Result<impl Iterator<Item = Result<VariationRegion<'a>, ParseError>> + '_, ParseError>

950

951

        let item_variation_data = self

952

            .item_variation_data

953

            .get(usize::from(index))

954

            .ok_or(ParseError::BadIndex)?;

955

        Ok(item_variation_data

956

            .region_indexes

957

            .iter()

958

            .map(move |region_index| {

959

                self.variation_region(region_index)

960

                    .ok_or(ParseError::BadIndex)

961

}))

962

963

964

    fn variation_region(&self, region_index: u16) -> Option<VariationRegion<'a>> {

965

        let region_index = usize::from(region_index);

966

        self.variation_region_list

967

            .variation_regions

968

            .read_item(region_index)

969

            .ok()

970

971

972

    /// Returns an owned version of `self`.

973

    pub fn try_to_owned(&self) -> Result<owned::ItemVariationStore, ParseError> {

974

        let item_variation_data = self

975

            .item_variation_data

976

            .iter()

977

            .map(|data| data.to_owned())

978

            .collect();

979

        Ok(owned::ItemVariationStore {

980

            variation_region_list: self.variation_region_list.try_to_owned()?,

981

            item_variation_data,

982

})

983

984

985

986

impl ReadBinary for ItemVariationStore<'_> {

987

    type HostType<'a> = ItemVariationStore<'a>;

988

989

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

990

        let scope = ctxt.scope();

991

        let format = ctxt.read_u16be()?;

992

        ctxt.check(format == 1)?;

993

        let variation_region_list_offset = ctxt.read_u32be()?;

994

        let item_variation_data_count = ctxt.read_u16be()?;

995

        let item_variation_data_offsets =

996

            ctxt.read_array::<U32Be>(usize::from(item_variation_data_count))?;

997

        let variation_region_list = scope

998

            .offset(usize::safe_from(variation_region_list_offset))

999

            .read::<VariationRegionList<'_>>()?;

1000

        let item_variation_data = item_variation_data_offsets

1001

            .iter()

1002

            .map(|offset| {

1003

                scope

1004

                    .offset(usize::safe_from(offset))

1005

                    .read::<ItemVariationData<'_>>()

1006

})

1007

            .collect::<Result<Vec<_>, _>>()?;

1008

1009

        Ok(ItemVariationStore {

1010

            variation_region_list,

1011

            item_variation_data,

1012

})

1013

1014

1015

1016

impl VariationRegionList<'_> {

1017

    fn try_to_owned(&self) -> Result<owned::VariationRegionList, ParseError> {

1018

        let variation_regions = self

1019

            .variation_regions

1020

            .iter_res()

1021

            .map(|region| region.map(|region| region.to_owned()))

1022

            .collect::<Result<_, _>>()?;

1023

        Ok(owned::VariationRegionList { variation_regions })

1024

1025

1026

1027

impl WriteBinary<&Self> for ItemVariationStore<'_> {

1028

    type Output = ();

1029

1030

    fn write<C: WriteContext>(ctxt: &mut C, store: &Self) -> Result<Self::Output, WriteError> {

1031

        U16Be::write(ctxt, 1u16)?; // format

1032

        let variation_region_list_offset_placeholder = ctxt.placeholder::<U16Be, _>()?;

1033

        U16Be::write(ctxt, u16::try_from(store.item_variation_data.len())?)?;

1034

        let item_variation_data_offsets_placeholders =

1035

            ctxt.placeholder_array::<U32Be, _>(store.item_variation_data.len())?;

1036

1037

        // Write out the VariationRegionList

1038

        ctxt.write_placeholder(

1039

            variation_region_list_offset_placeholder,

1040

            u16::try_from(ctxt.bytes_written())?,

1041

)?;

1042

        VariationRegionList::write(ctxt, &store.variation_region_list)?;

1043

1044

        // Write the ItemVariationData sub-tables

1045

        for (offset_placeholder, variation_data) in item_variation_data_offsets_placeholders

1046

            .into_iter()

1047

            .zip(store.item_variation_data.iter())

1048

1049

            ctxt.write_placeholder(offset_placeholder, u32::try_from(ctxt.bytes_written())?)?;

1050

            ItemVariationData::write(ctxt, variation_data)?;

1051

1052

1053

        Ok(())

1054

1055

1056

1057

impl ReadBinary for VariationRegionList<'_> {

1058

    type HostType<'a> = VariationRegionList<'a>;

1059

1060

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

1061

        let axis_count = ctxt.read_u16be()?;

1062

        let region_count = ctxt.read_u16be()?;

1063

        // The high-order bit of the region_count field is reserved for future use,

1064

        // and must be cleared.

1065

        ctxt.check(region_count < 32768)?;

1066

        let variation_regions = ctxt.read_array_dep(usize::from(region_count), axis_count)?;

1067

        Ok(VariationRegionList { variation_regions })

1068

1069

1070

1071

impl WriteBinary<&Self> for VariationRegionList<'_> {

1072

    type Output = ();

1073

1074

    fn write<C: WriteContext>(

1075

        ctxt: &mut C,

1076

        region_list: &Self,

1077

    ) -> Result<Self::Output, WriteError> {

1078

        U16Be::write(ctxt, *region_list.variation_regions.args())?; // axis count

1079

        U16Be::write(ctxt, u16::try_from(region_list.variation_regions.len())?)?; // region count

1080

        for region in region_list.variation_regions.iter_res() {

1081

            let region = region.map_err(|_| WriteError::BadValue)?;

1082

            VariationRegion::write(ctxt, &region)?;

1083

1084

        Ok(())

1085

1086

1087

1088

// In general, variation deltas are, logically, signed 16-bit integers, and in

1089

// most cases, they are applied to signed 16-bit values The LONG_WORDS flag

1090

// should only be used in top-level tables that include 32-bit values that can

1091

// be variable — currently, only the COLR table.

1092

/// Delta data for variations.

1093

pub struct DeltaSet<'a> {

1094

    long_deltas: bool,

1095

    word_data: &'a [u8],

1096

    short_data: &'a [u8],

1097

1098

1099

impl DeltaSet<'_> {

1100

    fn iter(&self) -> impl Iterator<Item = i32> + '_ {

1101

        // NOTE(unwrap): Safe as `mid` is multiple of U32Be::SIZE

1102

        let (short_size, long_size) = if self.long_deltas {

1103

            (I16Be::SIZE, I32Be::SIZE)

1104

        } else {

1105

            (I8::SIZE, I16Be::SIZE)

1106

};

1107

        let words = self.word_data.chunks(long_size).map(move |chunk| {

1108

            if self.long_deltas {

1109

                i32::from_be_bytes(chunk.try_into().unwrap())

1110

            } else {

1111

                i32::from(i16::from_be_bytes(chunk.try_into().unwrap()))

1112

1113

});

1114

        let shorts = self.short_data.chunks(short_size).map(move |chunk| {

1115

            if self.long_deltas {

1116

                i32::from(i16::from_be_bytes(chunk.try_into().unwrap()))

1117

            } else {

1118

                i32::from(chunk[0] as i8)

1119

1120

});

1121

1122

        words.chain(shorts)

1123

1124

1125

1126

trait DeltaSetT {

1127

    /// Flag indicating that "word" deltas are long (int32)

1128

    const LONG_WORDS: u16 = 0x8000;

1129

1130

    /// Count of "word" deltas

1131

    const WORD_DELTA_COUNT_MASK: u16 = 0x7FFF;

1132

1133

    fn delta_sets(&self) -> &[u8];

1134

1135

    fn raw_word_delta_count(&self) -> u16;

1136

1137

    fn region_index_count(&self) -> u16;

1138

1139

    /// Retrieve a delta-set row within this item variation data sub-table.

1140

    fn delta_set_impl(&self, index: u16) -> Option<DeltaSet<'_>> {

1141

        let row_length = self.row_length();

1142

        let row_data = self

1143

            .delta_sets()

1144

            .get(usize::from(index) * row_length..)

1145

            .and_then(|offset| offset.get(..row_length))?;

1146

        let mid = self.word_delta_count() * self.word_delta_size();

1147

        if mid > row_data.len() {

1148

            return None;

1149

1150

        let (word_data, short_data) = row_data.split_at(mid);

1151

1152

        // Check that short data is a multiple of the short size

1153

        if short_data.len() % self.short_delta_size() != 0 {

1154

            return None;

1155

1156

1157

        Some(DeltaSet {

1158

            long_deltas: self.long_deltas(),

1159

            word_data,

1160

            short_data,

1161

})

1162

1163

1164

    fn word_delta_count(&self) -> usize {

1165

        usize::from(self.raw_word_delta_count() & Self::WORD_DELTA_COUNT_MASK)

1166

1167

1168

    fn long_deltas(&self) -> bool {

1169

        self.raw_word_delta_count() & Self::LONG_WORDS != 0

1170

1171

1172

    fn row_length(&self) -> usize {

1173

        calculate_row_length(self.region_index_count(), self.raw_word_delta_count())

1174

1175

1176

    fn word_delta_size(&self) -> usize {

1177

        if self.long_deltas() {

1178

            I32Be::SIZE

1179

        } else {

1180

            I16Be::SIZE

1181

1182

1183

1184

    fn short_delta_size(&self) -> usize {

1185

        if self.long_deltas() {

1186

            I16Be::SIZE

1187

        } else {

1188

            U8::SIZE

1189

1190

1191

1192

1193

fn calculate_row_length(region_index_count: u16, raw_word_delta_count: u16) -> usize {

1194

    let row_length = usize::from(region_index_count)

1195

        + usize::from(raw_word_delta_count & ItemVariationData::WORD_DELTA_COUNT_MASK);

1196

    if raw_word_delta_count & ItemVariationData::LONG_WORDS == 0 {

1197

        row_length

1198

    } else {

1199

        row_length * 2

1200

1201

1202

1203

impl DeltaSetT for ItemVariationData<'_> {

1204

    fn delta_sets(&self) -> &[u8] {

1205

        self.delta_sets

1206

1207

1208

    fn raw_word_delta_count(&self) -> u16 {

1209

        self.word_delta_count

1210

1211

1212

    fn region_index_count(&self) -> u16 {

1213

        self.region_index_count

1214

1215

1216

1217

impl ItemVariationData<'_> {

1218

    /// Retrieve the set of deltas at the supplied `index`.

1219

    pub fn delta_set(&self, index: u16) -> Option<DeltaSet<'_>> {

1220

        self.delta_set_impl(index)

1221

1222

1223

    fn to_owned(&self) -> owned::ItemVariationData {

1224

        owned::ItemVariationData {

1225

            word_delta_count: self.word_delta_count,

1226

            region_index_count: self.region_index_count(),

1227

            region_indexes: self.region_indexes.to_vec(),

1228

            delta_sets: Box::from(self.delta_sets),

1229

1230

1231

1232

1233

impl ReadBinary for ItemVariationData<'_> {

1234

    type HostType<'a> = ItemVariationData<'a>;

1235

1236

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

1237

        let item_count = ctxt.read_u16be()?;

1238

        let word_delta_count = ctxt.read_u16be()?;

1239

        let region_index_count = ctxt.read_u16be()?;

1240

        let region_indexes = ctxt.read_array::<U16Be>(usize::from(region_index_count))?;

1241

        let row_length = calculate_row_length(region_index_count, word_delta_count);

1242

        let delta_sets = ctxt.read_slice(usize::from(item_count) * row_length)?;

1243

1244

        Ok(ItemVariationData {

1245

            item_count,

1246

            word_delta_count,

1247

            region_index_count,

1248

            region_indexes,

1249

            delta_sets,

1250

})

1251

1252

1253

1254

impl WriteBinary<&Self> for ItemVariationData<'_> {

1255

    type Output = ();

1256

1257

    fn write<C: WriteContext>(

1258

        ctxt: &mut C,

1259

        variation_data: &Self,

1260

    ) -> Result<Self::Output, WriteError> {

1261

        U16Be::write(ctxt, variation_data.item_count)?;

1262

        U16Be::write(ctxt, variation_data.word_delta_count)?;

1263

        U16Be::write(ctxt, u16::try_from(variation_data.region_indexes.len())?)?;

1264

        ctxt.write_array(&variation_data.region_indexes)?;

1265

        ctxt.write_bytes(variation_data.delta_sets)?;

1266

        Ok(())

1267

1268

1269

1270

impl VariationRegion<'_> {

1271

    pub(crate) fn scalar(&self, tuple: impl Iterator<Item = F2Dot14>) -> Option<f32> {

1272

        scalar(self.region_axes.iter(), tuple)

1273

1274

1275

    fn to_owned(&self) -> owned::VariationRegion {

1276

        owned::VariationRegion {

1277

            region_axes: self.region_axes.to_vec(),

1278

1279

1280

1281

1282

pub(crate) fn scalar(

1283

    region_axes: impl Iterator<Item = RegionAxisCoordinates>,

1284

    tuple: impl Iterator<Item = F2Dot14>,

1285

) -> Option<f32> {

1286

    let scalar = region_axes

1287

        .zip(tuple)

1288

        .map(|(region, instance)| {

1289

            let RegionAxisCoordinates {

1290

                start_coord: start,

1291

                peak_coord: peak,

1292

                end_coord: end,

1293

            } = region;

1294

            calculate_scalar(instance, start, peak, end)

1295

})

1296

        .fold(1., |scalar, axis_scalar| scalar * axis_scalar);

1297

1298

    (scalar != 0.).then_some(scalar)

1299

1300

1301

fn calculate_scalar(instance: F2Dot14, start: F2Dot14, peak: F2Dot14, end: F2Dot14) -> f32 {

1302

    // If peak is zero or not contained by the region of applicability then it does

1303

    // not apply

1304

    if peak == F2Dot14::from(0) {

1305

        // If the peak is zero for some axis, then ignore the axis.

1306

1.

1307

    } else if (start..=end).contains(&instance) {

1308

        // The region is applicable: calculate a per-axis scalar as a proportion

1309

        // of the proximity of the instance to the peak within the region.

1310

        if instance == peak {

1311

1.

1312

        } else if instance < peak {

1313

            (f32::from(instance) - f32::from(start)) / (f32::from(peak) - f32::from(start))

1314

        } else {

1315

            // instance > peak

1316

            (f32::from(end) - f32::from(instance)) / (f32::from(end) - f32::from(peak))

1317

1318

    } else {

1319

        // If the instance coordinate is out of range for some axis, then the region and

1320

        // its associated deltas are not applicable.

1321

0.

1322

1323

1324

1325

impl ReadBinaryDep for VariationRegion<'_> {

1326

    type Args<'a> = u16;

1327

    type HostType<'a> = VariationRegion<'a>;

1328

1329

    fn read_dep<'a>(

1330

        ctxt: &mut ReadCtxt<'a>,

1331

        axis_count: u16,

1332

    ) -> Result<Self::HostType<'a>, ParseError> {

1333

        let region_axes = ctxt.read_array(usize::from(axis_count))?;

1334

        Ok(VariationRegion { region_axes })

1335

1336

1337

1338

impl ReadFixedSizeDep for VariationRegion<'_> {

1339

    fn size(axis_count: u16) -> usize {

1340

        usize::from(axis_count) * RegionAxisCoordinates::SIZE

1341

1342

1343

1344

impl WriteBinary<&Self> for VariationRegion<'_> {

1345

    type Output = ();

1346

1347

    fn write<C: WriteContext>(ctxt: &mut C, region: &Self) -> Result<Self::Output, WriteError> {

1348

        ctxt.write_array(&region.region_axes)

1349

1350

1351

1352

impl ReadFrom for RegionAxisCoordinates {

1353

    type ReadType = (F2Dot14, F2Dot14, F2Dot14);

1354

1355

    fn read_from((start_coord, peak_coord, end_coord): (F2Dot14, F2Dot14, F2Dot14)) -> Self {

1356

        RegionAxisCoordinates {

1357

            start_coord,

1358

            peak_coord,

1359

            end_coord,

1360

1361

1362

1363

1364

impl WriteBinary for RegionAxisCoordinates {

1365

    type Output = ();

1366

1367

    fn write<C: WriteContext>(ctxt: &mut C, coords: Self) -> Result<Self::Output, WriteError> {

1368

        F2Dot14::write(ctxt, coords.start_coord)?;

1369

        F2Dot14::write(ctxt, coords.peak_coord)?;

1370

        F2Dot14::write(ctxt, coords.end_coord)?;

1371

        Ok(())

1372

1373

1374

1375

impl DeltaSetIndexMap<'_> {

1376

    /// Mask for the low 4 bits of the DeltaSetIndexMap entry format.

1377

///

1378

    /// Gives the count of bits minus one that are used in each entry for the

1379

    /// inner-level index.

1380

    const INNER_INDEX_BIT_COUNT_MASK: u8 = 0x0F;

1381

1382

    /// Mask for bits of the DeltaSetIndexMap entry format that indicate the

1383

    /// size in bytes minus one of each entry.

1384

    const MAP_ENTRY_SIZE_MASK: u8 = 0x30;

1385

1386

    /// Returns delta-set outer-level index and inner-level index combination.

1387

    pub fn entry(&self, mut i: u32) -> Result<DeltaSetIndexMapEntry, ParseError> {

1388

        // If an index into the mapping array is used that is greater than or equal to mapCount,

1389

        // then the last logical entry of the mapping array is used.

1390

//

1391

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

1392

        if i >= self.map_count {

1393

            i = self.map_count.checked_sub(1).ok_or(ParseError::BadIndex)?;

1394

1395

1396

        let entry_size = usize::from(self.entry_size());

1397

        let offset = usize::safe_from(i) * entry_size;

1398

        let entry_bytes = self

1399

            .map_data

1400

            .get(offset..(offset + entry_size))

1401

            .ok_or(ParseError::BadIndex)?;

1402

1403

        // entry can be 1, 2, 3, or 4 bytes

1404

        let entry = entry_bytes

1405

            .iter()

1406

            .copied()

1407

            .fold(0u32, |entry, byte| (entry << 8) | u32::from(byte));

1408

        let outer_index =

1409

            (entry >> (u32::from(self.entry_format & Self::INNER_INDEX_BIT_COUNT_MASK) + 1)) as u16;

1410

        let inner_index = (entry

1411

            & ((1 << (u32::from(self.entry_format & Self::INNER_INDEX_BIT_COUNT_MASK) + 1)) - 1))

1412

            as u16;

1413

1414

        Ok(DeltaSetIndexMapEntry {

1415

            outer_index,

1416

            inner_index,

1417

})

1418

1419

1420

    /// Returns the number of entries in this map.

1421

    pub fn len(&self) -> usize {

1422

        usize::safe_from(self.map_count)

1423

1424

1425

    /// The size of an entry in bytes

1426

    fn entry_size(&self) -> u8 {

1427

        Self::entry_size_impl(self.entry_format)

1428

1429

1430

    fn entry_size_impl(entry_format: u8) -> u8 {

1431

        ((entry_format & Self::MAP_ENTRY_SIZE_MASK) >> 4) + 1

1432

1433

1434

1435

impl ReadBinary for DeltaSetIndexMap<'_> {

1436

    type HostType<'a> = DeltaSetIndexMap<'a>;

1437

1438

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

1439

        let format = ctxt.read_u8()?;

1440

        let entry_format = ctxt.read_u8()?;

1441

        let map_count = match format {

1442

            0 => ctxt.read_u16be().map(u32::from)?,

1443

            1 => ctxt.read_u32be()?,

1444

            _ => return Err(ParseError::BadVersion),

1445

};

1446

        let entry_size = DeltaSetIndexMap::entry_size_impl(entry_format);

1447

        let map_size = usize::from(entry_size) * usize::safe_from(map_count);

1448

        let map_data = ctxt.read_slice(map_size)?;

1449

1450

        Ok(DeltaSetIndexMap {

1451

            entry_format,

1452

            map_count,

1453

            map_data,

1454

})

1455

1456

1457

1458

impl fmt::Debug for DeltaSetIndexMap<'_> {

1459

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

1460

        let DeltaSetIndexMap {

1461

            entry_format,

1462

            map_count,

1463

            map_data,

1464

        } = self;

1465

        f.debug_struct("DeltaSetIndexMap")

1466

            .field("entry_format", entry_format)

1467

            .field("map_count", map_count)

1468

            .field("map_data", &DebugData(map_data))

1469

            .finish()

1470

1471

1472

1473

enum Coordinates<'a> {

1474

    Tuple(ReadTuple<'a>),

1475

    Array(TinyVec<[F2Dot14; 4]>),

1476

1477

1478

struct CoordinatesIter<'a, 'data> {

1479

    coords: &'a Coordinates<'data>,

1480

    index: usize,

1481

1482

1483

impl<'data> Coordinates<'data> {

1484

    pub fn iter(&self) -> CoordinatesIter<'_, 'data> {

1485

        CoordinatesIter {

1486

            coords: self,

1487

            index: 0,

1488

1489

1490

1491

    pub fn len(&self) -> usize {

1492

        match self {

1493

            Coordinates::Tuple(coords) => coords.0.len(),

1494

            Coordinates::Array(coords) => coords.len(),

1495

1496

1497

1498

1499

impl Iterator for CoordinatesIter<'_, '_> {

1500

    type Item = F2Dot14;

1501

1502

    fn next(&mut self) -> Option<Self::Item> {

1503

        if self.index >= self.coords.len() {

1504

            return None;

1505

1506

1507

        let index = self.index;

1508

        self.index += 1;

1509

        match self.coords {

1510

            Coordinates::Tuple(coords) => coords.0.get_item(index),

1511

            Coordinates::Array(coords) => Some(coords[index]),

1512

1513

1514

1515

1516

#[cfg(test)]

1517

mod tests {

1518

    use super::*;

1519

    use crate::binary::read::ReadScope;

1520

1521

    #[test]

1522

    fn test_read_count() {

1523

        let mut ctxt = ReadScope::new(&[0]).ctxt();

1524

        assert_eq!(read_count(&mut ctxt).unwrap(), 0);

1525

        let mut ctxt = ReadScope::new(&[0x32]).ctxt();

1526

        assert_eq!(read_count(&mut ctxt).unwrap(), 50);

1527

        let mut ctxt = ReadScope::new(&[0x81, 0x22]).ctxt();

1528

        assert_eq!(read_count(&mut ctxt).unwrap(), 290);

1529

1530

1531

    #[test]

1532

    fn test_read_packed_point_numbers() {

1533

        let data = [0x0d, 0x0c, 1, 4, 4, 2, 1, 2, 3, 3, 2, 1, 1, 3, 4];

1534

        let mut ctxt = ReadScope::new(&data).ctxt();

1535

1536

        let expected = vec![1, 5, 9, 11, 12, 14, 17, 20, 22, 23, 24, 27, 31];

1537

        assert_eq!(

1538

            read_packed_point_numbers(&mut ctxt, expected.len() as u32)

1539

                .unwrap()

1540

                .iter()

1541

                .collect::<Vec<_>>(),

1542

            expected

1543

);

1544

1545

1546

    #[test]

1547

    fn test_read_packed_deltas() {

1548

        let data = [

1549

            0x03, 0x0A, 0x97, 0x00, 0xC6, 0x87, 0x41, 0x10, 0x22, 0xFB, 0x34,

1550

];

1551

        let mut ctxt = ReadScope::new(&data).ctxt();

1552

        let expected = vec![10, -105, 0, -58, 0, 0, 0, 0, 0, 0, 0, 0, 4130, -1228];

1553

        assert_eq!(

1554

            packed_deltas::read(&mut ctxt, expected.len() as u32).unwrap(),

1555

            expected

1556

);

1557

1558