Grcov report - cbdt.rs

1

#![deny(missing_docs)]

2

3

//! Bitmap fonts in `EBLC`/`EBDT` and `CBLC`/`CBDT` tables.

4

5

use std::fmt;

6

7

use super::BitDepth;

8

use crate::binary::read::{

9

    ReadArray, ReadBinary, ReadBinaryDep, ReadCtxt, ReadFixedSizeDep, ReadFrom, ReadScope,

10

};

11

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

12

use crate::bitmap::{

13

    Bitmap, BitmapGlyph, BitmapMetrics, EmbeddedBitmap, EmbeddedMetrics, EncapsulatedBitmap,

14

    EncapsulatedFormat, Metrics,

15

};

16

use crate::error::ParseError;

17

use crate::size;

18

use crate::SafeFrom;

19

20

/// Flag in `BitmapInfo` `flags` indicating the direction of small glyph metrics is horizontal.

21

///

22

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/eblc#bitmap-flags>

23

const HORIZONTAL_METRICS: i8 = 1;

24

25

/// Flag in `BitmapInfo` `flags` indicating the direction of small glyph metrics is vertical.

26

///

27

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/eblc#bitmap-flags>

28

const VERTICAL_METRICS: i8 = 2;

29

30

/// `CBLC` — Color Bitmap Location Table

31

pub struct CBLCTable<'a> {

32

    /// Major version of this table.

33

///

34

    /// 2 for `EBLC`, 3, for `CBLC`

35

    pub major_version: u16,

36

    /// Minor version of this table.

37

    pub minor_version: u16,

38

    /// Array of "strikes" available for this font.

39

    pub bitmap_sizes: Vec<BitmapSize<'a>>,

40

41

42

/// A description of a "strike" of bitmap data.

43

pub struct BitmapSize<'a> {

44

    /// Bitmap information.

45

    pub inner: BitmapInfo,

46

    /// Index sub-table records.

47

    index_sub_table_records: ReadArray<'a, IndexSubTableRecord>,

48

    /// Index sub-tables, one for each record.

49

    index_sub_tables: Vec<IndexSubTable<'a>>,

50

51

52

#[allow(missing_docs)]

53

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

54

pub struct SbitLineMetrics {

55

    pub ascender: i8,

56

    pub descender: i8,

57

    pub width_max: u8,

58

    pub caret_slope_numerator: i8,

59

    pub caret_slope_denominator: i8,

60

    pub caret_offset: i8,

61

    pub min_origin_sb: i8,

62

    pub min_advance_sb: i8,

63

    pub max_before_bl: i8,

64

    pub min_after_bl: i8,

65

    pub pad1: i8,

66

    pub pad2: i8,

67

68

69

/// Subset of BitmapSize that includes common fields.

70

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

71

pub struct BitmapInfo {

72

    /// Line metrics for text rendered horizontally.

73

    pub hori: SbitLineMetrics,

74

    /// Line metrics for text rendered vertically.

75

    pub vert: SbitLineMetrics,

76

    /// Lowest glyph index for this size.

77

    pub start_glyph_index: u16,

78

    /// Highest glyph index for this size.

79

    pub end_glyph_index: u16,

80

    /// Horizontal pixels per em.

81

    pub ppem_x: u8,

82

    /// Vertical pixels per em.

83

    pub ppem_y: u8,

84

    /// Bit depth.

85

///

86

    /// In addition to already defined bitDepth values 1, 2, 4, and 8 supported by `EBDT` the value

87

    /// of 32 is used to identify color bitmaps with 8 bit per channel RGBA channels in `CBDT`.

88

    pub bit_depth: BitDepth,

89

    /// Vertical or horizontal.

90

    pub flags: i8,

91

92

93

/// Sub table record of `BitmapSize` describing a range of glyphs and the location of the sub

94

/// table.

95

struct IndexSubTableRecord {

96

    /// First glyph ID of this range.

97

    pub first_glyph_index: u16,

98

    /// Last glyph ID of this range (inclusive).

99

    pub last_glyph_index: u16,

100

    // Add to indexSubTableArrayOffset to get offset from beginning of EBLC.

101

    additional_offset_to_index_sub_table: u32,

102

103

104

/// An index sub table of a `BitmapSize` describing the image format and location.

105

///

106

/// The `IndexSubTable` provides the offset within `CBDT` where the bitmap data for a range of

107

/// glyphs (described by `IndexSubTableRecord`) can be found, optionally with metrics for the whole

108

/// range of glyphs as well, depending on the format.

109

enum IndexSubTable<'a> {

110

    /// IndexSubTable1: variable-metrics glyphs with 4-byte offsets.

111

    Format1 {

112

        /// Format of EBDT image data.

113

        image_format: ImageFormat,

114

        /// Offset to image data in EBDT table.

115

        image_data_offset: u32,

116

        /// Offsets into `EBDT` for bitmap data.

117

///

118

        /// The actual offset for a glyph is `image_data_offset` + the value read from this

119

        /// array.

120

        offsets: ReadArray<'a, U32Be>,

121

},

122

    /// IndexSubTable2: all glyphs have identical metrics.

123

    Format2 {

124

        /// Format of EBDT image data.

125

        image_format: ImageFormat,

126

        /// Offset to image data in EBDT table.

127

        image_data_offset: u32,

128

        /// The size of the data for each bitmap.

129

        image_size: u32,

130

        /// Metrics for all glyphs in this range.

131

        big_metrics: BigGlyphMetrics,

132

},

133

    /// IndexSubTable3: variable-metrics glyphs with 2-byte offsets.

134

    Format3 {

135

        /// Format of EBDT image data.

136

        image_format: ImageFormat,

137

        /// Offset to image data in EBDT table.

138

        image_data_offset: u32,

139

        /// Offsets into `EBDT` for bitmap data.

140

///

141

        /// The actual offset for a glyph is `image_data_offset` + the value read from this

142

        /// array.

143

        offsets: ReadArray<'a, U16Be>,

144

},

145

    /// IndexSubTable4: variable-metrics glyphs with sparse glyph codes.

146

    Format4 {

147

        /// Format of EBDT image data.

148

        image_format: ImageFormat,

149

        /// Offset to image data in EBDT table.

150

        image_data_offset: u32,

151

        /// Array of ranges.

152

        glyph_array: ReadArray<'a, GlyphOffsetPair>,

153

},

154

    /// IndexSubTable5: constant-metrics glyphs with sparse glyph codes.

155

    Format5 {

156

        /// Format of EBDT image data.

157

        image_format: ImageFormat,

158

        /// Offset to image data in EBDT table.

159

        image_data_offset: u32,

160

        /// All glyphs have the same data size.

161

        image_size: u32,

162

        /// All glyphs have the same metrics.

163

        big_metrics: BigGlyphMetrics,

164

        /// One per glyph, sorted by glyph ID.

165

        glyph_id_array: ReadArray<'a, U16Be>,

166

},

167

168

169

/// Valid image formats

170

#[allow(missing_docs)]

171

#[derive(Copy, Clone)]

172

pub enum ImageFormat {

173

    Format1,

174

    Format2,

175

    Format5,

176

    Format6,

177

    Format7,

178

    Format8,

179

    Format9,

180

    Format17,

181

    Format18,

182

    Format19,

183

184

185

#[allow(missing_docs)]

186

#[derive(Debug, Copy, Clone)]

187

pub struct SmallGlyphMetrics {

188

    pub height: u8,

189

    pub width: u8,

190

    pub bearing_x: i8,

191

    pub bearing_y: i8,

192

    pub advance: u8,

193

194

195

#[allow(missing_docs)]

196

#[derive(Debug, Copy, Clone)]

197

pub struct BigGlyphMetrics {

198

    pub height: u8,

199

    pub width: u8,

200

    pub hori_bearing_x: i8,

201

    pub hori_bearing_y: i8,

202

    pub hori_advance: u8,

203

    pub vert_bearing_x: i8,

204

    pub vert_bearing_y: i8,

205

    pub vert_advance: u8,

206

207

208

/// The direction of small glyph metrics when present.

209

enum MetricsDirection {

210

    Horizontal,

211

    Vertical,

212

    Unknown,

213

214

215

/// Record indicating the offset in `EBDT` for a specific glyph id.

216

struct GlyphOffsetPair {

217

    /// Glyph ID of glyph present.

218

    pub glyph_id: u16,

219

    /// Location in EBDT.

220

