Grcov report - colr.rs

1

#![deny(missing_docs)]

2

3

//! `COLR` table parsing.

4

//!

5

//! <https://learn.microsoft.com/en-us/typography/opentype/spec/colr>

6

7

use std::cmp::Ordering;

8

use std::fmt;

9

use std::fmt::Write;

10

use std::str::FromStr;

11

12

use pathfinder_geometry::line_segment::LineSegment2F;

13

use pathfinder_geometry::rect::RectF;

14

use pathfinder_geometry::transform2d::Transform2F;

15

use pathfinder_geometry::vector::{vec2f, Vector2F};

16

use rustc_hash::FxHashSet;

17

18

use super::{F2Dot14, Fixed};

19

use crate::binary::{U24Be, U32Be};

20

use crate::outline::{OutlineBuilder, OutlineSink};

21

use crate::tables::cpal::{ColorRecord, Palette};

22

use crate::tables::variable_fonts::{DeltaSetIndexMap, ItemVariationStore};

23

use crate::SafeFrom;

24

use crate::{

25

    binary::{

26

        read::{ReadArray, ReadBinary, ReadBinaryDep, ReadCtxt, ReadFrom, ReadScope},

27

        U16Be,

28

},

29

    error::ParseError,

30

};

31

32

/// `COLR` — Color Table.

33

pub struct ColrTable<'a> {

34

    /// COLR table version, 0 or 1 currently

35

    pub version: u16,

36

    // May be empty in COLRv1

37

    base_glyph_records: ReadArray<'a, BaseGlyph>,

38

    // May be empty in COLRv1

39

    layer_records: ReadArray<'a, Layer>,

40

    base_glyph_list: Option<BaseGlyphList<'a>>,

41

    layer_list: Option<LayerList<'a>>,

42

    clip_list: Option<ClipList<'a>>,

43

    /// Index map for variable COLR fonts

44

    pub var_index_map: Option<DeltaSetIndexMap<'a>>,

45

    /// Variation data for variable COLR fonts

46

    pub item_variation_store: Option<ItemVariationStore<'a>>,

47

48

49

/// A `COLR` table.

50

impl<'a, 'data> ColrTable<'data> {

51

    /// Lookup a color glyph in this table.

