[read-fonts] Properly compute length of delta sets

font-codegen/src/parsing.rs

@@ -288,6 +288,8 @@ pub(crate) enum CountTransform {
     DeltaSetIndexData,
     /// three args: the axis count, the tuple index, and a constant on that index
     TupleLen,
+    /// only ItemVariationStore: requires item_count, word_delta_count, region_index_count
+    ItemVariationDataLen,
 }
 
 /// Attributes for specifying how to compile a field
@@ -1396,6 +1398,10 @@ static TRANSFORM_IDENTS: &[(CountTransform, &str)] = &[
     (CountTransform::DeltaValueCount, "delta_value_count"),
     (CountTransform::DeltaSetIndexData, "delta_set_index_data"),
     (CountTransform::TupleLen, "tuple_len"),
+    (
+        CountTransform::ItemVariationDataLen,
+        "item_variation_data_len",
+    ),
 ];
 
 impl FromStr for CountTransform {
@@ -1428,6 +1434,7 @@ impl CountTransform {
             CountTransform::DeltaValueCount => 3,
             CountTransform::DeltaSetIndexData => 2,
             CountTransform::TupleLen => 3,
+            CountTransform::ItemVariationDataLen => 3,
         }
     }
 }
@@ -1561,6 +1568,9 @@ impl Count {
                 (CountTransform::TupleLen, [a, b, c]) => {
                     quote!(TupleIndex::tuple_len(#a, #b, #c))
                 }
+                (CountTransform::ItemVariationDataLen, [a, b, c]) => {
+                    quote!(ItemVariationData::delta_sets_len(#a, #b, #c))
+                }
                 _ => unreachable!("validated before now"),
             },
         }

read-fonts/generated/generated_variations.rs

@@ -1137,12 +1137,14 @@ impl ItemVariationDataMarker {
 impl<'a> FontRead<'a> for ItemVariationData<'a> {
     fn read(data: FontData<'a>) -> Result<Self, ReadError> {
         let mut cursor = data.cursor();
-        cursor.advance::<u16>();
-        cursor.advance::<u16>();
+        let item_count: u16 = cursor.read()?;
+        let word_delta_count: u16 = cursor.read()?;
         let region_index_count: u16 = cursor.read()?;
         let region_indexes_byte_len = region_index_count as usize * u16::RAW_BYTE_LEN;
         cursor.advance_by(region_indexes_byte_len);
-        let delta_sets_byte_len = cursor.remaining_bytes() / u8::RAW_BYTE_LEN * u8::RAW_BYTE_LEN;
+        let delta_sets_byte_len =
+            ItemVariationData::delta_sets_len(item_count, word_delta_count, region_index_count)
+                * u8::RAW_BYTE_LEN;
         cursor.advance_by(delta_sets_byte_len);
         cursor.finish(ItemVariationDataMarker {
             region_indexes_byte_len,

read-fonts/src/tables/variations.rs

@@ -981,24 +981,39 @@ impl<'a> ItemVariationData<'a> {
     /// inner index.
     pub fn delta_set(&self, inner_index: u16) -> impl Iterator<Item = i32> + 'a + Clone {
         let word_delta_count = self.word_delta_count();
+        let region_count = self.region_index_count();
+        let bytes_per_row = Self::delta_row_len(word_delta_count, region_count);
         let long_words = word_delta_count & 0x8000 != 0;
-        let (word_size, small_size) = if long_words { (4, 2) } else { (2, 1) };
         let word_delta_count = word_delta_count & 0x7FFF;
-        let region_count = self.region_index_count() as usize;
-        let row_size = word_delta_count as usize * word_size
-            + region_count.saturating_sub(word_delta_count as usize) * small_size;
-        let offset = row_size * inner_index as usize;
+
+        let offset = bytes_per_row * inner_index as usize;
         ItemDeltas {
             cursor: FontData::new(self.delta_sets())
                 .slice(offset..)
                 .unwrap_or_default()
                 .cursor(),
             word_delta_count,
             long_words,
-            len: region_count as u16,
+            len: region_count,
             pos: 0,
         }
     }
+
+    /// the length of one delta set
+    fn delta_row_len(word_delta_count: u16, region_index_count: u16) -> usize {
+        let region_count = region_index_count as usize;
+        let long_words = word_delta_count & 0x8000 != 0;
+        let (word_size, small_size) = if long_words { (4, 2) } else { (2, 1) };
+        let long_delta_count = (word_delta_count & 0x7FFF) as usize;
+        let short_delta_count = region_count.saturating_sub(long_delta_count);
+        long_delta_count * word_size + short_delta_count * small_size
+    }
+
+    // called from generated code: compute the length in bytes of the delta_sets data
+    fn delta_sets_len(item_count: u16, word_delta_count: u16, region_index_count: u16) -> usize {
+        let bytes_per_row = Self::delta_row_len(word_delta_count, region_index_count);
+        bytes_per_row * item_count as usize
+    }
 }
 
 #[derive(Clone)]
@@ -1062,7 +1077,7 @@ pub(crate) fn item_delta(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{FontRef, TableProvider};
+    use crate::{test_helpers::BeBuffer, FontRef, TableProvider};
 
     #[test]
     fn ivs_regions() {
@@ -1258,4 +1273,34 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn ivs_data_len_short() {
+        let data = BeBuffer::new()
+            .push(2u16) // item_count
+            .push(3u16) // word_delta_count
+            .push(5u16) // region_index_count
+            .extend([0u16, 1, 2, 3, 4]) // region_indices
+            .extend([1u8; 128]); // this is much more data than we need!
+
+        let ivs = ItemVariationData::read(data.font_data()).unwrap();
+        let row_len = (3 * u16::RAW_BYTE_LEN) + (2 * u8::RAW_BYTE_LEN); // 3 word deltas, 2 byte deltas
+        let expected_len = 2 * row_len;
+        assert_eq!(ivs.delta_sets().len(), expected_len);
+    }
+
+    #[test]
+    fn ivs_data_len_long() {
+        let data = BeBuffer::new()
+            .push(2u16) // item_count
+            .push(2u16 | 0x8000) // word_delta_count, long deltas
+            .push(4u16) // region_index_count
+            .extend([0u16, 1, 2]) // region_indices
+            .extend([1u8; 128]); // this is much more data than we need!
+
+        let ivs = ItemVariationData::read(data.font_data()).unwrap();
+        let row_len = (2 * u32::RAW_BYTE_LEN) + (2 * u16::RAW_BYTE_LEN); // 1 word (4-byte) delta, 2 short (2-byte)
+        let expected_len = 2 * row_len;
+        assert_eq!(ivs.delta_sets().len(), expected_len);
+    }
 }

resources/codegen_inputs/variations.rs

@@ -156,7 +156,7 @@ table ItemVariationData {
     #[count($region_index_count)]
     region_indexes: [u16],
     /// Delta-set rows.
-    #[count(..)]
+    #[count(item_variation_data_len($item_count, $word_delta_count, $region_index_count))]
     delta_sets: [u8],
 }