    pub offset: u16,

221

222

223

/// `CBDT` — Color Bitmap Data Table

224

pub struct CBDTTable<'a> {

225

    /// Major version of this table.

226

///

227

    /// 2 for `EBDT`, 3, for `CBDT`

228

    pub major_version: u16,

229

    /// Minor version of this table.

230

    pub minor_version: u16,

231

    /// The raw data of the whole `CBDT` table.

232

    data: ReadScope<'a>,

233

234

235

/// Record corresponding to data read from `CBDT`.

236

pub enum GlyphBitmapData<'a> {

237

    /// Format 1: small metrics, byte-aligned data.

238

    Format1 {

239

        /// Metrics information for the glyph.

240

        small_metrics: SmallGlyphMetrics,

241

        /// Byte-aligned bitmap data.

242

        data: &'a [u8],

243

},

244

    /// Format 2: small metrics, bit-aligned data.

245

    Format2 {

246

        /// Metrics information for the glyph.

247

        small_metrics: SmallGlyphMetrics,

248

        /// Bit-aligned bitmap data.

249

        data: &'a [u8],

250

},

251

    // Format3 (obsolete, not in OpenType spec)

252

    // Format4 (not supported by OpenType, Apple specific)

253

    /// Format 5: metrics in EBLC, bit-aligned image data only.

254

    Format5 {

255

        /// Metrics information for the glyph.

256

        big_metrics: BigGlyphMetrics,

257

        /// Bit-aligned bitmap data.

258

        data: &'a [u8],

259

},

260

    /// Format 6: big metrics, byte-aligned data.

261

    Format6 {

262

        /// Metrics information for the glyph.

263

        big_metrics: BigGlyphMetrics,

264

        /// Byte-aligned bitmap data.

265

        data: &'a [u8],

266

},

267

    /// Format7: big metrics, bit-aligned data.

268

    Format7 {

269

        /// Metrics information for the glyph.

270

        big_metrics: BigGlyphMetrics,

271

        /// Bit-aligned bitmap data.

272

        data: &'a [u8],

273

},

274

    /// Format 8: small metrics, component data.

275

    Format8 {

276

        /// Metrics information for the glyph.

277

        small_metrics: SmallGlyphMetrics,

278

        /// Array of EbdtComponent records.

279

        components: ReadArray<'a, EbdtComponent>,

280

},

281

    /// Format 9: big metrics, component data.

282

    Format9 {

283

        /// Metrics information for the glyph.

284

        big_metrics: BigGlyphMetrics,

285

        /// Array of EbdtComponent records.

286

        components: ReadArray<'a, EbdtComponent>,

287

},

288

    // 10-16 are not defined

289

    /// Format 17: small metrics, PNG image data.

290

    Format17 {

291

        /// Metrics information for the glyph.

292

        small_metrics: SmallGlyphMetrics,

293

        /// Raw PNG data

294

        data: &'a [u8],

295

},

296

    /// Format 18: big metrics, PNG image data.

297

    Format18 {

298

        /// Metrics information for the glyph.

299

        big_metrics: BigGlyphMetrics,

300

        /// Raw PNG data

301

        data: &'a [u8],

302

},

303

    /// Format 19: metrics in CBLC table, PNG image data.

304

    Format19 {

305

        /// Metrics information for the glyph.

306

        big_metrics: BigGlyphMetrics,

307

        /// Raw PNG data

308

        data: &'a [u8],

309

},

310

311

312

/// The EbdtComponent record is used in glyph bitmap data formats 8 and 9.

313

pub struct EbdtComponent {

314

    /// Component glyph ID

315

    pub glyph_id: u16,

316

    /// Position of component left

317

    pub x_offset: i8,

318

    /// Position of component top

319

    pub y_offset: i8,

320

321

322

/// Result of `find_strike`.

323

pub struct MatchingStrike<'a, 'b> {

324

    /// The glyph index for which the strike was matched.

325

    glyph_id: u16,

326

    pub(crate) bitmap_size: &'a BitmapSize<'b>,

327

    index_subtable_index: usize,

328

329

330

impl MatchingStrike<'_, '_> {

331

    /// Retrieve the bitmap data from the supplied strike.

332

///

333

    /// * `matching_strike` the strike to lookup the bitmap in. Acquired via

334

    ///   [find_strike](./struct.CBLCTable.html#method.find_strike).

335

    /// * `cbdt` is a reference to the colour bitmap data table.

336

///

337

    /// The returned `GlyphBitmapData` contains metrics and data for the bitmap, if found.

338

///

339

    /// **Note:** that some fonts may contain bitmaps with `0x0` dimensions, so be prepared to handle

340

    /// those.

341

    pub fn bitmap<'cbdt>(

342

        &self,

343

        cbdt: &CBDTTable<'cbdt>,

344

    ) -> Result<Option<GlyphBitmapData<'cbdt>>, ParseError> {

345

        let glyph_id = self.glyph_id;

346

347

        // NOTE(unwrap): Safe as MatchingStrike is only constructed with valid index_subtable_index.

348

        let index_sub_table_header: &IndexSubTableRecord = &self

349

            .bitmap_size

350

            .index_sub_table_records

351

            .get_item(self.index_subtable_index)

352

            .unwrap();

353