52

    pub fn lookup(&'a self, glyph_id: u16) -> Result<Option<ColrGlyph<'a, 'data>>, ParseError> {

53

        if self.version == 0 {

54

            self.v0_lookup(glyph_id)

55

        } else if self.version == 1 {

56

            // For applications that support COLR version 1, the application should search for a base

57

            // glyph ID first in the BaseGlyphList. Then, if not found, search in the baseGlyphRecords

58

            // array, if present.

59

            if let Some(list) = self.base_glyph_list.as_ref() {

60

                let Some(paint) = list.record(glyph_id)? else {

61

                    return self.v0_lookup(glyph_id);

62

};

63

                return Ok(Some(ColrGlyph {

64

                    index: glyph_id,

65

                    table: self,

66

                    paint,

67

                }));

68

            } else {

69

                self.v0_lookup(glyph_id)

70

71

        } else {

72

            return Err(ParseError::BadVersion);

73

74

75

76

    fn v0_lookup(&'a self, glyph_id: u16) -> Result<Option<ColrGlyph<'a, 'data>>, ParseError> {

77

        // NOTE(unwrap): Safe as search found an entry with the binary search

78

        let Some(base_glyph) = self

79

            .base_glyph_records

80

            .binary_search_by(|base| base.glyph_id.cmp(&glyph_id))

81

            .map(|index| self.base_glyph_records.get_item(index).unwrap())

82

            .ok()

83

        else {

84

            return Ok(None);

85

};

86

87

        let table = PaintTable::Layers(PaintLayers {

88

            first_layer_index: base_glyph.first_layer_index,

89

            num_layers: base_glyph.num_layers,

90

});

91

        let paint = Paint {

92

            addr: usize::from(glyph_id),

93

            table,

94

};

95

96

        Ok(Some(ColrGlyph {

97

            index: glyph_id,

98

            table: self,

99

            paint,

100

}))

101

102

103

    /// Retrieve a layer from the layer list.

104

    pub fn layer(&self, index: u32) -> Result<Paint<'data>, ParseError> {

105

        let list = self.layer_list.as_ref().ok_or(ParseError::MissingValue)?;

106

        list.layer(index)

107

108

109

    /// Retrieve a layer from the layer records.

110

    pub fn layer_record(&self, index: u16) -> Result<Layer, ParseError> {

111

        self.layer_records

112

            .get_item(usize::from(index))

113

            .ok_or(ParseError::BadIndex)

114

115

116

    /// Retrieve a clip box from the clip list.

117

    pub fn clip_box(&self, index: u16) -> Result<Option<RectF>, ParseError> {

118

        let clip_box = self

119

            .clip_list

120

            .as_ref()

121

            .and_then(|list| list.clip_box(index).transpose())

122

            .transpose()?;

123

124

        if let Some(ClipBox {

125

            x_min,

126

            y_min,

127

            x_max,

128

            y_max,

129

            var_index_base: _,

130

        }) = clip_box

131

132

            Ok(Some(RectF::from_points(

133

                vec2f(x_min.into(), y_min.into()),

134

                vec2f(x_max.into(), y_max.into()),

135

)))

136

        } else {

137

            Ok(None)

138

139

140

141

142

/// A glyph from a `COLR` table.

143

pub struct ColrGlyph<'a, 'data> {

144

    /// The base glyph index of this COLR glyph.

145

    index: u16,

146

    table: &'a ColrTable<'data>,

147

    paint: Paint<'data>,

148

149

150

/// Trait used to traverse the paint tree of a `COLR` glyph.

151

///

152

/// A [Painter] implementation is passed to [ColrGlyph::visit] or

153

/// [Font::visit_colr_glyph][crate::Font::visit_colr_glyph] to traverse the paint tree

154

/// of a glyph.

155

pub trait Painter: OutlineSink {

156

    /// Type used to represent layers in the graphics context.

157

    type Layer;

158

    /// Error type returned from Painter methods.

159

    type Error;

160

161

    /// Fill the current path with the supplied color.

162

    fn fill(&mut self, color: Color) -> Result<(), Self::Error>;

163

164

    /// Fill the current path with a linear gradient.

165

    fn linear_gradient(

166

        &mut self,

167

        gradient: LinearGradient<'_>,

168

        palette: Palette<'_, '_>,

169

    ) -> Result<(), Self::Error>;

170

171

    /// Fill the current path with a radial gradient.

172

    fn radial_gradient(

173

        &mut self,

174

        gradient: RadialGradient<'_>,

175

        palette: Palette<'_, '_>,

176

    ) -> Result<(), Self::Error>;

177

178

    /// Fill the current path with a conic gradient.

179

///

180

    /// Corresponds to the PaintSweep `COLR` operator.

181

    fn conic_gradient(

182

        &mut self,

183

        gradient: ConicGradient<'_>,

184

        palette: Palette<'_, '_>,

185

    ) -> Result<(), Self::Error>;

186

187

    /// Establish a new clip region by intersecting the current clip region with the current path.

188

    fn clip(&mut self) -> Result<(), Self::Error>;

189

190

    /// Start a new path.

191

    fn new_path(&mut self) -> Result<(), Self::Error>;

192

193

    /// Start a new rendering layer.

194

    fn begin_layer(&mut self) -> Result<(), Self::Error>;

195

196

    /// End the current layer, returning it.

197

    fn end_layer(&mut self) -> Result<Self::Layer, Self::Error>;

198

199

    /// Compose two layers using the supplied mode.

200

    fn compose_layers(

201

        &mut self,

202

        backdrop: Self::Layer,

203

        source: Self::Layer,

204

        mode: CompositeMode,

205

    ) -> Result<(), Self::Error>;

206

207

    /// Save graphics context state.

208

    fn push_state(&mut self) -> Result<(), Self::Error>;

209

210

    /// Restore graphics context state previously saved with [push_state][Self::push_state].

211

    fn pop_state(&mut self) -> Result<(), Self::Error>;

212

213

    /// Apply the supplied affine transform to the graphics state.

214

    fn transform(&mut self, transform: Transform2F) -> Result<(), Self::Error>;

215

216

    /// Apply the supplied translation to the graphics state.

217

    fn translate(&mut self, dx: i16, dy: i16) -> Result<(), Self::Error>;

218

219

    /// Scale the graphics state by the supplied X-scale, and Y-scale values.

220

///

221

    /// If `center` is `Some` the scaling is performed around the supplied center point.

222

    fn scale(&mut self, sx: f32, sy: f32, center: Option<(i16, i16)>) -> Result<(), Self::Error>;

223

224

    /// Apply a rotating transformation to the graphics state.

225

///

226

    /// `angle` is in degrees. If `center` is `Some` the rotation is performed around the

227

    /// supplied center point.

228

    fn rotate(&mut self, angle: f32, center: Option<(i16, i16)>) -> Result<(), Self::Error>;

229

230

    /// Apply a skew transformation to the graphics state.

231

///

232

    /// `angle_x` and `angle_y` are in degrees. If `center` is `Some` the rotation is performed

233

    /// around the supplied center point.

234

    fn skew(

235

        &mut self,

236

        angle_x: f32,

237

        angle_y: f32,

238

        center: Option<(i16, i16)>,

239

    ) -> Result<(), Self::Error>;

240

241

242

struct PaintStack {

243

    stack: FxHashSet<usize>,

244

245

246

impl PaintStack {

247

    fn new() -> PaintStack {

248

        PaintStack {

249

            stack: FxHashSet::default(),

250

251

252

    fn push(&mut self, paint: &Paint<'_>) -> Result<(), ParseError> {

253

        if !self.stack.insert(paint.addr) {

254

            return Err(ParseError::LimitExceeded);

255

256

        Ok(())

257

258

259

    fn pop(&mut self, paint: &Paint<'_>) {

260

        self.stack.remove(&paint.addr);

261

262

263

264

impl<'a, 'data> ColrGlyph<'a, 'data> {

265

    /// Read the clip box of this glyph from the clip list.

266

///

267

    /// If the `COLR` table does not supply a clip list or there is no clip box for this

268

    /// glyph, then `Ok(None)` is returned.

269

    pub fn clip_box(&self) -> Result<Option<RectF>, ParseError> {

270

        self.table.clip_box(self.index)

271

272

273

    /// Traverse the paint tree of this glyph using the supplied `Painter`.

274

///

275

    /// Colors are supplied by `palette`, which can be obtained via

276

    /// [CpalTable::palette][super::cpal::CpalTable::palette].

277

    pub fn visit<P, G>(

278

        &self,

279

        painter: &mut P,

280

        glyphs: &mut G,

281

        palette: Palette<'a, 'data>,

282

    ) -> Result<(), P::Error>

283

    where

284

        P: Painter,

285

        P::Error: From<ParseError> + From<G::Error>,

286

        G: OutlineBuilder,

287

288

        self.paint

289

            .visit(painter, glyphs, palette, self.table, &mut PaintStack::new())

290

291

292

293

impl<'data, 'a> Paint<'data> {

294

    fn visit<P, G>(

295

        &self,

296

        painter: &mut P,

297

        glyphs: &mut G,

298

        palette: Palette<'a, 'data>,

299

        colr: &'a ColrTable<'data>,

300

        stack: &mut PaintStack,

301

    ) -> Result<(), P::Error>

302

    where

303

        P: Painter + OutlineSink,

304

        P::Error: From<ParseError> + From<G::Error>,

305

        G: OutlineBuilder,

306

307

        stack.push(self)?;

308

        match &self.table {

309

            PaintTable::Layers(PaintLayers {

310

                num_layers,

311

                first_layer_index,

312

            }) => {

313

                let range = *first_layer_index

314

                    ..first_layer_index

315

                        .checked_add(*num_layers)

316

                        .ok_or(ParseError::LimitExceeded)?;

317

                for index in range {

318

                    let layer = colr.layer_record(index)?;

319

                    painter.push_state()?;

320

321

                    // Apply the outline of the referenced glyph to the clip region

322

                    glyphs.visit(layer.glyph_id, None, painter)?;

323

324

                    // Take the intersection of clip regions

325

                    painter.clip()?;

326

327

                    // Draw the layer

328

                    let color = palette

329

                        .color(layer.palette_index)

330

                        .map(Color::from)

331

                        .unwrap_or_else(|| Color(0.0, 0.0, 0.0, 0.0));

332

                    painter.fill(color)?;

333

334

                    // Restore the previous clip region

335

                    painter.pop_state()?;

336

337

338

            PaintTable::ColrLayers(PaintColrLayers {

339

                num_layers,

340

                first_layer_index,

341

            }) => {

342

                let range = *first_layer_index

343

                    ..first_layer_index

344

                        .checked_add(u32::from(*num_layers))

345

                        .ok_or(ParseError::LimitExceeded)?;

346

                for index in range {

347

                    let layer = colr.layer(index)?;

348

                    layer.visit(painter, glyphs, palette, colr, stack)?;

349

350

351

            PaintTable::Solid(paint_solid) => {

352

                // Fall back on transparent black if color reference is invalid

353

                let color = paint_solid

354

                    .color(palette)

355

                    .unwrap_or(Color(0.0, 0.0, 0.0, 0.0));

356

                painter.fill(color)?;

357

358

            PaintTable::LinearGradient(paint_linear_gradient) => {

359

                let color_line = paint_linear_gradient.color_line()?;

360

                let gradient = LinearGradient {

361

                    color_line,

362

                    start_point: (paint_linear_gradient.x0, paint_linear_gradient.y0),

363

                    end_point: (paint_linear_gradient.x1, paint_linear_gradient.y1),

364

                    rotation_point: (paint_linear_gradient.x2, paint_linear_gradient.y2),

365

};

366

                painter.linear_gradient(gradient, palette)?;

367

368

            PaintTable::RadialGradient(paint_radial_gradient) => {

369

                let color_line = paint_radial_gradient.color_line()?;

370

                let gradient = RadialGradient {

371

                    color_line,

372

                    start_circle: Circle {

373

                        x: paint_radial_gradient.x0,

374

                        y: paint_radial_gradient.y0,

375

                        radius: paint_radial_gradient.radius0,

376

},

377

                    end_circle: Circle {

378

                        x: paint_radial_gradient.x1,

379

                        y: paint_radial_gradient.y1,

380

                        radius: paint_radial_gradient.radius1,

381

},

382

};

383

                painter.radial_gradient(gradient, palette)?;

384

385

            PaintTable::SweepGradient(paint_sweep_gradient) => {

386

                let color_line = paint_sweep_gradient.color_line()?;

387

                let gradient = ConicGradient {

388

                    color_line,

389

                    center: (paint_sweep_gradient.center_x, paint_sweep_gradient.center_y),

390

                    start_angle: paint_sweep_gradient.start_angle.into(),

391

                    end_angle: paint_sweep_gradient.end_angle.into(),

392

};

393

                painter.conic_gradient(gradient, palette)?;

394

395

            PaintTable::Glyph(paint_glyph) => {

396

                let paint = paint_glyph.subpaint()?;

397

                painter.push_state()?;

398

399

                // Apply the outline of the referenced glyph to the clip region

400

                painter.new_path()?;

401

                glyphs.visit(paint_glyph.glyph_id, None, painter)?;

402

403

                // Take the intersection of clip regions

404

                painter.clip()?;

405

406

                // Visit the paint sub-table

407

                paint.visit(painter, glyphs, palette, colr, stack)?;

408

409

                // Restore the previous clip region

410

                painter.pop_state()?;

411

412

            PaintTable::ColrGlyph(paint_colr_glyph) => {

413

                // TODO: This is essentially a sub-routine

414

                // Ideally it would be possible for painters to cache the rendering of a glyph by id

415

                // so it can be reused

416

                if let Some(glyph) = colr.lookup(paint_colr_glyph.glyph_id)? {

417

                    glyph.paint.visit(painter, glyphs, palette, colr, stack)?;

418

419

420

            PaintTable::Transform(paint_transform) => {

421

                let paint = paint_transform.subpaint()?;

422

                let t = &paint_transform.transform;

423

                let transform = Transform2F::row_major(

424

                    t.xx.into(),

425

                    t.yx.into(),

426

                    t.xy.into(),

427

                    t.yy.into(),

428

                    t.dx.into(),

429

                    t.dy.into(),

430

);

431

                self.visit_transform(&paint, painter, glyphs, palette, colr, stack, |painter| {

432

                    painter.transform(transform)

433

                })?;

434

435

            PaintTable::Translate(paint_translate) => {

436

                let paint = paint_translate.subpaint()?;

437

                self.visit_transform(&paint, painter, glyphs, palette, colr, stack, |painter| {

438

                    painter.translate(paint_translate.dx, paint_translate.dy)

439

                })?;

440

441

            PaintTable::Scale(paint_scale) => {

442

                let PaintScale {

443

                    scale: (sx, sy),

444

                    center,

445

..

446

                } = paint_scale;

447

                let paint = paint_scale.subpaint()?;

448

                self.visit_transform(&paint, painter, glyphs, palette, colr, stack, |painter| {

449

                    painter.scale(f32::from(*sx), f32::from(*sy), *center)

450

                })?;

451

452

            PaintTable::Rotate(paint_rotate) => {

453

                let paint = paint_rotate.subpaint()?;

454

                self.visit_transform(&paint, painter, glyphs, palette, colr, stack, |painter| {

455

                    painter.rotate(raw_to_degrees(paint_rotate.angle), paint_rotate.center)

456

                })?;

457

458

            PaintTable::Skew(paint_skew) => {

459

                let PaintSkew {

460

                    skew_angle: (sx, sy),

461

                    center,

462

..

463

                } = paint_skew;

464

                let paint = paint_skew.subpaint()?;

465

                self.visit_transform(&paint, painter, glyphs, palette, colr, stack, |painter| {

466

                    painter.skew(raw_to_degrees(*sx), raw_to_degrees(*sy), *center)

467

                })?;

468

469

            PaintTable::Composite(paint_composite) => {

470

                let paint_backdrop = paint_composite.backdrop()?;

471

                let paint_source = paint_composite.source()?;

472

473

                painter.begin_layer()?;

474

                paint_backdrop.visit(painter, glyphs, palette, colr, stack)?;

475

                let backdrop = painter.end_layer()?;

476

                painter.begin_layer()?;

477

                paint_source.visit(painter, glyphs, palette, colr, stack)?;

478

                let source = painter.end_layer()?;

479

                painter.compose_layers(backdrop, source, paint_composite.composite_mode)?;

480

481

482

        stack.pop(self);

483

484

        Ok(())

485

486

487

    fn visit_transform<F, P, G>(

488

        &self,

489

        paint: &Paint<'data>,

490

        painter: &mut P,

491

        glyphs: &mut G,

492

        palette: Palette<'a, 'data>,

493

        colr: &'a ColrTable<'data>,

494

        stack: &mut PaintStack,

495

        f: F,

496

    ) -> Result<(), P::Error>

497

    where

498

        P: Painter + OutlineSink,

499

        P::Error: From<ParseError> + From<G::Error>,

500

        F: FnOnce(&mut P) -> Result<(), P::Error>,

501

        G: OutlineBuilder,

502

503

        painter.push_state()?;

504

        f(painter)?;

505

        paint.visit(painter, glyphs, palette, colr, stack)?;

506

        painter.pop_state()?;

507

        Ok(())

508

509

510

511

/// A [Painter] implementation that prints paint operators.

512

///

513

/// ### Example

514

///

515

/// ```

516

/// use allsorts::binary::read::ReadScope;

517

/// use allsorts::tables::colr::DebugVisitor;

518

/// use allsorts::tables::OpenTypeFont;

519

/// use allsorts::Font;

520

/// #

521

/// # pub fn read_fixture<P: AsRef<std::path::Path>>(path: P) -> Vec<u8> {

522

/// #     std::fs::read(&std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join(path))

523

/// #         .expect("error reading file contents")

524

/// # }

525

///

526

/// let buffer = read_fixture(

527

///     "tests/fonts/colr/SixtyfourConvergence-Regular-VariableFont_BLED,SCAN,XELA,YELA.ttf",

528

/// );

529

/// let otf = ReadScope::new(&buffer).read::<OpenTypeFont<'_>>().unwrap();

530

/// let table_provider = otf.table_provider(0).expect("error reading font file");

531

/// let mut font = Font::new(table_provider).unwrap();

532

/// let mut painter = DebugVisitor;

533

/// let glyph_id = 47; // 'S'

534

/// match font.visit_colr_glyph(glyph_id, 0, &mut painter) {

535

///     Ok(()) => {}

536

///     Err(err) => panic!("error visiting COLR glyph: {}", err),

537

/// }

538

/// ```

539

pub struct DebugVisitor;

540

541

impl Painter for DebugVisitor {

542

    type Layer = ();

543

    type Error = Box<dyn std::error::Error>;

544

545

    fn fill(&mut self, color: Color) -> Result<(), Self::Error> {

546

        println!("fill {:?}", color);

547

        Ok(())

548

549

550

    fn linear_gradient(

551

        &mut self,

552

        gradient: LinearGradient<'_>,

553

        _palette: Palette<'_, '_>,

554

    ) -> Result<(), Self::Error> {

555

        println!("linear_gradient {:?}", gradient);

556

        Ok(())

557

558

559

    fn radial_gradient(

560

        &mut self,

561

        gradient: RadialGradient<'_>,

562

        _palette: Palette<'_, '_>,

563

    ) -> Result<(), Self::Error> {

564

        println!("radial_gradient {:?}", gradient);

565

        Ok(())

566

567

568

    fn conic_gradient(

569

        &mut self,

570

        gradient: ConicGradient<'_>,

571

        _palette: Palette<'_, '_>,

572

    ) -> Result<(), Self::Error> {

573

        println!("conic_gradient {:?}", gradient);

574

        Ok(())

575

576

577

    fn clip(&mut self) -> Result<(), Self::Error> {

578

        println!("clip");

579

        Ok(())

580

581

582

    fn new_path(&mut self) -> Result<(), Self::Error> {

583

        println!("new_path");

584

        Ok(())

585

586

587

    fn begin_layer(&mut self) -> Result<(), Self::Error> {

588

        println!("begin_layer");

589

        Ok(())

590

591

592

    fn end_layer(&mut self) -> Result<Self::Layer, Self::Error> {

593

        println!("end_layer");

594

        Ok(())

595

596

597

    fn compose_layers(

598

        &mut self,

599

        _backdrop: Self::Layer,

600

        _source: Self::Layer,

601

        mode: CompositeMode,

602

    ) -> Result<(), Self::Error> {

603

        println!("compose_layers {:?}", mode);

604

        Ok(())

605

606

607

    fn push_state(&mut self) -> Result<(), Self::Error> {

608

        println!("push_state");

609

        Ok(())

610

611

612

    fn pop_state(&mut self) -> Result<(), Self::Error> {

613

        println!("pop_state");

614

        Ok(())

615

616

617

    fn transform(&mut self, t: Transform2F) -> Result<(), Self::Error> {

618

        println!("transform {:?}", t);

619

        Ok(())

620

621

622

    fn translate(&mut self, dx: i16, dy: i16) -> Result<(), Self::Error> {

623

        println!("translate {}, {}", dx, dy);

624

        Ok(())

625

626

627

    fn scale(&mut self, sx: f32, sy: f32, center: Option<(i16, i16)>) -> Result<(), Self::Error> {

628

        println!("scale, {}, {} @ {:?}", sx, sy, center);

629

        Ok(())

630

631

632

    fn rotate(&mut self, angle: f32, center: Option<(i16, i16)>) -> Result<(), Self::Error> {

633

        println!("rotate, angle {} @ {:?}", angle, center);

634

        Ok(())

635

636

637

    fn skew(

638

        &mut self,

639

        angle_x: f32,

640

        angle_y: f32,

641

        center: Option<(i16, i16)>,

642

    ) -> Result<(), Self::Error> {

643

        println!(

644

            "skew, angle_x {}, angle_y {} @ {:?}",

645

            angle_x, angle_y, center

646

);

647

        Ok(())

648

649

650

651

impl OutlineSink for DebugVisitor {

652

    fn move_to(&mut self, to: Vector2F) {

653

        println!("move_to {:?}", to);

654

655

656

    fn line_to(&mut self, to: Vector2F) {

657

        println!("line_to {:?}", to);

658

659

660

    fn quadratic_curve_to(&mut self, ctrl: Vector2F, to: Vector2F) {

661

        println!("quadratic_curve_to {:?}, {:?}", ctrl, to);

662

663

664

    fn cubic_curve_to(&mut self, ctrl: LineSegment2F, to: Vector2F) {

665

        println!("cubic_curve_to {:?}, {:?}", ctrl, to);

666

667

668

    fn close(&mut self) {

669

        println!("close");

670

671

672

673

impl ReadBinary for ColrTable<'_> {

674

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

675

676

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

677

        let colr_scope = ctxt.scope();

678

        let version = ctxt.read_u16be()?;

679

        // Number of BaseGlyph records; may be 0 in a version 1 table.

680

        let num_base_glyph_records = ctxt.read_u16be()?;

681

        // Offset to baseGlyphRecords array, from beginning of COLR table (may be NULL).

682

        let base_glyph_records_offset = ctxt.read_u32be()?;

683

        // Offset to layerRecords array, from beginning of COLR table (may be NULL).

684

        let layer_records_offset = ctxt.read_u32be()?;

685

        // Number of Layer records; may be 0 in a version 1 table.

686

        let num_layer_records = ctxt.read_u16be()?;

687

688

        let base_glyph_records = colr_scope

689

            .read_optional_array(base_glyph_records_offset, num_base_glyph_records)?

690

            .unwrap_or_else(ReadArray::empty);

691

        let layer_records = colr_scope

692

            .read_optional_array(layer_records_offset, num_layer_records)?

693

            .unwrap_or_else(ReadArray::empty);

694

695

        if version == 0 {

696

            Ok(ColrTable {

697

                version,

698

                base_glyph_records,

699

                layer_records,

700

                base_glyph_list: None,

701

                layer_list: None,

702

                clip_list: None,

703

                var_index_map: None,

704

                item_variation_store: None,

705

})

706

        } else if version == 1 {

707

            // Offset to BaseGlyphList table, from beginning of COLR table.

708

            let base_glyph_list_offset = ctxt.read_u32be()?;

709

            // Offset to LayerList table, from beginning of COLR table (may be NULL).

710

            let layer_list_offset = ctxt.read_u32be()?;

711

            // Offset to ClipList table, from beginning of COLR table (may be NULL).

712

            let clip_list_offset = ctxt.read_u32be()?;

713

            // Offset to DeltaSetIndexMap table, from beginning of COLR table (may be NULL).

714

            let var_index_map_offset = ctxt.read_u32be()?;

715

            // Offset to ItemVariationStore, from beginning of COLR table (may be NULL).

716

            let item_variation_store_offset = ctxt.read_u32be()?;

717

718

            let base_glyph_list = (base_glyph_list_offset != 0)

719

                .then(|| {

720

                    colr_scope

721

                        .offset(usize::safe_from(base_glyph_list_offset))

722

                        .ctxt()

723

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

724

})

725

                .transpose()?;

726

727

            let layer_list = (layer_list_offset != 0)

728

                .then(|| {

729

                    colr_scope

730

                        .offset(usize::safe_from(layer_list_offset))

731

                        .ctxt()

732

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

733

})

734

                .transpose()?;

735

736

            let clip_list = (clip_list_offset != 0)

737

                .then(|| {

738

                    colr_scope

739

                        .offset(usize::safe_from(clip_list_offset))

740

                        .ctxt()

741

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

742

})

743

                .transpose()?;

744

745

            let var_index_map = (var_index_map_offset != 0)

746

                .then(|| {

747

                    colr_scope

748

                        .offset(usize::safe_from(var_index_map_offset))

749

                        .ctxt()

750

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

751

})

752

                .transpose()?;

753

754

            let item_variation_store = (item_variation_store_offset != 0)

755

                .then(|| {

756

                    colr_scope

757

                        .offset(usize::safe_from(item_variation_store_offset))

758

                        .ctxt()

759

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

760

})

761

                .transpose()?;

762

763

            Ok(ColrTable {

764

                version,

765

                base_glyph_records,

766

                layer_records,

767

                base_glyph_list,

768

                layer_list,

769

                clip_list,

770

                var_index_map,

771

                item_variation_store,

772

})

773

        } else {

774

            Err(ParseError::BadVersion)

775

776

777

778

779

/// BaseGlyph record.

780

#[derive(Debug, Copy, Clone)]

781

struct BaseGlyph {

782

    /// Glyph ID of the base glyph.

783

    glyph_id: u16,

784

    /// Index (base 0) into the layerRecords array.

785

    first_layer_index: u16,

786

    /// Number of color layers associated with this glyph.

787

    num_layers: u16,

788

789

790

/// Layer record.

791

#[derive(Debug, Clone, Copy)]

792

pub struct Layer {

793

    /// Glyph ID of the glyph used for a given layer.

794

///

795

    /// The glyphID in a Layer record must be less than the numGlyphs value in the `maxp` table.

796

    pub glyph_id: u16,

797

    /// Index (base 0) for a palette entry in the `CPAL` table.

798

///

799

    /// The paletteIndex value must be less than the numPaletteEntries value in the `CPAL` table. A

800

    /// paletteIndex value of 0xFFFF is a special case, indicating that the text foreground color

801

    /// (as determined by the application) is to be used.

802

    pub palette_index: u16,

803

804

805

impl ReadFrom for BaseGlyph {

806

    type ReadType = (U16Be, U16Be, U16Be);

807

808

    fn read_from((glyph_id, first_layer_index, num_layers): (u16, u16, u16)) -> Self {

809

        BaseGlyph {

810

            glyph_id,

811

            first_layer_index,

812

            num_layers,

813

814

815

816

817

impl ReadFrom for Layer {

818

    type ReadType = (U16Be, U16Be);

819

820

    fn read_from((glyph_id, palette_index): (u16, u16)) -> Self {

821

        Layer {

822

            glyph_id,

823

            palette_index,

824

825

826

827

828

#[derive(Debug)]

829

struct BaseGlyphList<'a> {

830

    scope: ReadScope<'a>,

831

    records: ReadArray<'a, BaseGlyphPaintRecord>,

832

833

834

impl<'a> BaseGlyphList<'a> {

835

    pub fn record(&self, glyph_id: u16) -> Result<Option<Paint<'a>>, ParseError> {

836

        let Some(record_index) = self

837

            .records

838

            .binary_search_by(|record| record.glyph_id.cmp(&glyph_id))

839

            .ok()

840

        else {

841

            return Ok(None);

842

};

843

        // NOTE(unwrap): Safe as binary search found item at record_index

844

        let record = self.records.get_item(record_index).unwrap();

845

        self.scope

846

            .offset(usize::safe_from(record.paint_offset))

847

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

848

            .map(Some)

849

850

851

852

impl ReadBinary for BaseGlyphList<'_> {

853

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

854

855

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

856

        let scope = ctxt.scope();

857

        let num_base_glyph_paint_records = ctxt.read_u32be()?;

858

        let base_glyph_paint_records =

859

            ctxt.read_array(usize::safe_from(num_base_glyph_paint_records))?;

860

861

        Ok(BaseGlyphList {

862

            scope,

863

            records: base_glyph_paint_records,

864

})

865

866

867

868

#[derive(Debug, Copy, Clone)]

869

struct BaseGlyphPaintRecord {

870

    /// Glyph ID of the base glyph.

871

    glyph_id: u16,

872

    /// Offset to a Paint table, from beginning of BaseGlyphList table.

873

    paint_offset: u32,

874

875

876

impl ReadFrom for BaseGlyphPaintRecord {

877

    type ReadType = (U16Be, U32Be);

878

879

    fn read_from((glyph_id, paint_offset): (u16, u32)) -> Self {

880

        BaseGlyphPaintRecord {

881

            glyph_id,

882

            paint_offset,

883

884

885

886

887

#[derive(Debug)]

888

struct LayerList<'a> {

889

    scope: ReadScope<'a>,

890

    paint_offsets: ReadArray<'a, U32Be>,

891

892

893

impl<'a> LayerList<'a> {

894

    pub fn layer(&self, index: u32) -> Result<Paint<'a>, ParseError> {

895

        let offset = self

896

            .paint_offsets

897

            .get_item(usize::safe_from(index))

898

            .ok_or(ParseError::BadIndex)?;

899

        self.scope

900

            .offset(usize::safe_from(offset))

901

            .read::<Paint<'a>>()

902

903

904

905

impl ReadBinary for LayerList<'_> {

906

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

907

908

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

909

        let scope = ctxt.scope();

910

        let num_layers = ctxt.read_u32be()?;

911

        let paint_offsets = ctxt.read_array(usize::safe_from(num_layers))?;

912

913

        Ok(LayerList {

914

            scope,

915

            paint_offsets,

916

})

917

918

919

920

#[derive(Debug)]

921

struct ClipList<'a> {

922

    scope: ReadScope<'a>,

923

    /// Clip records. Sorted by startGlyphID.

924

    clips: ReadArray<'a, Clip>,

925

926

927

impl ClipList<'_> {

928

    fn clip_box(&self, glyph_id: u16) -> Result<Option<ClipBox>, ParseError> {

929

        let clip_index = self

930

            .clips

931

            .binary_search_by(|clip| {

932

                if clip.contains(glyph_id) {

933

                    Ordering::Equal

934

                } else if glyph_id < clip.start_glyph_id {

935

                    Ordering::Greater

936

                } else {

937

                    Ordering::Less

938

939

})

940

            .ok();

941

942

        let clip = match clip_index {

943

            // NOTE(unwrap): Safe as binary search found item at index

944

            Some(index) => self.clips.get_item(index).unwrap(),

945

            None => return Ok(None),

946

};

947

948

        self.scope

949

            .offset(usize::safe_from(clip.clip_box_offset))

950

            .read::<ClipBox>()

951

            .map(Some)

952

953

954

955

impl ReadBinary for ClipList<'_> {

956

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

957

958

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

959

        let scope = ctxt.scope();

960

        let format = ctxt.read_u8()?;

961

        ctxt.check_version(format == 1)?;

962

        let num_clips = ctxt.read_u32be()?;

963

        let clips = ctxt.read_array(usize::safe_from(num_clips))?;

964

965

        Ok(ClipList { scope, clips })

966

967

968

969

/// Clip record.

970

#[derive(Debug, Clone, Copy)]

971

struct Clip {

972

    /// First glyph ID in the range.

973

    start_glyph_id: u16,

974

    /// Last glyph ID in the range.

975

    end_glyph_id: u16,

976

    /// Offset to a ClipBox table, from beginning of ClipList table.

977

    clip_box_offset: u32, // This is read from a 24-bit value

978

979

980

impl Clip {

981

    fn contains(&self, glyph_id: u16) -> bool {

982

        (self.start_glyph_id..=self.end_glyph_id).contains(&glyph_id)

983

984

985

986

impl ReadFrom for Clip {

987

    type ReadType = (U16Be, U16Be, U24Be);

988

989

    fn read_from((start_glyph_id, end_glyph_id, clip_box_offset): (u16, u16, u32)) -> Self {

990

        Clip {

991

            start_glyph_id,

992

            end_glyph_id,

993

            clip_box_offset,

994

995

996

997

998

/// Clip box for COLR glyph.

999

#[derive(Debug, Clone, Copy)]

1000

pub struct ClipBox {

1001

    /// Minimum x of clip box.

1002

///

1003

    /// For variation, use varIndexBase + 0.

1004

    pub x_min: i16,

1005

    /// Minimum y of clip box.

1006

///

1007

    /// For variation, use varIndexBase + 1.

1008

    pub y_min: i16,

1009

    /// Maximum x of clip box.

1010

///

1011

    /// For variation, use varIndexBase + 2.

1012

    pub x_max: i16,

1013

    /// Maximum y of clip box.

1014

///

1015

    /// For variation, use varIndexBase + 3.

1016

    pub y_max: i16,

1017

    /// Base index into DeltaSetIndexMap.

1018

    pub var_index_base: Option<u32>,

1019

1020

1021

impl ClipBox {

1022

    /// Obtain the width of this clip box.

1023

    pub fn width(&self) -> i16 {

1024

        self.x_max - self.x_min

1025

1026

1027

    /// Obtain the height of this clip box.

1028

    pub fn height(&self) -> i16 {

1029

        self.y_max - self.y_min

1030

1031

1032

1033

impl ReadBinary for ClipBox {

1034

    type HostType<'a> = ClipBox;

1035

1036

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

1037

        let format = ctxt.read_u8()?;

1038

        ctxt.check_version(format == 1 || format == 2)?;

1039

        let x_min = ctxt.read_i16be()?;

1040

        let y_min = ctxt.read_i16be()?;

1041

        let x_max = ctxt.read_i16be()?;

1042

        let y_max = ctxt.read_i16be()?;

1043

        let var_index_base = (format == 2).then(|| ctxt.read_u32be()).transpose()?;

1044

1045

        Ok(ClipBox {

1046

            x_min,

1047

            y_min,

1048

            x_max,

1049

            y_max,

1050

            var_index_base,

1051

})

1052

1053

1054

1055

/// A possibly variable color stop in a gradient.

1056

pub struct ColorStop {

1057

    /// Position on a color line.

1058

///

1059

    /// For variation, use varIndexBase + 0.

1060

    pub stop_offset: F2Dot14,

1061

    /// Index for a `CPAL` palette entry.

1062

    pub palette_index: u16,

1063

    /// Alpha value.

1064

///

1065

    /// For variation, use varIndexBase + 1.

1066

    pub alpha: F2Dot14,

1067

    /// Base index into DeltaSetIndexMap if the color line is variable.

1068

    pub var_index_base: Option<u32>,

1069

1070

1071

impl ColorStop {

1072

    /// The offset of this color stop along the color line.

1073

    pub fn offset(&self) -> f32 {

1074

        f32::from(self.stop_offset)

1075

1076

1077

    /// The color of this color-stop, according to the supplied palette.

1078

///

1079

    /// Obtain a [Palette] using the [palette method on CpalTable][super::cpal::CpalTable::palette].

1080

    pub fn color(&self, palette: Palette<'_, '_>) -> Option<Color> {

1081

        // The alpha value in the COLR structure is multiplied into the alpha value given in the

1082

        // CPAL color entry. If the palette entry index is 0xFFFF, the alpha value in the COLR

1083

        // structure is multiplied into the alpha value of the text foreground color.

1084

        let color = palette.color(self.palette_index)?;

1085

        let color = Color::new_with_alpha(color, self.alpha);

1086

        Some(color)

1087

1088

1089

1090

impl From<StaticColorStop> for ColorStop {

1091

    fn from(

1092

        StaticColorStop {

1093

            stop_offset,

1094

            palette_index,

1095

            alpha,

1096

        }: StaticColorStop,

1097

    ) -> Self {

1098

        ColorStop {

1099

            stop_offset,

1100

            palette_index,

1101

            alpha,

1102

            var_index_base: None,

1103

1104

1105

1106

1107

impl From<VarColorStop> for ColorStop {

1108

    fn from(

1109

        VarColorStop {

1110

            stop_offset,

1111

            palette_index,

1112

            alpha,

1113

            var_index_base,

1114

        }: VarColorStop,

1115

    ) -> Self {

1116

        ColorStop {

1117

            stop_offset,

1118

            palette_index,

1119

            alpha,

1120

            var_index_base: Some(var_index_base),

1121

1122

1123

1124

1125

/// A non-variable gradient color stop.

1126

#[derive(Debug, Clone, Copy)]

1127

pub struct StaticColorStop {

1128

    /// Position on a color line.

1129

    pub stop_offset: F2Dot14,

1130

    /// Index for a `CPAL` palette entry.

1131

    pub palette_index: u16,

1132

    /// Alpha value.

1133

    pub alpha: F2Dot14,

1134

1135

1136

impl ReadFrom for StaticColorStop {

1137

    type ReadType = (F2Dot14, U16Be, F2Dot14);

1138

1139

    fn read_from((stop_offset, palette_index, alpha): (F2Dot14, u16, F2Dot14)) -> Self {

1140

        StaticColorStop {

1141

            stop_offset,

1142

            palette_index,

1143

            alpha,

1144

1145

1146

1147

1148

/// A variable gradient color stop.

1149

#[derive(Debug, Clone, Copy)]

1150

pub struct VarColorStop {

1151

    /// Position on a color line.

1152

///

1153

    /// For variation, use varIndexBase + 0.

1154

    pub stop_offset: F2Dot14,

1155

    /// Index for a `CPAL` palette entry.

1156

    pub palette_index: u16,

1157

    /// Alpha value.

1158

///

1159

    /// For variation, use varIndexBase + 1.

1160

    pub alpha: F2Dot14,

1161

    /// Base index into DeltaSetIndexMap.

1162

    pub var_index_base: u32,

1163

1164

1165

impl ReadFrom for VarColorStop {

1166

    type ReadType = (F2Dot14, U16Be, F2Dot14, U32Be);

1167

1168

    fn read_from(

1169

        (stop_offset, palette_index, alpha, var_index_base): (F2Dot14, u16, F2Dot14, u32),

1170

    ) -> Self {

1171

        VarColorStop {

1172

            stop_offset,

1173

            palette_index,

1174

            alpha,

1175

            var_index_base,

1176

1177

1178

1179

1180

/// A gradient color line.

1181

#[derive(Debug)]

1182

pub enum ColorLine<'a> {

1183

    /// A non-variable color line.

1184

    Static(StaticColorLine<'a>),

1185

    /// A variable color line.

1186

    Variable(VarColorLine<'a>),

1187

1188

1189

impl<'a> ColorLine<'a> {

1190

    /// The extend mode of this color line.

1191

    pub fn extend(&self) -> Extend {

1192

        match self {

1193

            ColorLine::Static(line) => line.extend,

1194

            ColorLine::Variable(line) => line.extend,

1195

1196

1197

1198

    /// Iterator over the stops of this color line.

1199

    pub fn color_stops<'b>(&'b self) -> ColorStopIter<'b, 'a> {

1200

        ColorStopIter {

1201

            line: self,

1202

            index: 0,

1203

1204

1205

1206

1207

impl<'a> From<StaticColorLine<'a>> for ColorLine<'a> {

1208

    fn from(line: StaticColorLine<'a>) -> Self {

1209

        ColorLine::Static(line)

1210

1211

1212

1213

impl<'a> From<VarColorLine<'a>> for ColorLine<'a> {

1214

    fn from(line: VarColorLine<'a>) -> Self {

1215

        ColorLine::Variable(line)

1216

1217

1218

1219

/// Color line iterator.

1220

///

1221

/// Returned from [ColorLine::color_stops]

1222

#[derive(Copy, Clone)]

1223

pub struct ColorStopIter<'a, 'data> {

1224

    line: &'a ColorLine<'data>,

1225

    index: usize,

1226

1227

1228

impl ColorStopIter<'_, '_> {

1229

    /// Retrieve a specific color stop on the color line.

1230

///

1231

    /// None if `index` is >= color stops length.

1232

    pub fn get_item(&self, index: usize) -> Option<ColorStop> {

1233

        match self.line {

1234

            ColorLine::Static(line) => line.color_stops.get_item(index).map(ColorStop::from),

1235

            ColorLine::Variable(line) => line.color_stops.get_item(index).map(ColorStop::from),

1236

1237

1238

1239

1240

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

1241

    type Item = ColorStop;

1242

1243

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

1244

        let stop = self.get_item(self.index);

1245

        self.index = self.index.saturating_add(1);

1246

        stop

1247

1248

1249

    fn size_hint(&self) -> (usize, Option<usize>) {

1250

        let remaining = match self.line {

1251

            ColorLine::Static(line) => line.color_stops().len() - self.index,

1252

            ColorLine::Variable(line) => line.color_stops().len() - self.index,

1253

};

1254

        (remaining, Some(remaining))

1255

1256

1257

1258

impl ExactSizeIterator for ColorStopIter<'_, '_> {}

1259

1260

/// A non-variable gradient color line.

1261

#[derive(Debug, Clone)]

1262

pub struct StaticColorLine<'a> {

1263

    /// An Extend enum value.

1264

    extend: Extend,

1265

    /// ColorStop records.

1266

    color_stops: ReadArray<'a, StaticColorStop>,

1267

1268

1269

impl<'a> StaticColorLine<'a> {

1270

    /// The extend mode of this color line.

1271

    pub fn extend(&self) -> Extend {

1272

        self.extend

1273

1274

1275

    /// The color stops of this color line.

1276

    pub fn color_stops(&self) -> &ReadArray<'a, StaticColorStop> {

1277

        &self.color_stops

1278

1279

1280

1281

impl ReadBinary for StaticColorLine<'_> {

1282

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

1283

1284

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

1285

        let extend = ctxt.read_u8()?;

1286

        // If a ColorLine in a font has an unrecognized extend value,

1287

        // applications should use EXTEND_PAD by default.

1288

        let extend = Extend::try_from(extend).unwrap_or(Extend::Pad);

1289

        let num_stops = ctxt.read_u16be()?;

1290

        let color_stops = ctxt.read_array(usize::from(num_stops))?;

1291

        Ok(StaticColorLine {

1292

            extend,

1293

            color_stops,

1294

})

1295

1296

1297

1298

/// A variable gradient color line.

1299

#[derive(Debug, Clone)]

1300

pub struct VarColorLine<'a> {

1301

    /// An Extend enum value.

1302

    extend: Extend,

1303

    /// Allows for variations.

1304

    color_stops: ReadArray<'a, VarColorStop>,

1305

1306

1307

impl<'a> VarColorLine<'a> {

1308

    /// The extend mode of this color line.

1309

    pub fn extend(&self) -> Extend {

1310

        self.extend

1311

1312

1313

    /// The color stops of this color line.

1314

    pub fn color_stops(&self) -> &ReadArray<'a, VarColorStop> {

1315

        &self.color_stops

1316

1317

1318

1319

impl ReadBinary for VarColorLine<'_> {

1320

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

1321

1322

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

1323

        let extend = ctxt.read_u8()?;

1324

        // If a ColorLine in a font has an unrecognized extend value,

1325

        // applications should use EXTEND_PAD by default.

1326

        let extend = Extend::try_from(extend).unwrap_or(Extend::Pad);

1327

        let num_stops = ctxt.read_u16be()?;

1328

        let color_stops = ctxt.read_array(usize::from(num_stops))?;

1329

        Ok(VarColorLine {

1330

            extend,

1331

            color_stops,

1332

})

1333

1334

1335

1336

/// Gradient extend mode.

1337

///

1338

/// This defines how a gradient is extended if its color stops do not

1339

/// cover the full 0 to 1.0 range.

1340

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

1341

pub enum Extend {

1342

    /// Use nearest color stop.

1343

    Pad,

1344

    /// Repeat from farthest color stop.

1345

    Repeat,

1346

    /// Mirror color line from nearest end.

1347

    Reflect,

1348

1349

1350

impl TryFrom<u8> for Extend {

1351

    type Error = ParseError;

1352

1353

    fn try_from(value: u8) -> Result<Self, Self::Error> {

1354

        match value {

1355

            0 => Ok(Extend::Pad),

1356

            1 => Ok(Extend::Repeat),

1357

            2 => Ok(Extend::Reflect),

1358

            _ => Err(ParseError::BadValue),

1359

1360

1361

1362

1363

/// A COLR Paint table.

1364

///

1365

/// This describes a particular graphical operation.

1366

#[derive(Debug)]

1367

pub struct Paint<'a> {

1368

    addr: usize,

1369

    table: PaintTable<'a>,

1370

1371

1372

#[derive(Debug)]

1373

enum PaintTable<'a> {

1374

    /// V0 layers

1375

    Layers(PaintLayers),

1376

    ColrLayers(PaintColrLayers),

1377

    Solid(PaintSolid),

1378

    LinearGradient(PaintLinearGradient<'a>),

1379

    RadialGradient(PaintRadialGradient<'a>),

1380

    SweepGradient(PaintSweepGradient<'a>),

1381

    Glyph(PaintGlyph<'a>),

1382

    ColrGlyph(PaintColrGlyph),

1383

    Transform(PaintTransform<'a>),

1384

    Translate(PaintTranslate<'a>),

1385

    Scale(PaintScale<'a>),

1386

    Rotate(PaintRotate<'a>),

1387

    Skew(PaintSkew<'a>),

1388

    Composite(PaintComposite<'a>),

1389

1390

1391

macro_rules! subpaint {

1392

    ($t:ty) => {

1393

        impl<'data> $t {

1394

            fn subpaint(&self) -> Result<Paint<'data>, ParseError> {

1395

                self.scope

1396

                    .offset(usize::safe_from(self.paint_offset))

1397

                    .ctxt()

1398

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

1399

1400

1401

};

1402

1403

1404

subpaint!(PaintGlyph<'data>);

1405

subpaint!(PaintTransform<'data>);

1406

subpaint!(PaintTranslate<'data>);

1407

subpaint!(PaintScale<'data>);

1408

subpaint!(PaintRotate<'data>);

1409

subpaint!(PaintSkew<'data>);

1410

1411

#[derive(Debug)]

1412

struct PaintLayers {

1413

    /// Index (base 0) into the layerRecords array.

1414

    first_layer_index: u16,

1415

    /// Number of color layers associated with this glyph.

1416

    num_layers: u16,

1417

1418

1419

#[derive(Debug)]

1420

struct PaintColrLayers {

1421

    /// Number of offsets to paint tables to read from LayerList.

1422

    num_layers: u8,

1423

    /// Index (base 0) into the LayerList.

1424

    first_layer_index: u32,

1425

1426

1427

#[derive(Debug)]

1428

struct PaintSolid {

1429

    /// Index for a CPAL palette entry.

1430

    palette_index: u16,

1431

    /// Alpha value.

1432

    alpha: F2Dot14,

1433

    /// Base index into DeltaSetIndexMap.

1434

    _var_index_base: Option<u32>,

1435

1436

1437

trait Gradient {

1438

    fn scope(&self) -> ReadScope<'_>;

1439

1440

    fn color_line_offset(&self) -> u32;

1441

1442

    fn var_index_base(&self) -> Option<u32>;

1443

1444

    fn color_line(&self) -> Result<ColorLine<'_>, ParseError> {

1445

        let mut ctxt = self

1446

            .scope()

1447

            .offset(usize::safe_from(self.color_line_offset()))

1448

            .ctxt();

1449

1450

        if self.var_index_base().is_some() {

1451

            ctxt.read::<VarColorLine<'_>>().map(ColorLine::from)

1452

        } else {

1453

            ctxt.read::<StaticColorLine<'_>>().map(ColorLine::from)

1454

1455

1456

1457

1458

#[derive(Debug)]

1459

struct PaintLinearGradient<'a> {

1460

    scope: ReadScope<'a>,

1461

    /// Offset to ColorLine table, from beginning of PaintLinearGradient table.

1462

    color_line_offset: u32, // Offset24,

1463

    /// Start point (p₀) x coordinate.

1464

    x0: i16,

1465

    /// Start point (p₀) y coordinate.

1466

    y0: i16,

1467

    /// End point (p₁) x coordinate.

1468

    x1: i16,

1469

    /// End point (p₁) y coordinate.

1470

    y1: i16,

1471

    /// Rotation point (p₂) x coordinate.

1472

    x2: i16,

1473

    /// Rotation point (p₂) y coordinate.

1474

    y2: i16,

1475

    /// Base index into DeltaSetIndexMap.

1476

    var_index_base: Option<u32>,

1477

1478

1479

/// A linear gradient, possibly rotated about a point.

1480

#[derive(Debug)]

1481

pub struct LinearGradient<'a> {

1482

    /// The color line of the gradient

1483

    pub color_line: ColorLine<'a>,

1484

    /// Start point (p₀)

1485

    pub start_point: (i16, i16),

1486

    /// End point (p₁)

1487

    pub end_point: (i16, i16),

1488

    /// Rotation point (p₂)

1489

    pub rotation_point: (i16, i16),

1490

1491

1492

#[derive(Debug)]

1493

struct PaintRadialGradient<'a> {

1494

    scope: ReadScope<'a>,

1495

    /// Offset to VarColorLine table, from beginning of PaintVarRadialGradient table.

1496

    color_line_offset: u32, // Offset24,

1497

    /// Start circle center x coordinate.

1498

///

1499

    /// For variation, use varIndexBase + 0.

1500

    x0: i16,

1501

    /// Start circle center y coordinate.

1502

///

1503

    /// For variation, use varIndexBase + 1.

1504

    y0: i16,

1505

    /// Start circle radius.

1506

///

1507

    /// For variation, use varIndexBase + 2.

1508

    radius0: u16,

1509

    /// End circle center x coordinate.

1510

///

1511

    /// For variation, use varIndexBase + 3.

1512

    x1: i16,

1513

    /// End circle center y coordinate.

1514

///

1515

    /// For variation, use varIndexBase + 4.

1516

    y1: i16,

1517

    /// End circle radius.

1518

///

1519

    /// For variation, use varIndexBase + 5.

1520

    radius1: u16,

1521

    /// Base index into DeltaSetIndexMap.

1522

    var_index_base: Option<u32>,

1523

1524

1525

/// A gradient of colors along a cylinder defined by two circles.

1526

#[derive(Debug)]

1527

pub struct RadialGradient<'a> {

1528

    /// The color line of the gradient

1529

    pub color_line: ColorLine<'a>,

1530

    /// Start circle

1531

    pub start_circle: Circle,

1532

    /// End circle

1533

    pub end_circle: Circle,

1534

1535

1536

/// A constituent circle of a radial gradient.

1537

#[derive(Debug, Copy, Clone)]

1538

pub struct Circle {

1539

    /// The center X coordinate of the circle

1540

    pub x: i16,

1541

    /// The center Y coordinate of the circle

1542

    pub y: i16,

1543

    /// The radius of the circle

1544

    pub radius: u16,

1545

1546

1547

#[derive(Debug)]

1548

struct PaintSweepGradient<'a> {

1549

    scope: ReadScope<'a>,

1550

    /// Offset to VarColorLine table, from beginning of PaintVarSweepGradient table.

1551

    color_line_offset: u32, // Offset24,

1552

    /// Center x coordinate.

1553

///

1554

    /// For variation, use varIndexBase + 0.

1555

    center_x: i16,

1556

    /// Center y coordinate.

1557

///

1558

    /// For variation, use varIndexBase + 1.

1559

    center_y: i16,

1560

    /// Start of the angular range of the gradient: add 1.0 and multiply by 180° to retrieve counter-clockwise degrees.

1561

///

1562

    /// For variation, use varIndexBase + 2.

1563

    start_angle: F2Dot14,

1564

    /// End of the angular range of the gradient: add 1.0 and multiply by 180° to retrieve counter-clockwise degrees.

1565

///

1566

    /// For variation, use varIndexBase + 3.

1567

    end_angle: F2Dot14,

1568

    /// Base index into DeltaSetIndexMap.

1569

    var_index_base: Option<u32>,

1570

1571

1572

/// A conic or sweep gradient that provides a gradation of colors that sweep around a center point.

1573

#[derive(Debug)]

1574

pub struct ConicGradient<'a> {

1575

    /// The color line of the gradient

1576

    pub color_line: ColorLine<'a>,

1577

    /// The center point of the sweep

1578

    pub center: (i16, i16),

1579

    /// The starting angle of the sweep (raw value)

1580

///

1581

    /// **Note:** This is the raw value from the font. Add 1.0 and multiply by 180 to get

1582

    /// the angle in degrees.

1583

    pub start_angle: f32,

1584

    /// The ending angle of the sweep (raw value)

1585

///

1586

    /// **Note:** This is the raw value from the font. Add 1.0 and multiply by 180 to get

1587

    /// the angle in degrees.

1588

    pub end_angle: f32,

1589

1590

1591

#[derive(Debug)]

1592

struct PaintGlyph<'a> {

1593

    scope: ReadScope<'a>,

1594

    /// Offset to a Paint table, from beginning of PaintGlyph table.

1595

    paint_offset: u32, // Offset24,

1596

    /// Glyph ID for the source outline.

1597

    glyph_id: u16,

1598

1599

1600

#[derive(Debug)]

1601

struct PaintColrGlyph {

1602

    /// Glyph ID for a BaseGlyphList base glyph.

1603

    glyph_id: u16,

1604

1605

1606

#[derive(Debug)]

1607

struct PaintTransform<'a> {

1608

    scope: ReadScope<'a>,

1609

    /// Offset to a Paint table, from beginning of PaintGlyph table.

1610

    paint_offset: u32, // Offset24,

1611

    /// Offset to an Affine2x3 table, from beginning of PaintTransform table.

1612

    transform: Affine2x3,

1613

1614

1615

#[derive(Debug)]

1616

struct Affine2x3 {

1617

    /// x-component of transformed x-basis vector.

1618

///

1619

    /// For variation, use varIndexBase + 0.

1620

    xx: Fixed,

1621

    /// y-component of transformed x-basis vector.

1622

///

1623

    /// For variation, use varIndexBase + 1.

1624

    yx: Fixed,

1625

    /// x-component of transformed y-basis vector.

1626

///

1627

    /// For variation, use varIndexBase + 2.

1628

    xy: Fixed,

1629

    /// y-component of transformed y-basis vector.

1630

///

1631

    /// For variation, use varIndexBase + 3.

1632

    yy: Fixed,

1633

    /// Translation in x direction.

1634

///

1635

    /// For variation, use varIndexBase + 4.

1636

    dx: Fixed,

1637

    /// Translation in y direction.

1638

///

1639

    /// For variation, use varIndexBase + 5.

1640

    dy: Fixed,

1641

    /// Base index into DeltaSetIndexMap.

1642

    _var_index_base: Option<u32>,

1643

1644

1645

#[derive(Debug)]

1646

struct PaintTranslate<'a> {

1647

    scope: ReadScope<'a>,

1648

    /// Offset to a Paint subtable, from beginning of PaintVarTranslate table.

1649

    paint_offset: u32, // Offset24,

1650

    /// Translation in x direction.

1651

///

1652

    /// For variation, use varIndexBase + 0.

1653

    dx: i16,

1654

    /// Translation in y direction.

1655

///

1656

    /// For variation, use varIndexBase + 1.

1657

    dy: i16,

1658

    /// Base index into DeltaSetIndexMap.

1659

    _var_index_base: Option<u32>,

1660

1661

1662

#[derive(Debug)]

1663

struct PaintScale<'a> {

1664

    scope: ReadScope<'a>,

1665

    /// Offset to a Paint subtable, from beginning of PaintVarScale table.

1666

    paint_offset: u32, // Offset24,

1667

    /// Scale factor in (x, y) directions.

1668

///

1669

    /// For variation, use varIndexBase + 0 for x, varIndexBase + 1 for y.

1670

    scale: (F2Dot14, F2Dot14),

1671

    /// Coordinates for the center of scaling (x, y).

1672

///

1673

    /// For variation, use varIndexBase + 2 for x, varIndexBase + 3 for y.

1674

    center: Option<(i16, i16)>,

1675

    /// Base index into DeltaSetIndexMap.

1676

    _var_index_base: Option<u32>,

1677

1678

1679

#[derive(Debug)]

1680

struct PaintRotate<'a> {

1681

    scope: ReadScope<'a>,

1682

    /// Offset to a Paint subtable, from beginning of PaintVarRotate table.

1683

    paint_offset: u32, // Offset24,

1684

    /// Rotation angle, 180° in counter-clockwise degrees per 1.0 of value.

1685

///

1686

    /// For variation, use varIndexBase + 0.

1687

    angle: F2Dot14,

1688

    /// Coordinates for the center of rotation (x, y).

1689

///

1690

    /// For variation, use varIndexBase + 1 for x and varIndexBase + 2 for y.

1691

    center: Option<(i16, i16)>,

1692

    /// Base index into DeltaSetIndexMap.

1693

    _var_index_base: Option<u32>,

1694

1695

1696

#[derive(Debug)]

1697

struct PaintSkew<'a> {

1698

    scope: ReadScope<'a>,

1699

    /// Offset to a Paint subtable, from beginning of PaintVarSkew table.

1700

    paint_offset: u32, // Offset24,

1701

    /// Angle of skew (x, y)

1702

///

1703

    /// 180° in counter-clockwise degrees per 1.0 of value.

1704

///

1705

    /// For variation, use varIndexBase + 0 for x-axis and varIndexBase + 1 for y-axis.

1706

    skew_angle: (F2Dot14, F2Dot14),

1707

    /// Coordinates for the center of rotation (x, y).

1708

///

1709

    /// For variation, use varIndexBase + 2 for x and varIndexBase + 3 for y.

1710

    center: Option<(i16, i16)>,

1711

    /// Base index into DeltaSetIndexMap.

1712

    _var_index_base: Option<u32>,

1713

1714

1715

#[derive(Debug)]

1716

struct PaintComposite<'a> {

1717

    scope: ReadScope<'a>,

1718

    /// Offset to a source Paint table, from beginning of PaintComposite table.

1719

    source_paint_offset: u32, // Offset24,

1720

    /// A CompositeMode enumeration value.

1721

    composite_mode: CompositeMode,

1722

    /// Offset to a backdrop Paint table, from beginning of PaintComposite table.

1723

    backdrop_paint_offset: u32, // Offset24,

1724

1725

1726

/// Mode to use for compositing paint format.

1727

#[derive(Debug, Copy, Clone, Eq, PartialEq)]

1728

pub enum CompositeMode {

1729

    // Porter-Duff modes

1730

    /// Clear

1731

    Clear,

1732

    /// Source (“Copy” in Composition & Blending Level 1)

1733

    Src,

1734

    /// Destination

1735

    Dest,

1736

    /// Source Over

1737

    SrcOver,

1738

    /// Destination Over

1739

    DestOver,

1740

    /// Source In

1741

    SrcIn,

1742

    /// Destination In

1743

    DestIn,

1744

    /// Source Out

1745

    SrcOut,

1746

    /// Destination Out

1747

    DestOut,

1748

    /// Source Atop

1749

    SrcAtop,

1750

    /// Destination Atop

1751

    DestAtop,

1752

    /// XOR

1753

    Xor,

1754

    /// Plus (“Lighter” in Composition & Blending Level 1)

1755

    Plus,

1756

    // Separable color blend modes:

1757

    /// screen

1758

    Screen,

1759

    /// overlay

1760

    Overlay,

1761

    /// darken

1762

    Darken,

1763

    /// lighten

1764

    Lighten,

1765

    /// color-dodge

1766

    ColorDodge,

1767

    /// color-burn

1768

    ColorBurn,

1769

    /// hard-light

1770

    HardLight,

1771

    /// soft-light

1772

    SoftLight,

1773

    /// difference

1774

    Difference,

1775

    /// exclusion

1776

    Exclusion,

1777

    /// multiply

1778

    Multiply,

1779

    // Non-separable color blend modes:

1780

    /// hue

1781

    HslHue,

1782

    /// saturation

1783

    HslSaturation,

1784

    /// color

1785

    HslColor,

1786

    /// luminosity

1787

    HslLuminosity,

1788

1789

1790

impl TryFrom<u8> for CompositeMode {

1791

    type Error = ParseError;

1792

1793

    fn try_from(value: u8) -> Result<Self, Self::Error> {

1794

        match value {

1795

            0 => Ok(CompositeMode::Clear),

1796

            1 => Ok(CompositeMode::Src),

1797

            2 => Ok(CompositeMode::Dest),

1798

            3 => Ok(CompositeMode::SrcOver),

1799

            4 => Ok(CompositeMode::DestOver),

1800

            5 => Ok(CompositeMode::SrcIn),

1801

            6 => Ok(CompositeMode::DestIn),

1802

            7 => Ok(CompositeMode::SrcOut),

1803

            8 => Ok(CompositeMode::DestOut),

1804

            9 => Ok(CompositeMode::SrcAtop),

1805

            10 => Ok(CompositeMode::DestAtop),

1806

            11 => Ok(CompositeMode::Xor),

1807

            12 => Ok(CompositeMode::Plus),

1808

            13 => Ok(CompositeMode::Screen),

1809

            14 => Ok(CompositeMode::Overlay),

1810

            15 => Ok(CompositeMode::Darken),

1811

            16 => Ok(CompositeMode::Lighten),

1812

            17 => Ok(CompositeMode::ColorDodge),

1813

            18 => Ok(CompositeMode::ColorBurn),

1814

            19 => Ok(CompositeMode::HardLight),

1815

            20 => Ok(CompositeMode::SoftLight),

1816

            21 => Ok(CompositeMode::Difference),

1817

            22 => Ok(CompositeMode::Exclusion),

1818

            23 => Ok(CompositeMode::Multiply),

1819

            24 => Ok(CompositeMode::HslHue),

1820

            25 => Ok(CompositeMode::HslSaturation),

1821

            26 => Ok(CompositeMode::HslColor),

1822

            27 => Ok(CompositeMode::HslLuminosity),

1823

            _ => Err(ParseError::BadValue),

1824

1825

1826

1827

1828

impl ReadBinary for Paint<'_> {

1829

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

1830

1831

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

1832

        // Paint tables can introduce cycles because they can refer to each other in order to

1833

        // reduce duplication. When rendering a paint table if any of its ancestors are encountered

1834

        // again then a cycle is introduced. We need to detect this to prevent an infinite loop.

1835

//

1836

        // Identifying a paint table as being the "same" poses some challenges. It's not equality

1837

        // that matters since it would be ok for two equivalent paint tables to be encountered that

1838

        // contain the same data _if_ they were stored separately. Additionally, the offsets used

1839

        // to refer to paint tables are relative to different base positions so these can't be used

1840

        // either.

1841

//

1842

        // With the assumption that the paint tables are all being read from the same slice of data

1843

        // in memory the offsets will end up resolving to addresses in that slice. An offset that

1844

        // resolves to the same address as an existing paint table in the stack indicates that it's

1845

        // pointing to the same paint table and thus a cycle.

1846

//

1847

        // So, we track the address that each paint table originated from.

1848

        let addr = ctxt.scope().data().as_ptr() as usize;

1849

1850

        // Peek the format to determine paint type to read

1851

        let format = ctxt.scope().ctxt().read_u8()?;

1852

        let table = match format {

1853

            1 => PaintTable::ColrLayers(ctxt.read::<PaintColrLayers>()?),

1854

            2 | 3 => PaintTable::Solid(ctxt.read::<PaintSolid>()?),

1855

            4 | 5 => PaintTable::LinearGradient(ctxt.read::<PaintLinearGradient<'_>>()?),

1856

            6 | 7 => PaintTable::RadialGradient(ctxt.read::<PaintRadialGradient<'_>>()?),

1857

            8 | 9 => PaintTable::SweepGradient(ctxt.read::<PaintSweepGradient<'_>>()?),

1858

            10 => PaintTable::Glyph(ctxt.read::<PaintGlyph<'_>>()?),

1859

            11 => PaintTable::ColrGlyph(ctxt.read::<PaintColrGlyph>()?),

1860

            12 | 13 => PaintTable::Transform(ctxt.read::<PaintTransform<'_>>()?),

1861

            14 | 15 => PaintTable::Translate(ctxt.read::<PaintTranslate<'_>>()?),

1862

            16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 => {

1863

                PaintTable::Scale(ctxt.read::<PaintScale<'_>>()?)

1864

1865

            24 | 25 | 26 | 27 => PaintTable::Rotate(ctxt.read::<PaintRotate<'_>>()?),

1866

            28 | 29 | 30 | 31 => PaintTable::Skew(ctxt.read::<PaintSkew<'_>>()?),

1867

            32 => PaintTable::Composite(ctxt.read::<PaintComposite<'_>>()?),

1868

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

1869

};

1870

1871

        Ok(Paint { addr, table })

1872

1873

1874

1875

impl ReadBinary for PaintColrLayers {

1876

    type HostType<'a> = PaintColrLayers;

1877

1878

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

1879

        let format = ctxt.read_u8()?;

1880

        ctxt.check_version(format == 1)?;

1881

        let num_layers = ctxt.read_u8()?;

1882

        let first_layer_index = ctxt.read_u32be()?;

1883

1884

        Ok(PaintColrLayers {

1885

            num_layers,

1886

            first_layer_index,

1887

})

1888

1889

1890

1891

impl PaintSolid {

1892

    fn color(&self, palette: Palette<'_, '_>) -> Option<Color> {

1893

        // The alpha value in the COLR structure is multiplied into the alpha value given in the

1894

        // CPAL color entry. If the palette entry index is 0xFFFF, the alpha value in the COLR

1895

        // structure is multiplied into the alpha value of the text foreground color.

1896

        let color = palette.color(self.palette_index)?;

1897

        Some(Color::new_with_alpha(color, self.alpha))

1898

1899

1900

1901

impl ReadBinary for PaintSolid {

1902

    type HostType<'a> = PaintSolid;

1903

1904

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

1905

        let format = ctxt.read_u8()?;

1906

        let palette_index = ctxt.read_u16be()?;

1907

        let alpha = ctxt.read::<F2Dot14>()?;

1908

        let var_index_base = match format {

1909

            2 => None,

1910

            3 => ctxt.read_u32be().map(Some)?,

1911

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

1912

};

1913

1914

        Ok(PaintSolid {

1915

            palette_index,

1916

            alpha,

1917

            _var_index_base: var_index_base,

1918

})

1919

1920

1921

1922

macro_rules! gradient {

1923

    ($t:ty) => {

1924

        impl Gradient for $t {

1925

            fn scope(&self) -> ReadScope<'_> {

1926

                self.scope

1927

1928

1929

            fn color_line_offset(&self) -> u32 {

1930

                self.color_line_offset

1931

1932

1933

            fn var_index_base(&self) -> Option<u32> {

1934

                self.var_index_base

1935

1936

1937

};

1938

1939

1940

gradient!(PaintLinearGradient<'_>);

1941

gradient!(PaintRadialGradient<'_>);

1942

gradient!(PaintSweepGradient<'_>);

1943

1944

impl ReadBinary for PaintLinearGradient<'_> {

1945

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

1946

1947

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

1948

        let scope = ctxt.scope();

1949

        let format = ctxt.read_u8()?;

1950

        let color_line_offset = ctxt.read::<U24Be>()?;

1951

        let x0 = ctxt.read_i16be()?;

1952

        let y0 = ctxt.read_i16be()?;

1953

        let x1 = ctxt.read_i16be()?;

1954

        let y1 = ctxt.read_i16be()?;

1955

        let x2 = ctxt.read_i16be()?;

1956

        let y2 = ctxt.read_i16be()?;

1957

        let var_index_base = match format {

1958

            4 => None,

1959

            5 => ctxt.read_u32be().map(Some)?,

1960

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

1961

};

1962

1963

        Ok(PaintLinearGradient {

1964

            scope,

1965

            color_line_offset,

1966

x0,

1967

y0,

1968

x1,

1969

y1,

1970

x2,

1971

y2,

1972

            var_index_base,

1973

})

1974

1975

1976

1977

impl ReadBinary for PaintRadialGradient<'_> {

1978

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

1979

1980

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

1981

        let scope = ctxt.scope();

1982

        let format = ctxt.read_u8()?;

1983

        let color_line_offset = ctxt.read::<U24Be>()?;

1984

        let x0 = ctxt.read_i16be()?;

1985

        let y0 = ctxt.read_i16be()?;

1986

        let radius0 = ctxt.read_u16be()?;

1987

        let x1 = ctxt.read_i16be()?;

1988

        let y1 = ctxt.read_i16be()?;

1989

        let radius1 = ctxt.read_u16be()?;

1990

        let var_index_base = match format {

1991

            6 => None,

1992

            7 => ctxt.read_u32be().map(Some)?,

1993

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

1994

};

1995

1996

        Ok(PaintRadialGradient {

1997

            scope,

1998

            color_line_offset,

1999

x0,

2000

y0,

2001

            radius0,

2002

x1,

2003

y1,

2004

            radius1,

2005

            var_index_base,

2006

})

2007

2008

2009

2010

impl ReadBinary for PaintSweepGradient<'_> {

2011

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

2012

2013

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

2014

        let scope = ctxt.scope();

2015

        let format = ctxt.read_u8()?;

2016

        let color_line_offset = ctxt.read::<U24Be>()?;

2017

        let center_x = ctxt.read_i16be()?;

2018

        let center_y = ctxt.read_i16be()?;

2019

        let start_angle = ctxt.read::<F2Dot14>()?;

2020

        let end_angle = ctxt.read::<F2Dot14>()?;

2021

        let var_index_base = match format {

2022

            8 => None,

2023

            9 => ctxt.read_u32be().map(Some)?,

2024

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

2025

};

2026

2027

        Ok(PaintSweepGradient {

2028

            scope,

2029

            color_line_offset,

2030

            center_x,

2031

            center_y,

2032

            start_angle,

2033

            end_angle,

2034

            var_index_base,

2035

})

2036

2037

2038

2039

impl ReadBinary for PaintGlyph<'_> {

2040

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

2041

2042

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

2043

        let scope = ctxt.scope();

2044

        let format = ctxt.read_u8()?;

2045

        ctxt.check_version(format == 10)?;

2046

        let paint_offset = ctxt.read::<U24Be>()?;

2047

        let glyph_id = ctxt.read_u16be()?;

2048

2049

        Ok(PaintGlyph {

2050

            scope,

2051

            paint_offset,

2052

            glyph_id,

2053

})

2054

2055

2056

2057

impl ReadBinary for PaintColrGlyph {

2058

    type HostType<'a> = PaintColrGlyph;

2059

2060

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

2061

        let format = ctxt.read_u8()?;

2062

        ctxt.check_version(format == 11)?;

2063

        let glyph_id = ctxt.read_u16be()?;

2064

2065

        Ok(PaintColrGlyph { glyph_id })

2066

2067

2068

2069

impl ReadBinary for PaintTransform<'_> {

2070

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

2071

2072

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

2073

        let scope = ctxt.scope();

2074

        let format = ctxt.read_u8()?;

2075

        let paint_offset = ctxt.read::<U24Be>()?;

2076

        let transform_offset = ctxt.read::<U24Be>().map(SafeFrom::safe_from)?;

2077

        let variable = match format {

2078

            12 => false,

2079

            13 => true,

2080

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

2081

};

2082

        let transform = scope

2083

            .offset(transform_offset)

2084

            .ctxt()

2085

            .read_dep::<Affine2x3>(variable)?;

2086

2087

        Ok(PaintTransform {

2088

            scope,

2089

            paint_offset,

2090

            transform,

2091

})

2092

2093

2094

2095

impl ReadBinaryDep for Affine2x3 {

2096

    type Args<'a> = bool;

2097

    type HostType<'a> = Affine2x3;

2098

2099

    fn read_dep<'a>(

2100

        ctxt: &mut ReadCtxt<'a>,

2101

        variable: bool,

2102

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

2103

        let xx = ctxt.read::<Fixed>()?;

2104

        let yx = ctxt.read::<Fixed>()?;

2105

        let xy = ctxt.read::<Fixed>()?;

2106

        let yy = ctxt.read::<Fixed>()?;

2107

        let dx = ctxt.read::<Fixed>()?;

2108

        let dy = ctxt.read::<Fixed>()?;

2109

        let var_index_base = variable.then(|| ctxt.read_u32be()).transpose()?;

2110

2111

        Ok(Affine2x3 {

2112

xx,

2113

yx,

2114

xy,

2115

yy,

2116

dx,

2117

dy,

2118

            _var_index_base: var_index_base,

2119

})

2120

2121

2122

2123

impl ReadBinary for PaintTranslate<'_> {

2124

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

2125

2126

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

2127

        let scope = ctxt.scope();

2128

        let format = ctxt.read_u8()?;

2129

        let paint_offset = ctxt.read::<U24Be>()?;

2130

        let dx = ctxt.read_i16be()?;

2131

        let dy = ctxt.read_i16be()?;

2132

        let var_index_base = match format {

2133

            14 => None,

2134

            15 => ctxt.read_u32be().map(Some)?,

2135

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

2136

};

2137

2138

        Ok(PaintTranslate {

2139

            scope,

2140

            paint_offset,

2141

dx,

2142

dy,

2143

            _var_index_base: var_index_base,

2144

})

2145

2146

2147

2148

impl ReadBinary for PaintScale<'_> {

2149

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

2150

2151

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

2152

        let scope = ctxt.scope();

2153

        let format = ctxt.read_u8()?;

2154

        let paint_offset = ctxt.read::<U24Be>()?;

2155

        let (scale, center, var_index_base) = match format {

2156

            // PaintScale and PaintVarScale

2157

            16 | 17 => {

2158

                let scale_x = ctxt.read::<F2Dot14>()?;

2159

                let scale_y = ctxt.read::<F2Dot14>()?;

2160

                let var_index_base = (format == 17).then(|| ctxt.read_u32be()).transpose()?;

2161

                ((scale_x, scale_y), None, var_index_base)

2162

2163

            // PaintScaleAroundCenter and PaintVarScaleAroundCenter

2164

            18 | 19 => {

2165

                let scale_x = ctxt.read::<F2Dot14>()?;

2166

                let scale_y = ctxt.read::<F2Dot14>()?;

2167

                let center_x = ctxt.read_i16be()?;

2168

                let center_y = ctxt.read_i16be()?;

2169

                let var_index_base = (format == 19).then(|| ctxt.read_u32be()).transpose()?;

2170

2171

                    (scale_x, scale_y),

2172

                    Some((center_x, center_y)),

2173

                    var_index_base,

2174

2175

2176

            // PaintScaleUniform and PaintVarScaleUniform

2177

            20 | 21 => {

2178

                let scale = ctxt.read::<F2Dot14>()?;

2179

                let var_index_base = (format == 21).then(|| ctxt.read_u32be()).transpose()?;

2180

                ((scale, scale), None, var_index_base)

2181

2182

            // PaintScaleUniformAroundCenter and PaintVarScaleUniformAroundCenter

2183

            22 | 23 => {

2184

                let scale = ctxt.read::<F2Dot14>()?;

2185

                let center_x = ctxt.read_i16be()?;

2186

                let center_y = ctxt.read_i16be()?;

2187

                let var_index_base = (format == 23).then(|| ctxt.read_u32be()).transpose()?;

2188

                ((scale, scale), Some((center_x, center_y)), var_index_base)

2189

2190

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

2191

};

2192

2193

        Ok(PaintScale {

2194

            scope,

2195

            paint_offset,

2196

            scale,

2197

            center,

2198

            _var_index_base: var_index_base,

2199

})

2200

2201

2202

2203

impl ReadBinary for PaintRotate<'_> {

2204

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

2205

2206

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

2207

        let scope = ctxt.scope();

2208

        let format = ctxt.read_u8()?;

2209

        let paint_offset = ctxt.read::<U24Be>()?;

2210

        let angle = ctxt.read::<F2Dot14>()?;

2211

        let (center, var_index_base) = match format {

2212

            // PaintRotate

2213

            24 => (None, None),

2214

            // PaintVarRotate

2215

            25 => {

2216

                let var_index_base = ctxt.read_u32be()?;

2217

                (None, Some(var_index_base))

2218

2219

            // PaintRotateAroundCenter and PaintVarRotateAroundCenter

2220

            26 | 27 => {

2221

                let center_x = ctxt.read_i16be()?;

2222

                let center_y = ctxt.read_i16be()?;

2223

                let var_index_base = (format == 27).then(|| ctxt.read_u32be()).transpose()?;

2224

                (Some((center_x, center_y)), var_index_base)

2225

2226

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

2227

};

2228

2229

        Ok(PaintRotate {

2230

            scope,

2231

            paint_offset,

2232

            angle,

2233

            center,

2234

            _var_index_base: var_index_base,

2235

})

2236

2237

2238

2239

impl ReadBinary for PaintSkew<'_> {

2240

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

2241

2242

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

2243

        let scope = ctxt.scope();

2244

        let format = ctxt.read_u8()?;

2245

        let paint_offset = ctxt.read::<U24Be>()?;

2246

        let x_skew_angle = ctxt.read::<F2Dot14>()?;

2247

        let y_skew_angle = ctxt.read::<F2Dot14>()?;

2248

        let (center, var_index_base) = match format {

2249

            // PaintSkew

2250

            28 => (None, None),

2251

            // PaintVarSkew

2252

            29 => {

2253

                let var_index_base = ctxt.read_u32be()?;

2254

                (None, Some(var_index_base))

2255

2256

            // PaintSkewAroundCenter and PaintVarSkewAroundCenter

2257

            30 | 31 => {

2258

                let center_x = ctxt.read_i16be()?;

2259

                let center_y = ctxt.read_i16be()?;

2260

                let var_index_base = (format == 31).then(|| ctxt.read_u32be()).transpose()?;

2261

                (Some((center_x, center_y)), var_index_base)

2262

2263

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

2264

};

2265

2266

        Ok(PaintSkew {

2267

            scope,

2268

            paint_offset,

2269

            skew_angle: (x_skew_angle, y_skew_angle),

2270

            center,

2271

            _var_index_base: var_index_base,

2272

})

2273

2274

2275

2276

impl<'data> PaintComposite<'data> {

2277

    fn backdrop(&self) -> Result<Paint<'data>, ParseError> {

2278

        self.scope

2279

            .offset(usize::safe_from(self.backdrop_paint_offset))

2280

            .ctxt()

2281

            .read::<Paint<'data>>()

2282

2283

2284

    fn source(&self) -> Result<Paint<'data>, ParseError> {

2285

        self.scope

2286

            .offset(usize::safe_from(self.source_paint_offset))

2287

            .ctxt()

2288

            .read::<Paint<'data>>()

2289

2290

2291

2292

impl ReadBinary for PaintComposite<'_> {

2293

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

2294

2295

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

2296

        let scope = ctxt.scope();

2297

        let format = ctxt.read_u8()?;

2298

        ctxt.check_version(format == 32)?;

2299

        let source_paint_offset = ctxt.read::<U24Be>()?;

2300

        let composite_mode = ctxt.read::<CompositeMode>()?;

2301

        let backdrop_paint_offset = ctxt.read::<U24Be>()?;

2302

2303

        Ok(PaintComposite {

2304

            scope,

2305

            source_paint_offset,

2306

            composite_mode,

2307

            backdrop_paint_offset,

2308

})

2309

2310

2311

2312

impl ReadBinary for CompositeMode {

2313

    type HostType<'a> = CompositeMode;

2314

2315

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

2316

        ctxt.read_u8()

2317

            .map_err(ParseError::from)

2318

            .and_then(TryFrom::try_from)

2319

2320

2321

2322

/// An RGBA color

2323

#[derive(Copy, Clone, Debug, PartialEq)]

2324

pub struct Color(pub f32, pub f32, pub f32, pub f32);

2325

2326

impl Color {

2327

    /// Create a new Color from the supplied [ColorRecord] and alpha value

2328

    pub fn new_with_alpha(color: ColorRecord, alpha: F2Dot14) -> Self {

2329

        // "The alpha indicated in this record is multiplied with the alpha component of the CPAL

2330

        // entry (converted to float—divide by 255)."

2331

//

2332

        // "Values for alpha outside the range [0., 1.] (inclusive) are reserved; values outside

2333

        // this range must be clamped."

2334

        let alpha = ((f32::from(color.alpha) / 255.0) * f32::from(alpha)).clamp(0.0, 1.0);

2335

        Color(

2336

            f32::from(color.red) / 255.0,

2337

            f32::from(color.green) / 255.0,

2338

            f32::from(color.blue) / 255.0,

2339

            alpha,

2340

2341

2342

2343

2344

impl fmt::Display for Color {

2345

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

2346

        let r = (255.0 * self.0).round() as u8;

2347

        let g = (255.0 * self.1).round() as u8;

2348

        let b = (255.0 * self.2).round() as u8;

2349

        let a = (255.0 * self.3).round() as u8;

2350

2351

        f.write_char('#')?;

2352

        write!(f, "{:02x}", r)?;

2353

        write!(f, "{:02x}", g)?;

2354

        write!(f, "{:02x}", b)?;

2355

        write!(f, "{:02x}", a)

2356

2357

2358

2359

impl From<ColorRecord> for Color {

2360

    fn from(color: ColorRecord) -> Self {

2361

        Color(

2362

            f32::from(color.red) / 255.0,

2363

            f32::from(color.green) / 255.0,

2364

            f32::from(color.blue) / 255.0,

2365

            f32::from(color.alpha) / 255.0,

2366

2367

2368

2369

2370

impl FromStr for Color {

2371

    type Err = ParseError;

2372

2373

    fn from_str(s: &str) -> Result<Self, Self::Err> {

2374

        if !s.starts_with('#') || s.len() != 9 || s.chars().skip(1).any(|c| !c.is_ascii_hexdigit())

2375

2376

            return Err(ParseError::BadValue);

2377

2378

2379

        // NOTE(unwrap): Safe as we have verified all chars are ASCII hex digits

2380

        let r = u8::from_str_radix(&s[1..3], 16).unwrap();

2381

        let g = u8::from_str_radix(&s[3..5], 16).unwrap();

2382

        let b = u8::from_str_radix(&s[5..7], 16).unwrap();

2383

        let a = u8::from_str_radix(&s[7..9], 16).unwrap();

2384

        Ok(Color(

2385

            f32::from(r) / 255.0,

2386

            f32::from(g) / 255.0,

2387

            f32::from(b) / 255.0,

2388

            f32::from(a) / 255.0,

2389

))

2390

2391

2392

2393

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

2394

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

2395

        let ColrTable {

2396

            version,

2397

            base_glyph_records,

2398

            layer_records,

2399

            base_glyph_list,

2400

            layer_list,

2401

            clip_list,

2402

            var_index_map,

2403

            item_variation_store,

2404

        } = self;

2405

        f.debug_struct("ColrTable")

2406

            .field("version", version)

2407

            .field("base_glyph_records", base_glyph_records)

2408

            .field("layer_records", layer_records)

2409

            .field("base_glyph_list", base_glyph_list)

2410

            .field("layer_list", layer_list)

2411

            .field("clip_list", clip_list)

2412

            .field("var_index_map", var_index_map)

2413

            .field(

2414

                "item_variation_store",

2415

                if item_variation_store.is_some() {

2416

                    &"Some(_)"

2417

                } else {

2418

                    &"None"

2419

},

2420

2421

            .finish()

2422

2423

2424

2425

/// Convert the raw angle value in a paint format to degrees.

2426

fn raw_to_degrees(angle: F2Dot14) -> f32 {

2427

    f32::from(angle) * 180.

2428

2429

2430

#[cfg(test)]

2431

mod tests {

2432

    use super::*;

2433

    use crate::{

2434

        tables::{FontTableProvider, OpenTypeFont},

2435

        tag,

2436

        tests::read_fixture,

2437

        Font,

2438

};

2439

2440

    #[test]

2441

    fn test_read_colr_v1_variable() {

2442

        let buffer = read_fixture(

2443

            "tests/fonts/colr/SixtyfourConvergence-Regular-VariableFont_BLED,SCAN,XELA,YELA.ttf",

2444

);

2445

        let otf = ReadScope::new(&buffer).read::<OpenTypeFont<'_>>().unwrap();

2446

        let table_provider = otf.table_provider(0).expect("error reading font file");

2447

2448

        let colr_data = table_provider

2449

            .read_table_data(tag::COLR)

2450

            .expect("unable to read COLR data");

2451

        let colr = ReadScope::new(&colr_data)

2452

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

2453

            .expect("unable to parse COLR table");

2454

2455

        assert!(colr.base_glyph_records.is_empty());

2456

        assert!(colr.layer_records.is_empty());

2457

        assert!(colr.layer_list.is_none());

2458

        assert!(colr.clip_list.is_none());

2459

        assert_eq!(colr.var_index_map.as_ref().map(|map| map.len()), Some(8));

2460

        assert_eq!(

2461

            colr.base_glyph_list.as_ref().map(|list| list.records.len()),

2462

            Some(481)

2463

);

2464

2465

        assert!(colr.lookup(1).unwrap().is_some());

2466

2467

2468

    #[test]

2469

    #[cfg(feature = "prince")]

2470

    fn test_visit_colr_nabla_glyph() {

2471

        let buffer =

2472

            read_fixture("../../../tests/data/fonts/colr/Nabla-Regular-VariableFont_EDPT,EHLT.ttf");

2473

        let otf = ReadScope::new(&buffer).read::<OpenTypeFont<'_>>().unwrap();

2474

        let table_provider = otf.table_provider(0).expect("error reading font file");

2475

        let mut font = Font::new(table_provider).unwrap();

2476

        let mut painter = DebugVisitor;

2477

2478

        let glyph_id = 62; // 'N'

2479

        match font.visit_colr_glyph(glyph_id, 0, &mut painter) {

2480

            Ok(()) => {}

2481

            Err(err) => panic!("error visiting COLR glyph: {}", err),

2482

2483

2484