        match &self.bitmap_size.index_sub_tables[self.index_subtable_index] {

354

            IndexSubTable::Format1 {

355

                image_format,

356

                image_data_offset,

357

                offsets,

358

            } => {

359

                // Should not underflow because find_strike picked a strike that contains this glyph

360

                let glyph_index = usize::from(glyph_id - index_sub_table_header.first_glyph_index);

361

                let start =

362

                    usize::safe_from(offsets.get_item(glyph_index).ok_or(ParseError::BadIndex)?);

363

                let end = usize::safe_from(

364

                    offsets

365

                        .get_item(glyph_index + 1)

366

                        .ok_or(ParseError::BadIndex)?,

367

);

368

                let length = end - start;

369

370

                if length == 0 {

371

                    // A small number of missing glyphs can be efficiently represented in formats 1 or

372

                    // 3 by having the offset for the missing glyph be followed by the same offset for

373

                    // the next glyph, thus indicating a data size of zero.

374

                    return Ok(None);

375

376

377

                let offset = usize::safe_from(*image_data_offset) + start;

378

                let mut ctxt = cbdt.data.offset_length(offset, length)?.ctxt();

379

                let bitmap = ctxt.read_dep::<ImageFormat>((*image_format, None))?;

380

                Ok(Some(bitmap))

381

382

            IndexSubTable::Format2 {

383

                image_format,

384

                image_data_offset,

385

                image_size,

386

                big_metrics,

387

            } => {

388

                let glyph_index = u32::from(glyph_id - index_sub_table_header.first_glyph_index);

389

                let offset = usize::try_from(image_data_offset + (glyph_index * image_size))?;

390

                let mut ctxt = cbdt

391

                    .data

392

                    .offset_length(offset, usize::try_from(*image_size)?)?

393

                    .ctxt();

394

                let bitmap = ctxt.read_dep::<ImageFormat>((*image_format, Some(*big_metrics)))?;

395

                Ok(Some(bitmap))

396

397

            IndexSubTable::Format3 {

398

                image_format,

399

                image_data_offset,

400

                offsets,

401

            } => {

402

                // Should not underflow because find_strike picked a strike that contains this glyph

403

                let glyph_index = usize::from(glyph_id - index_sub_table_header.first_glyph_index);

404

                let start = usize::from(offsets.get_item(glyph_index).ok_or(ParseError::BadIndex)?);

405

                let end = usize::from(

406

                    offsets

407

                        .get_item(glyph_index + 1)

408

                        .ok_or(ParseError::BadIndex)?,

409

);

410

                let length = end - start;

411

412

                if length == 0 {

413

                    // A small number of missing glyphs can be efficiently represented in formats 1 or

414

                    // 3 by having the offset for the missing glyph be followed by the same offset for

415

                    // the next glyph, thus indicating a data size of zero.

416

                    return Ok(None);

417

418

419

                let offset = usize::try_from(*image_data_offset)? + start;

420

                let mut ctxt = cbdt.data.offset_length(offset, length)?.ctxt();

421

                let bitmap = ctxt.read_dep::<ImageFormat>((*image_format, None))?;

422

                Ok(Some(bitmap))

423

424

            IndexSubTable::Format4 {

425

                image_format,

426

                image_data_offset,

427

                glyph_array,

428

            } => {

429

                // Try to find the desired glyph in the offset pairs

430

                for (glyph_index, glyph_offset_pair) in glyph_array.iter().enumerate() {

431

                    if glyph_offset_pair.glyph_id == glyph_id {

432

                        let offset = usize::try_from(*image_data_offset)?

433

                            + usize::from(glyph_offset_pair.offset);

434

435

                        // Get the next pair to determine how big the image data for this glyph is

436

                        let end = glyph_array

437

                            .get_item(glyph_index + 1)

438

                            .ok_or(ParseError::BadIndex)?;

439

                        let length = usize::from(end.offset - glyph_offset_pair.offset);

440

                        let mut ctxt = cbdt.data.offset_length(offset, length)?.ctxt();

441

                        let bitmap = ctxt.read_dep::<ImageFormat>((*image_format, None))?;

442

                        return Ok(Some(bitmap));

443

                    } else if glyph_offset_pair.glyph_id > glyph_id {

444

                        // Pairs are supposed to be ordered by glyph id so if we're past the one we're

445

                        // looking for it won't be found.

446

                        return Ok(None);

447

448

449

450

                Ok(None)

451

452

            IndexSubTable::Format5 {

453

                image_format,

454

                image_data_offset,

455

                image_size,

456

                big_metrics,

457

                glyph_id_array,

458

            } => {

459

                // Try to find the desired glyph in the list of glyphs covered by this index

460

                for (glyph_index, this_glyph_id) in glyph_id_array.iter().enumerate() {

461

                    if this_glyph_id == glyph_id {

462

                        // Found

463

                        // cast is safe because glyph_id_array num_glyphs is a u32

464

                        let offset =

465

                            usize::try_from(image_data_offset + (glyph_index as u32 * image_size))?;

466

                        let mut ctxt = cbdt

467

                            .data

468

                            .offset_length(offset, usize::try_from(*image_size)?)?

469

                            .ctxt();

470

                        let bitmap =

471

                            ctxt.read_dep::<ImageFormat>((*image_format, Some(*big_metrics)))?;

472

                        return Ok(Some(bitmap));

473

                    } else if this_glyph_id > glyph_id {

474

                        // Array is meant to be ordered by glyph id so if we're past the one we're

475

                        // looking for it won't be found.

476

                        return Ok(None);

477

478

479

480

                Ok(None)

481

482

483

484

485

486

impl ReadBinaryDep for ImageFormat {

487

    type Args<'a> = (ImageFormat, Option<BigGlyphMetrics>);

488

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

489

490

    fn read_dep<'a>(

491

        ctxt: &mut ReadCtxt<'a>,

492

        (format, metrics): Self::Args<'_>,

493

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

494

        match format {

495

            ImageFormat::Format1 => {

496

                let small_metrics = ctxt.read::<SmallGlyphMetrics>()?;

497

                let data = ctxt.scope().data();

498

499

                Ok(GlyphBitmapData::Format1 {

500

                    small_metrics,

501

                    data,

502

})

503

504

            ImageFormat::Format2 => {

505

                let small_metrics = ctxt.read::<SmallGlyphMetrics>()?;

506

                let data = ctxt.scope().data();

507

508

                Ok(GlyphBitmapData::Format2 {

509

                    small_metrics,

510

                    data,

511

})

512

513

            ImageFormat::Format5 => Ok(GlyphBitmapData::Format5 {

514

                big_metrics: metrics.ok_or(ParseError::MissingValue)?,

515

                data: ctxt.scope().data(),

516

}),

517

            ImageFormat::Format6 => {

518

                let big_metrics = ctxt.read::<BigGlyphMetrics>()?;

519

                let data = ctxt.scope().data();

520

521

                Ok(GlyphBitmapData::Format6 { big_metrics, data })

522

523

            ImageFormat::Format7 => {

524

                let big_metrics = ctxt.read::<BigGlyphMetrics>()?;

525

                let data = ctxt.scope().data();

526

527

                Ok(GlyphBitmapData::Format7 { big_metrics, data })

528

529

            ImageFormat::Format8 => {

530

                let small_metrics = ctxt.read::<SmallGlyphMetrics>()?;

531

                let _pad = ctxt.read_u8()?;

532

                let num_components = usize::from(ctxt.read_u16be()?);

533

                let components = ctxt.read_array::<EbdtComponent>(num_components)?;

534

535

                Ok(GlyphBitmapData::Format8 {

536

                    small_metrics,

537

                    components,

538

})

539

540

            ImageFormat::Format9 => {

541

                let big_metrics = ctxt.read::<BigGlyphMetrics>()?;

542

                let num_components = usize::from(ctxt.read_u16be()?);

543

                let components = ctxt.read_array::<EbdtComponent>(num_components)?;

544

545

                Ok(GlyphBitmapData::Format9 {

546

                    big_metrics,

547

                    components,

548

})

549

550

            ImageFormat::Format17 => {

551

                let small_metrics = ctxt.read::<SmallGlyphMetrics>()?;

552

                let data_len = usize::try_from(ctxt.read_u32be()?)?;

553

                let data = ctxt.read_slice(data_len)?;

554

555

                Ok(GlyphBitmapData::Format17 {

556

                    small_metrics,

557

                    data,

558

})

559

560

            ImageFormat::Format18 => {

561

                let big_metrics = ctxt.read::<BigGlyphMetrics>()?;

562

                let data_len = usize::try_from(ctxt.read_u32be()?)?;

563

                let data = ctxt.read_slice(data_len)?;

564

565

                Ok(GlyphBitmapData::Format18 { big_metrics, data })

566

567

            ImageFormat::Format19 => {

568

                let data_len = usize::try_from(ctxt.read_u32be()?)?;

569

                let data = ctxt.read_slice(data_len)?;

570

571

                Ok(GlyphBitmapData::Format19 {

572

                    big_metrics: metrics.ok_or(ParseError::MissingValue)?,

573

                    data,

574

})

575

576

577

578

579

580

impl<'a> CBLCTable<'a> {

581

    /// Find a strike matching the supplied criteria.

582

///

583

    /// * `glyph_id` is the glyph to lookup.

584

    /// * `target_ppem` is the desired size. If an exact match can't be found the nearest one will

585

    ///    be returned, favouring being oversize vs. undersized.

586

    /// * `max_bit_depth` is the maximum accepted bit depth of the bitmap to return. If you accept

587

    ///   all bit depths then use `BitDepth::ThirtyTwo`.

588

    pub fn find_strike(

589

        &self,

590

        glyph_id: u16,

591

        target_ppem: u8,

592

        max_bit_depth: BitDepth,

593

    ) -> Option<MatchingStrike<'_, 'a>> {

594

        // Find a strike that contains the glyph we want, then find one with an appropriate size

595

        let candidates = self.bitmap_sizes.iter().filter_map(|bitmap_size| {

596

            bitmap_size

597

                .index_sub_table_index(glyph_id)

598

                .and_then(|index| {

599

                    if bitmap_size.inner.bit_depth <= max_bit_depth {

600

                        Some((bitmap_size, index))

601

                    } else {

602

                        // Strike has higher bit depth than max_bit_depth

603

                        None

604

605

})

606

});

607

608

        // Pick a candidate that maximises size and bit depth according to `size_ppem` and `max_bit_depth`.

609

        let size_ppem = i16::from(target_ppem);

610

        let mut best: Option<(i16, &BitmapSize<'a>, usize)> = None;

611

612

        for (bitmap_size, index) in candidates {

613

            let difference = i16::from(bitmap_size.inner.ppem_x) - size_ppem;

614

            match best {

615

                Some((current_best_difference, current_best_bitmap_size, _))

616

                    if same_size_higher_bit_depth(

617

                        difference,

618

                        current_best_difference,

619

                        bitmap_size.inner.bit_depth,

620

                        current_best_bitmap_size.inner.bit_depth,

621

                    ) =>

622

623

                    best = Some((difference, bitmap_size, index))

624

625

                Some((current_best_difference, _, _))

626

                    if super::bigger_or_closer_to_zero(

627

                        i32::from(difference),

628

                        i32::from(current_best_difference),

629

                    ) =>

630

631

                    best = Some((difference, bitmap_size, index))

632

633

                None => best = Some((difference, bitmap_size, index)),

634

                _ => (),

635

636

637

638

        best.map(|(_, bitmap_size, index)| MatchingStrike {

639

            glyph_id,

640

            bitmap_size,

641

            index_subtable_index: index,

642

})

643

644

645

646

fn same_size_higher_bit_depth(

647

    difference: i16,

648

    current_best_difference: i16,

649

    candiate_bit_depth: BitDepth,

650

    current_best_bit_depth: BitDepth,

651

) -> bool {

652

    difference == current_best_difference && candiate_bit_depth > current_best_bit_depth

653

654

655

impl ReadBinary for CBLCTable<'_> {

656

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

657

658

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

659

        let table = ctxt.scope();

660

661

        let major_version = ctxt.read_u16be()?;

662

        // version 2 is EBLT, version 3 is CBLC, 3 is backward compatible but defines additional

663

        // formats and bit depth.

664

        ctxt.check_version((2..=3).contains(&major_version))?;

665

        let minor_version = ctxt.read_u16be()?;

666

        let num_sizes = ctxt.read_u32be()?;

667

        let bitmap_sizes = ctxt

668

            .read_array_dep::<BitmapSize<'_>>(usize::try_from(num_sizes)?, table)?

669

            .iter_res()

670

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

671

672

        Ok(CBLCTable {

673

            major_version,

674

            minor_version,

675

            bitmap_sizes,

676

})

677

678

679

680

impl ReadBinary for CBDTTable<'_> {

681

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

682

683

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

684

        // The locators in the CBLC table are relative to the start of the CBDT table.

685

        // So we hold on to a scope at the start of the table for later use.

686

        let data = ctxt.scope();

687

        let major_version = ctxt.read_u16be()?;

688

        // version 2 is EBLT, version 3 is CBLC, 3 is backward compatible but defines additional

689

        // formats and bit depth.

690

        ctxt.check_version((2..=3).contains(&major_version))?;

691

        let minor_version = ctxt.read_u16be()?;

692

        Ok(CBDTTable {

693

            major_version,

694

            minor_version,

695

            data,

696

})

697

698

699

700

impl BitmapSize<'_> {

701

    /// Returns the index of the index sub table for the supplied glyph, if found.

702

    fn index_sub_table_index(&self, glyph_id: u16) -> Option<usize> {

703

        // The startGlyphIndex and endGlyphIndex describe the minimum and maximum glyph IDs in the

704

        // strike, but a strike does not necessarily contain bitmaps for all glyph IDs in this

705

        // range. The IndexSubTables determine which glyphs are actually present in the CBDT table.

706

        // https://docs.microsoft.com/en-us/typography/opentype/spec/eblc#sbitlinemetrics

707

        if (self.inner.start_glyph_index..=self.inner.end_glyph_index).contains(&glyph_id) {

708

            self.index_sub_table_records

709

                .iter()

710

                .position(|record| record.contains_glyph(glyph_id))

711

        } else {

712

            None

713

714

715

716

717

impl MatchingStrike<'_, '_> {

718

    /// Returns the bit depth of this `MatchingStrike`.

719

    pub fn bit_depth(&self) -> BitDepth {

720

        self.bitmap_size.inner.bit_depth

721

722

723

724

impl ReadBinaryDep for BitmapSize<'_> {

725

    type Args<'a> = ReadScope<'a>;

726

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

727

728

    fn read_dep<'a>(

729

        ctxt: &mut ReadCtxt<'a>,

730

        cblc_scope: Self::Args<'a>,

731

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

732

        let index_sub_table_array_offset = usize::try_from(ctxt.read_u32be()?)?;

733

        let _index_tables_size = ctxt.read_u32be()?;

734

        let number_of_index_sub_tables = ctxt.read_u32be()?;

735

        let _color_ref = ctxt.read_u32be()?; // Not used; set to 0.

736

        let hori = ctxt.read::<SbitLineMetrics>()?;

737

        let vert = ctxt.read::<SbitLineMetrics>()?;

738

        let start_glyph_index = ctxt.read_u16be()?;

739

        let end_glyph_index = ctxt.read_u16be()?;

740

        let ppem_x = ctxt.read_u8()?;

741

        let ppem_y = ctxt.read_u8()?;

742

        let bit_depth = BitDepth::try_from(ctxt.read_u8()?)?;

743

        let flags = ctxt.read_i8()?;

744

745

        // Read the index sub tables

746

        let index_sub_table_records: ReadArray<'_, IndexSubTableRecord> = cblc_scope

747

            .offset(index_sub_table_array_offset)

748

            .ctxt()

749

            .read_array::<IndexSubTableRecord>(usize::try_from(number_of_index_sub_tables)?)?;

750

        let mut index_sub_tables = Vec::with_capacity(usize::try_from(number_of_index_sub_tables)?);

751

        for index_sub_table_record in index_sub_table_records.iter() {

752

            let offset = index_sub_table_array_offset

753

                .checked_add(usize::try_from(

754

                    index_sub_table_record.additional_offset_to_index_sub_table,

755

)?)

756

                .ok_or(ParseError::BadOffset)?;

757

            // Read the index sub table

758

            let index_sub_table = cblc_scope

759

                .offset(offset)

760

                .ctxt()

761

                .read_dep::<IndexSubTable<'_>>((

762

                    index_sub_table_record.first_glyph_index,

763

                    index_sub_table_record.last_glyph_index,

764

                ))?;

765

            index_sub_tables.push(index_sub_table);

766

767

768

        Ok(BitmapSize {

769

            inner: BitmapInfo {

770

                hori,

771

                vert,

772

                start_glyph_index,

773

                end_glyph_index,

774

                ppem_x,

775

                ppem_y,

776

                bit_depth,

777

                flags,

778

},

779

            index_sub_table_records,

780

            index_sub_tables,

781

})

782

783

784

785

impl ReadFixedSizeDep for BitmapSize<'_> {

786

    fn size(_: Self::Args<'_>) -> usize {

787

        // Offset32         indexSubTableArrayOffset

788

        // uint32           indexTablesSize

789

        // uint32           numberofIndexSubTables

790

        // uint32           colorRef

791

        (4 * size::U32)

792

        // SbitLineMetrics  hori

793

        // SbitLineMetrics  vert

794

        + (2 * SbitLineMetrics::size(()))

795

        // uint16           startGlyphIndex

796

        // uint16           endGlyphIndex

797

        + (2 * size::U16)

798

        // uint8            ppemX

799

        // uint8            ppemY

800

        // uint8            bitDepth

801

        // int8             flags

802

+ 4

803

804

805

806

impl ReadBinary for SbitLineMetrics {

807

    type HostType<'b> = Self;

808

809

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

810

        let ascender = ctxt.read_i8()?;

811

        let descender = ctxt.read_i8()?;

812

        let width_max = ctxt.read_u8()?;

813

        let caret_slope_numerator = ctxt.read_i8()?;

814

        let caret_slope_denominator = ctxt.read_i8()?;

815

        let caret_offset = ctxt.read_i8()?;

816

        let min_origin_sb = ctxt.read_i8()?;

817

        let min_advance_sb = ctxt.read_i8()?;

818

        let max_before_bl = ctxt.read_i8()?;

819

        let min_after_bl = ctxt.read_i8()?;

820

        let pad1 = ctxt.read_i8()?;

821

        let pad2 = ctxt.read_i8()?;

822

823

        Ok(SbitLineMetrics {

824

            ascender,

825

            descender,

826

            width_max,

827

            caret_slope_numerator,

828

            caret_slope_denominator,

829

            caret_offset,

830

            min_origin_sb,

831

            min_advance_sb,

832

            max_before_bl,

833

            min_after_bl,

834

            pad1,

835

            pad2,

836

})

837

838

839

840

impl ReadFixedSizeDep for SbitLineMetrics {

841

    fn size(_scope: Self::Args<'_>) -> usize {

842

        // 12 fields, all 1 byte

843

844

845

846

847

impl TryFrom<u8> for BitDepth {

848

    type Error = ParseError;

849

850

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

851

        match value {

852

            1 => Ok(BitDepth::One),

853

            2 => Ok(BitDepth::Two),

854

            4 => Ok(BitDepth::Four),

855

            8 => Ok(BitDepth::Eight),

856

            32 => Ok(BitDepth::ThirtyTwo),

857

            _ => Err(ParseError::BadValue),

858

859

860

861

862

impl IndexSubTableRecord {

863

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

864

        (self.first_glyph_index..=self.last_glyph_index).contains(&glyph_id)

865

866

867

868

impl ReadFrom for IndexSubTableRecord {

869

    type ReadType = (U16Be, U16Be, U32Be);

870

871

    fn read_from(

872

        (first_glyph_index, last_glyph_index, additional_offset_to_index_sub_table): (

873

            u16,

874

            u16,

875

            u32,

876

),

877

    ) -> Self {

878

        IndexSubTableRecord {

879

            first_glyph_index,

880

            last_glyph_index,

881

            additional_offset_to_index_sub_table,

882

883

884

885

886

impl ReadBinaryDep for IndexSubTable<'_> {

887

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

888

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

889

890

    fn read_dep<'a>(

891

        ctxt: &mut ReadCtxt<'a>,

892

        (first_glyph_index, last_glyph_index): (u16, u16),

893

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

894

        let index_format = ctxt.read_u16be()?;

895

        let image_format = ImageFormat::try_from(ctxt.read_u16be()?)?;

896

        let image_data_offset = ctxt.read_u32be()?;

897

898

        match index_format {

899

            1 => {

900

                // +1 for last_glyph_index being inclusive,

901

                // +1 for there being an extra record at the end

902

                let offsets = ctxt.read_array::<U32Be>(usize::from(

903

                    last_glyph_index - first_glyph_index + 1 + 1,

904

                ))?;

905

                Ok(IndexSubTable::Format1 {

906

                    image_format,

907

                    image_data_offset,

908

                    offsets,

909

})

910

911

            2 => {

912

                let image_size = ctxt.read_u32be()?;

913

                let big_metrics = ctxt.read::<BigGlyphMetrics>()?;

914

                Ok(IndexSubTable::Format2 {

915

                    image_format,

916

                    image_data_offset,

917

                    image_size,

918

                    big_metrics,

919

})

920

921

            3 => {

922

                // +1 for last_glyph_index being inclusive,

923

                // +1 for there being an extra record at the end

924

                let offsets = ctxt.read_array::<U16Be>(usize::from(

925

                    last_glyph_index - first_glyph_index + 1 + 1,

926

                ))?;

927

                Ok(IndexSubTable::Format3 {

928

                    image_format,

929

                    image_data_offset,

930

                    offsets,

931

})

932

933

            4 => {

934

                let num_glyphs = ctxt.read_u32be()?;

935

                let glyph_array =

936

                    ctxt.read_array::<GlyphOffsetPair>(usize::try_from(num_glyphs + 1)?)?;

937

                Ok(IndexSubTable::Format4 {

938

                    image_format,

939

                    image_data_offset,

940

                    glyph_array,

941

})

942

943

            5 => {

944

                let image_size = ctxt.read_u32be()?;

945

                let big_metrics = ctxt.read::<BigGlyphMetrics>()?;

946

                let num_glyphs = ctxt.read_u32be()?;

947

                let glyph_id_array = ctxt.read_array::<U16Be>(usize::try_from(num_glyphs)?)?;

948

                Ok(IndexSubTable::Format5 {

949

                    image_format,

950

                    image_data_offset,

951

                    image_size,

952

                    big_metrics,

953

                    glyph_id_array,

954

})

955

956

            _ => Err(ParseError::BadValue),

957

958

959

960

961

impl ReadFrom for SmallGlyphMetrics {

962

    type ReadType = ((U8, U8), (I8, I8, U8));

963

964

    fn read_from(

965

        ((height, width), (bearing_x, bearing_y, advance)): ((u8, u8), (i8, i8, u8)),

966

    ) -> Self {

967

        SmallGlyphMetrics {

968

            height,

969

            width,

970

            bearing_x,

971

            bearing_y,

972

            advance,

973

974

975

976

977

impl ReadBinary for BigGlyphMetrics {

978

    type HostType<'b> = Self;

979

980

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

981

        let height = ctxt.read_u8()?;

982

        let width = ctxt.read_u8()?;

983

        let hori_bearing_x = ctxt.read_i8()?;

984

        let hori_bearing_y = ctxt.read_i8()?;

985

        let hori_advance = ctxt.read_u8()?;

986

        let vert_bearing_x = ctxt.read_i8()?;

987

        let vert_bearing_y = ctxt.read_i8()?;

988

        let vert_advance = ctxt.read_u8()?;

989

990

        Ok(BigGlyphMetrics {

991

            height,

992

            width,

993

            hori_bearing_x,

994

            hori_bearing_y,

995

            hori_advance,

996

            vert_bearing_x,

997

            vert_bearing_y,

998

            vert_advance,

999

})

1000

1001

1002

1003

impl ReadFixedSizeDep for BigGlyphMetrics {

1004

    fn size(_scope: Self::Args<'_>) -> usize {

1005

        // 8 fields, all 1 byte

1006

1007

1008

1009

1010

impl ReadFrom for GlyphOffsetPair {

1011

    type ReadType = (U16Be, U16Be);

1012

1013

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

1014

        GlyphOffsetPair { glyph_id, offset }

1015

1016

1017

1018

impl ReadFrom for EbdtComponent {

1019

    type ReadType = (U16Be, I8, I8);

1020

1021

    fn read_from((glyph_id, x_offset, y_offset): (u16, i8, i8)) -> Self {

1022

        EbdtComponent {

1023

            glyph_id,

1024

            x_offset,

1025

            y_offset,

1026

1027

1028

1029

1030

impl TryFrom<u16> for ImageFormat {

1031

    type Error = ParseError;

1032

1033

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

1034

        match value {

1035

            1 => Ok(ImageFormat::Format1),

1036

            2 => Ok(ImageFormat::Format2),

1037

            5 => Ok(ImageFormat::Format5),

1038

            6 => Ok(ImageFormat::Format6),

1039

            7 => Ok(ImageFormat::Format7),

1040

            8 => Ok(ImageFormat::Format8),

1041

            9 => Ok(ImageFormat::Format9),

1042

            17 => Ok(ImageFormat::Format17),

1043

            18 => Ok(ImageFormat::Format18),

1044

            19 => Ok(ImageFormat::Format19),

1045

            _ => Err(ParseError::BadValue),

1046

1047

1048

1049

1050

impl<'a> TryFrom<(&BitmapInfo, GlyphBitmapData<'a>, u16)> for BitmapGlyph {

1051

    type Error = ParseError;

1052

1053

    fn try_from(

1054

        (info, glyph, bitmap_id): (&BitmapInfo, GlyphBitmapData<'a>, u16),

1055

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

1056

        let res = match glyph {

1057

            // Format 1: small metrics, byte-aligned data.

1058

            GlyphBitmapData::Format1 {

1059

                small_metrics,

1060

                data,

1061

            } => {

1062

                let data = bgra_to_rgba(info.bit_depth, data.to_vec())?;

1063

                let metrics = EmbeddedMetrics::try_from((info, &small_metrics))?;

1064

                BitmapGlyph {

1065

                    bitmap: Bitmap::Embedded(EmbeddedBitmap {

1066

                        format: info.bit_depth,

1067

                        width: small_metrics.width,

1068

                        height: small_metrics.height,

1069

                        data: Box::from(data),

1070

}),

1071

                    bitmap_id,

1072

                    metrics: Metrics::Embedded(metrics),

1073

                    ppem_x: Some(u16::from(info.ppem_x)),

1074

                    ppem_y: Some(u16::from(info.ppem_y)),

1075

                    should_flip_hori: false,

1076

1077

1078

            // Format 2: small metrics, bit-aligned data.

1079

            GlyphBitmapData::Format2 {

1080

                small_metrics,

1081

                data,

1082

            } => {

1083

                let metrics = EmbeddedMetrics::try_from((info, &small_metrics))?;

1084

                let unpacked = unpack_bit_aligned_data(

1085

                    info.bit_depth,

1086

                    small_metrics.width,

1087

                    small_metrics.height,

1088

                    data,

1089

1090

                .and_then(|data| bgra_to_rgba(info.bit_depth, data))?;

1091

                BitmapGlyph {

1092

                    bitmap: Bitmap::Embedded(EmbeddedBitmap {

1093

                        format: info.bit_depth,

1094

                        width: small_metrics.width,

1095

                        height: small_metrics.height,

1096

                        data: unpacked.into(),

1097

}),

1098

                    bitmap_id,

1099

                    metrics: Metrics::Embedded(metrics),

1100

                    ppem_x: Some(u16::from(info.ppem_x)),

1101

                    ppem_y: Some(u16::from(info.ppem_y)),

1102

                    should_flip_hori: false,

1103

1104

1105

            // Format 5: metrics in EBLC, bit-aligned image data only.

1106

            GlyphBitmapData::Format5 { big_metrics, data } => {

1107

                let metrics = EmbeddedMetrics::try_from((info, &big_metrics))?;

1108

                let unpacked = unpack_bit_aligned_data(

1109

                    info.bit_depth,

1110

                    big_metrics.width,

1111

                    big_metrics.height,

1112

                    data,

1113

1114

                .and_then(|data| bgra_to_rgba(info.bit_depth, data))?;

1115

                BitmapGlyph {

1116

                    bitmap: Bitmap::Embedded(EmbeddedBitmap {

1117

                        format: info.bit_depth,

1118

                        width: big_metrics.width,

1119

                        height: big_metrics.height,

1120

                        data: unpacked.into(),

1121

}),

1122

                    bitmap_id,

1123

                    metrics: Metrics::Embedded(metrics),

1124

                    ppem_x: Some(u16::from(info.ppem_x)),

1125

                    ppem_y: Some(u16::from(info.ppem_y)),

1126

                    should_flip_hori: false,

1127

1128

1129

            // Format 6: big metrics, byte-aligned data.

1130

            GlyphBitmapData::Format6 { big_metrics, data } => {

1131

                let data = bgra_to_rgba(info.bit_depth, data.to_vec())?;

1132

                let metrics = EmbeddedMetrics::try_from((info, &big_metrics))?;

1133

                BitmapGlyph {

1134

                    bitmap: Bitmap::Embedded(EmbeddedBitmap {

1135

                        format: info.bit_depth,

1136

                        width: big_metrics.width,

1137

                        height: big_metrics.height,

1138

                        data: Box::from(data),

1139

}),

1140

                    bitmap_id,

1141

                    metrics: Metrics::Embedded(metrics),

1142

                    ppem_x: Some(u16::from(info.ppem_x)),

1143

                    ppem_y: Some(u16::from(info.ppem_y)),

1144

                    should_flip_hori: false,

1145

1146

1147

            // Format7: big metrics, bit-aligned data.

1148

            GlyphBitmapData::Format7 { big_metrics, data } => {

1149

                let metrics = EmbeddedMetrics::try_from((info, &big_metrics))?;

1150

                let unpacked = unpack_bit_aligned_data(

1151

                    info.bit_depth,

1152

                    big_metrics.width,

1153

                    big_metrics.height,

1154

                    data,

1155

1156

                .and_then(|data| bgra_to_rgba(info.bit_depth, data))?;

1157

                BitmapGlyph {

1158

                    bitmap: Bitmap::Embedded(EmbeddedBitmap {

1159

                        format: info.bit_depth,

1160

                        width: big_metrics.width,

1161

                        height: big_metrics.height,

1162

                        data: unpacked.into(),

1163

}),

1164

                    bitmap_id,

1165

                    metrics: Metrics::Embedded(metrics),

1166

                    ppem_x: Some(u16::from(info.ppem_x)),

1167

                    ppem_y: Some(u16::from(info.ppem_y)),

1168

                    should_flip_hori: false,

1169

1170

1171

            // Format 8: small metrics, component data.

1172

            GlyphBitmapData::Format8 { .. } => return Err(ParseError::NotImplemented),

1173

            // Format 9: big metrics, component data.

1174

            GlyphBitmapData::Format9 { .. } => return Err(ParseError::NotImplemented),

1175

            // Format 17: small metrics, PNG image data.

1176

            GlyphBitmapData::Format17 {

1177

                small_metrics,

1178

                data,

1179

            } => {

1180

                let metrics = EmbeddedMetrics::try_from((info, &small_metrics))?;

1181

                let bitmap = EncapsulatedBitmap {

1182

                    format: EncapsulatedFormat::Png,

1183

                    data: Box::from(data),

1184

};

1185

                BitmapGlyph {

1186

                    bitmap: Bitmap::Encapsulated(bitmap),

1187

                    bitmap_id,

1188

                    metrics: Metrics::Embedded(metrics),

1189

                    ppem_x: Some(u16::from(info.ppem_x)),

1190

                    ppem_y: Some(u16::from(info.ppem_y)),

1191

                    should_flip_hori: false,

1192

1193

1194

            // Format 18: big metrics, PNG image data.

1195

            // Format 19: metrics in CBLC table, PNG image data.

1196

            GlyphBitmapData::Format18 { big_metrics, data }

1197

            | GlyphBitmapData::Format19 { big_metrics, data } => {

1198

                let metrics = EmbeddedMetrics::try_from((info, &big_metrics))?;

1199

                let bitmap = EncapsulatedBitmap {

1200

                    format: EncapsulatedFormat::Png,

1201

                    data: Box::from(data),

1202

};

1203

                BitmapGlyph {

1204

                    bitmap: Bitmap::Encapsulated(bitmap),

1205

                    bitmap_id,

1206

                    metrics: Metrics::Embedded(metrics),

1207

                    ppem_x: Some(u16::from(info.ppem_x)),

1208

                    ppem_y: Some(u16::from(info.ppem_y)),

1209

                    should_flip_hori: false,

1210

1211

1212

};

1213

1214

        Ok(res)

1215

1216

1217

1218

impl GlyphBitmapData<'_> {

1219

    /// The width of the bitmap.

1220

    pub fn width(&self) -> u8 {

1221

        match self {

1222

            GlyphBitmapData::Format1 {

1223

                small_metrics: SmallGlyphMetrics { width, .. },

1224

..

1225

            } => *width,

1226

            GlyphBitmapData::Format2 {

1227

                small_metrics: SmallGlyphMetrics { width, .. },

1228

..

1229

            } => *width,

1230

            GlyphBitmapData::Format5 {

1231

                big_metrics: BigGlyphMetrics { width, .. },

1232

..

1233

            } => *width,

1234

            GlyphBitmapData::Format6 {

1235

                big_metrics: BigGlyphMetrics { width, .. },

1236

..

1237

            } => *width,

1238

            GlyphBitmapData::Format7 {

1239

                big_metrics: BigGlyphMetrics { width, .. },

1240

..

1241

            } => *width,

1242

            GlyphBitmapData::Format8 {

1243

                small_metrics: SmallGlyphMetrics { width, .. },

1244

..

1245

            } => *width,

1246

            GlyphBitmapData::Format9 {

1247

                big_metrics: BigGlyphMetrics { width, .. },

1248

..

1249

            } => *width,

1250

            GlyphBitmapData::Format17 {

1251

                small_metrics: SmallGlyphMetrics { width, .. },

1252

..

1253

            } => *width,

1254

            GlyphBitmapData::Format18 {

1255

                big_metrics: BigGlyphMetrics { width, .. },

1256

..

1257

            } => *width,

1258

            GlyphBitmapData::Format19 {

1259

                big_metrics: BigGlyphMetrics { width, .. },

1260

..

1261

            } => *width,

1262

1263

1264

1265

    /// The height of the bitmap.

1266

    pub fn height(&self) -> u8 {

1267

        match self {

1268

            GlyphBitmapData::Format1 {

1269

                small_metrics: SmallGlyphMetrics { height, .. },

1270

..

1271

            } => *height,

1272

            GlyphBitmapData::Format2 {

1273

                small_metrics: SmallGlyphMetrics { height, .. },

1274

..

1275

            } => *height,

1276

            GlyphBitmapData::Format5 {

1277

                big_metrics: BigGlyphMetrics { height, .. },

1278

..

1279

            } => *height,

1280

            GlyphBitmapData::Format6 {

1281

                big_metrics: BigGlyphMetrics { height, .. },

1282

..

1283

            } => *height,

1284

            GlyphBitmapData::Format7 {

1285

                big_metrics: BigGlyphMetrics { height, .. },

1286

..

1287

            } => *height,

1288

            GlyphBitmapData::Format8 {

1289

                small_metrics: SmallGlyphMetrics { height, .. },

1290

..

1291

            } => *height,

1292

            GlyphBitmapData::Format9 {

1293

                big_metrics: BigGlyphMetrics { height, .. },

1294

..

1295

            } => *height,

1296

            GlyphBitmapData::Format17 {

1297

                small_metrics: SmallGlyphMetrics { height, .. },

1298

..

1299

            } => *height,

1300

            GlyphBitmapData::Format18 {

1301

                big_metrics: BigGlyphMetrics { height, .. },

1302

..

1303

            } => *height,

1304

            GlyphBitmapData::Format19 {

1305

                big_metrics: BigGlyphMetrics { height, .. },

1306

..

1307

            } => *height,

1308

1309

1310

1311

1312

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

1313

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

1314

        match self {

1315

            GlyphBitmapData::Format1 {

1316

                small_metrics,

1317

                data,

1318

            } => f

1319

                .debug_struct("GlyphBitmapData::Format1")

1320

                .field("small_metrics", &small_metrics)

1321

                .field("data", &format_args!("[{} bytes]", data.len()))

1322

                .finish(),

1323

            GlyphBitmapData::Format2 {

1324

                small_metrics,

1325

                data,

1326

            } => f

1327

                .debug_struct("GlyphBitmapData::Format2")

1328

                .field("small_metrics", &small_metrics)

1329

                .field("data", &format_args!("[{} bytes]", data.len()))

1330

                .finish(),

1331

            GlyphBitmapData::Format5 { big_metrics, data } => f

1332

                .debug_struct("GlyphBitmapData::Format5")

1333

                .field("big_metrics", &big_metrics)

1334

                .field("data", &format_args!("[{} bytes]", data.len()))

1335

                .finish(),

1336

            GlyphBitmapData::Format6 { big_metrics, data } => f

1337

                .debug_struct("GlyphBitmapData::Format6")

1338

                .field("big_metrics", &big_metrics)

1339

                .field("data", &format_args!("[{} bytes]", data.len()))

1340

                .finish(),

1341

            GlyphBitmapData::Format7 { big_metrics, data } => f

1342

                .debug_struct("GlyphBitmapData::Format7")

1343

                .field("big_metrics", &big_metrics)

1344

                .field("data", &format_args!("[{} bytes]", data.len()))

1345

                .finish(),

1346

            GlyphBitmapData::Format8 { small_metrics, .. } => f

1347

                .debug_struct("GlyphBitmapData::Format8")

1348

                .field("small_metrics", &small_metrics)

1349

                .finish(),

1350

            GlyphBitmapData::Format9 { big_metrics, .. } => f

1351

                .debug_struct("GlyphBitmapData::Format9")

1352

                .field("big_metrics", &big_metrics)

1353

                .finish(),

1354

            GlyphBitmapData::Format17 {

1355

                small_metrics,

1356

                data,

1357

            } => f

1358

                .debug_struct("GlyphBitmapData::Format17")

1359

                .field("small_metrics", &small_metrics)

1360

                .field("data", &format_args!("[{} bytes]", data.len()))

1361

                .finish(),

1362

            GlyphBitmapData::Format18 { big_metrics, data } => f

1363

                .debug_struct("GlyphBitmapData::Format18")

1364

                .field("big_metrics", &big_metrics)

1365

                .field("data", &format_args!("[{} bytes]", data.len()))

1366

                .finish(),

1367

            GlyphBitmapData::Format19 { big_metrics, data } => f

1368

                .debug_struct("GlyphBitmapData::Format19")

1369

                .field("big_metrics", &big_metrics)

1370

                .field("data", &format_args!("[{} bytes]", data.len()))

1371

                .finish(),

1372

1373

1374

1375

1376

impl TryFrom<(&BitmapInfo, &SmallGlyphMetrics)> for EmbeddedMetrics {

1377

    type Error = ParseError;

1378

1379

    fn try_from(

1380

        (info, small_metrics): (&BitmapInfo, &SmallGlyphMetrics),

1381

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

1382

        match info.small_glyph_metrics_direction() {

1383

            MetricsDirection::Horizontal | MetricsDirection::Unknown => EmbeddedMetrics::new(

1384

                info.ppem_x,

1385

                info.ppem_y,

1386

                Some(BitmapMetrics {

1387

                    origin_offset_x: i16::from(small_metrics.bearing_x),

1388

                    // Convert from offset to the top of the image to bottom

1389

                    origin_offset_y: i16::from(small_metrics.bearing_y)

1390

                        - i16::from(small_metrics.height),

1391

                    advance: small_metrics.advance,

1392

                    ascender: info.hori.ascender,

1393

                    descender: info.hori.descender,

1394

}),

1395

                None,

1396

),

1397

            MetricsDirection::Vertical => EmbeddedMetrics::new(

1398

                info.ppem_x,

1399

                info.ppem_y,

1400

                None,

1401

                Some(BitmapMetrics {

1402

                    origin_offset_x: i16::from(small_metrics.bearing_x),

1403

                    // Convert from offset to the top of the image to bottom

1404

                    origin_offset_y: i16::from(small_metrics.bearing_y)

1405

                        - i16::from(small_metrics.height),

1406

                    advance: small_metrics.advance,

1407

                    ascender: info.vert.ascender,

1408

                    descender: info.vert.descender,

1409

}),

1410

),

1411

1412

1413

1414

1415

impl TryFrom<(&BitmapInfo, &BigGlyphMetrics)> for EmbeddedMetrics {

1416

    type Error = ParseError;

1417

1418

    fn try_from((info, big_metrics): (&BitmapInfo, &BigGlyphMetrics)) -> Result<Self, Self::Error> {

1419

        EmbeddedMetrics::new(

1420

            info.ppem_x,

1421

            info.ppem_y,

1422

            Some(BitmapMetrics {

1423

                origin_offset_x: i16::from(big_metrics.hori_bearing_x),

1424

                origin_offset_y: i16::from(big_metrics.hori_bearing_y)

1425

                    - i16::from(big_metrics.height),

1426

                advance: big_metrics.hori_advance,

1427

                ascender: info.hori.ascender,

1428

                descender: info.hori.descender,

1429

}),

1430

            Some(BitmapMetrics {

1431

                origin_offset_x: i16::from(big_metrics.vert_bearing_x),

1432

                origin_offset_y: i16::from(big_metrics.vert_bearing_y)

1433

                    - i16::from(big_metrics.height),

1434

                advance: big_metrics.vert_advance,

1435

                ascender: info.vert.ascender,

1436

                descender: info.vert.descender,

1437

}),

1438

1439

1440

1441

1442

impl BitmapInfo {

1443

    fn small_glyph_metrics_direction(&self) -> MetricsDirection {

1444

        if self.flags & HORIZONTAL_METRICS == HORIZONTAL_METRICS {

1445

            MetricsDirection::Horizontal

1446

        } else if self.flags & VERTICAL_METRICS == VERTICAL_METRICS {

1447

            MetricsDirection::Vertical

1448

        } else {

1449

            MetricsDirection::Unknown

1450

1451

1452

1453

1454

fn unpack_bit_aligned_data(

1455

    bit_depth: BitDepth,

1456

    width: u8,

1457

    height: u8,

1458

    data: &[u8],

1459

) -> Result<Vec<u8>, ParseError> {

1460

    let bits_per_row = bit_depth as usize * usize::from(width);

1461

    let whole_bytes_per_row = bits_per_row >> 3;

1462

    let remaining_bits = (bits_per_row & 7) as u8;

1463

    let bytes_per_row = whole_bytes_per_row + if remaining_bits != 0 { 1 } else { 0 };

1464

1465

    let mut offset = 0;

1466

    let mut image_data = vec![0u8; usize::from(height) * bytes_per_row];

1467

    let mut reader = BitReader::new(data);

1468

    for _ in 0..height {

1469

        // Read whole bytes, then the remainder

1470

        for byte in image_data[offset..(offset + whole_bytes_per_row)].iter_mut() {

1471

            *byte = reader.read_u8(8)?;

1472

1473

        offset += whole_bytes_per_row;

1474

        if remaining_bits != 0 {

1475

            let byte = reader.read_u8(remaining_bits)?;

1476

            image_data[offset] = byte << (8 - remaining_bits);

1477

            offset += 1;

1478

1479

1480

1481

    Ok(image_data)

1482

1483

1484

/// MSB-first bit reader for CBDT/EBDT bit-aligned glyph data.

1485

///

1486

/// Only the 1..=8 bit case is exercised by callers in this file, which

1487

/// matches the CBDT/EBDT-spec-defined range for `BitDepth` values.

1488

struct BitReader<'a> {

1489

    data: &'a [u8],

1490

    bit_pos: usize,

1491

1492

1493

impl<'a> BitReader<'a> {

1494

    fn new(data: &'a [u8]) -> Self {

1495

        BitReader { data, bit_pos: 0 }

1496

1497

1498

    /// Read `bits` bits (1..=8) as a big-endian-packed `u8`.

1499

///

1500

    /// Returns `ParseError::BadEof` if there aren't enough bits remaining.

1501

    fn read_u8(&mut self, bits: u8) -> Result<u8, ParseError> {

1502

        debug_assert!(bits <= 8);

1503

        if bits == 0 {

1504

            return Ok(0);

1505

1506

        let total_bits = self.data.len() * 8;

1507

        if self.bit_pos + usize::from(bits) > total_bits {

1508

            return Err(ParseError::BadEof);

1509

1510

1511

        let byte_index = self.bit_pos >> 3;

1512

        let bit_offset = (self.bit_pos & 7) as u32;

1513

        // Pull up to two bytes into a 16-bit window so we can shift out the

1514

        // requested run regardless of byte alignment.

1515

        let hi = u16::from(self.data[byte_index]);

1516

        let lo = if byte_index + 1 < self.data.len() {

1517

            u16::from(self.data[byte_index + 1])

1518

        } else {

1519

1520

};

1521

        let window = (hi << 8) | lo;

1522

        let shift = 16 - bit_offset - u32::from(bits);

1523

        let mask = (1u16 << bits) - 1;

1524

        let value = ((window >> shift) & mask) as u8;

1525

        self.bit_pos += usize::from(bits);

1526

        Ok(value)

1527

1528

1529

1530

fn bgra_to_rgba(bit_depth: BitDepth, mut data: Vec<u8>) -> Result<Vec<u8>, ParseError> {

1531

    match bit_depth {

1532

        BitDepth::One | BitDepth::Two | BitDepth::Four | BitDepth::Eight => Ok(data),

1533

        BitDepth::ThirtyTwo => {

1534

            if data.len() % 4 != 0 {

1535

                return Err(ParseError::BadEof);

1536

1537

            data.chunks_exact_mut(4).for_each(|chunk| chunk.swap(0, 2));

1538

            Ok(data)

1539

1540

1541

1542

1543

#[cfg(test)]

1544

mod tests {

1545

    use std::borrow::Borrow;

1546

    use std::path::Path;

1547

1548

    use super::*;

1549

    use crate::font_data::FontData;

1550

    use crate::tables::FontTableProvider;

1551

    use crate::tag;

1552

    use crate::tests::read_fixture;

1553

1554

    #[test]

1555

    fn test_parse_cblc() {

1556

        let cblc_data = read_fixture(Path::new("tests/fonts/opentype/CBLC.bin"));

1557

        let cblc = ReadScope::new(&cblc_data).read::<CBLCTable<'_>>().unwrap();

1558

1559

        let strikes = &cblc.bitmap_sizes;

1560

        assert_eq!(strikes.len(), 1);

1561

        assert_eq!(strikes[0].index_sub_tables.len(), 3);

1562

        let ranges = strikes[0]

1563

            .index_sub_table_records

1564

            .iter()

1565

            .map(|rec| rec.first_glyph_index..=rec.last_glyph_index)

1566

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

1567

        assert_eq!(ranges, &[4..=17, 19..=1316, 1354..=3112]);

1568

1569

1570

    #[test]

1571

    fn test_parse_eblc() {

1572

        let buffer = read_fixture(Path::new("tests/fonts/opentype/TerminusTTF-4.47.0.ttf"));

1573

        let scope = ReadScope::new(&buffer);

1574

        let font_file = scope

1575

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

1576

            .expect("unable to parse font file");

1577

        let table_provider = font_file

1578

            .table_provider(0)

1579

            .expect("unable to create font provider");

1580

        let table = table_provider

1581

            .table_data(tag::EBLC)

1582

            .expect("no EBLC table")

1583

            .expect("no EBLC table");

1584

        let scope = ReadScope::new(table.borrow());

1585

        let eblc = scope.read::<CBLCTable<'_>>().unwrap();

1586

1587

        let strikes = &eblc.bitmap_sizes;

1588

        assert_eq!(strikes.len(), 9);

1589

1590

1591

    #[test]

1592

    fn test_lookup_eblc() {

1593

        let buffer = read_fixture(Path::new("tests/fonts/opentype/TerminusTTF-4.47.0.ttf"));

1594

        let scope = ReadScope::new(&buffer);

1595

        let font_file = scope

1596

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

1597

            .expect("unable to parse font file");

1598

        let table_provider = font_file

1599

            .table_provider(0)

1600

            .expect("unable to create font provider");

1601

        let table = table_provider

1602

            .table_data(tag::EBLC)

1603

            .expect("no EBLC table")

1604

            .expect("no EBLC table");

1605

        let scope = ReadScope::new(table.borrow());

1606

        let eblc = scope.read::<CBLCTable<'_>>().unwrap();

1607

        let table = table_provider

1608

            .table_data(tag::EBDT)

1609

            .expect("no EBDT table")

1610

            .expect("no EBDT table");

1611

        let scope = ReadScope::new(table.borrow());

1612

        let ebdt = scope.read::<CBDTTable<'_>>().unwrap();

1613

1614

        // Font has strikes in 12 14 16 18 20 22 24 28 32 ppem

1615

        // Glyph 10 is ampersand

1616

        let strike = eblc

1617

            .find_strike(10, 30, BitDepth::ThirtyTwo)

1618

            .expect("no matching strike");

1619

        let res = strike.bitmap(&ebdt).expect("error looking up glyph");

1620

        match res {

1621

            Some(GlyphBitmapData::Format5 { data, .. }) => assert_eq!(data.len(), 64),

1622

            _ => panic!("expected GlyphBitmapData::Format5 got something else"),

1623

1624

1625

1626

    #[test]

1627

    fn test_lookup_cblc() {

1628

        // Test tables are from Noto Color Emoji

1629

        let cblc_data = read_fixture(Path::new("tests/fonts/opentype/CBLC.bin"));

1630

        let cblc = ReadScope::new(&cblc_data).read::<CBLCTable<'_>>().unwrap();

1631

        let cbdt_data = read_fixture(Path::new("tests/fonts/opentype/CBDT.bin"));

1632

        let cbdt = ReadScope::new(&cbdt_data).read::<CBDTTable<'_>>().unwrap();

1633

1634

        // Glyph 1077 is Nerd Face U+1F913

1635

        let strike = cblc

1636

            .find_strike(1077, 30, BitDepth::ThirtyTwo)

1637

            .expect("no matching strike");

1638

        let res = strike.bitmap(&cbdt).expect("error looking up glyph");

1639

        match res {

1640

            Some(GlyphBitmapData::Format17 {

1641

                data,

1642

                small_metrics: SmallGlyphMetrics { width, height, .. },

1643

            }) => {

1644

                assert_eq!((width, height), (136, 128));

1645

                assert_eq!(&data[1..4], b"PNG");

1646

1647

            _ => panic!("expected PNG data got something else"),

1648

1649

1650

        // Repeat the lookup with a lower max bit depth, should now fail to find suitable strike

1651

        assert!(cblc.find_strike(1077, 30, BitDepth::Four).is_none());

1652

1653

1654

    #[test]

1655

    fn test_unpack_bit_aligned_data() {

1656

        let data = &[0xD3, 0xAA, 0x70];

1657

        let expected = &[0xD3, 0x80, 0xA9, 0xC0];

1658

        let actual = unpack_bit_aligned_data(BitDepth::Two, 5, 2, data).unwrap();

1659

        assert_eq!(&actual, expected);

1660

1661

1662

    #[test]

1663

    fn test_bgra_to_rgba_no_change() {

1664

        let original = vec![1, 2, 3, 4, 5, 6, 7, 8];

1665

        let actual = bgra_to_rgba(BitDepth::One, original.clone()).unwrap();

1666

        assert_eq!(actual, original);

1667

1668

1669

    #[test]

1670

    fn test_bgra_to_rgba_reorder() {

1671

        let data = vec![1, 2, 3, 4, 5, 6, 7, 8];

1672

        let expected = &[3, 2, 1, 4, 7, 6, 5, 8];

1673

        let actual = bgra_to_rgba(BitDepth::ThirtyTwo, data).unwrap();

1674

        assert_eq!(&actual, expected);

1675

1676

1677

    #[test]

1678

    fn test_bgra_to_rgba_too_short() {

1679

        let data = vec![1, 2, 3, 4, 5, 6, 7];

1680

        let res = bgra_to_rgba(BitDepth::ThirtyTwo, data);

1681

        assert_eq!(res, Err(ParseError::BadEof));

1682

1683