libextractor

gen_heif_testdata.sh (7116B)

---

 #!/bin/sh
 # This file is part of libextractor.
 # Copyright (C) 2026 Vidyut Samanta and Christian Grothoff
 #
 # Generate the test data for the "heif" plugin:
 #
 #   src/plugins/testdata/heif_test.heic
 #   src/plugins/testdata/heif_test.avif
 #
 # Both files are hand-constructed ISO base media file format containers.
 # They are structurally conformant HEIF/AVIF files -- the box tree, the
 # item structures and the property associations are exactly what the
 # specifications call for -- but the 'mdat' payload is a placeholder
 # rather than a real HEVC or AV1 bitstream, so they identify but do not
 # decode.  That is deliberate: the plugin is a container parser, the
 # values it must report are known exactly, and no encoder is needed.
 #
 # Needs: python3 (no third party modules).  Deterministic: no
 # timestamps, no random data.
 #
 # Written to CC0; there is no third party content in these files.
 #
 # Usage: contrib/gen_heif_testdata.sh [output-directory]
 
 set -e
 
 OUT="${1:-src/plugins/testdata}"
 mkdir -p "$OUT"
 
 python3 - "$OUT" <<'EOF'
 import struct
 import sys
 
 out = sys.argv[1]
 
 
 def box(btype, payload):
     """A plain ISO-BMFF box: 32-bit size, 4CC type, payload."""
     assert len(btype) == 4
     return struct.pack('>I', 8 + len(payload)) + btype.encode('ascii') + payload
 
 
 def fullbox(btype, version, flags, payload):
     """A FullBox: a box whose payload starts with version and flags."""
     return box(btype, bytes([version]) + struct.pack('>I', flags)[1:] + payload)
 
 
 def ftyp(major, brands):
     return box('ftyp',
                major.encode('ascii')
                + struct.pack('>I', 0)
                + b''.join(b.encode('ascii') for b in brands))
 
 
 def hdlr(handler):
     return fullbox('hdlr', 0, 0,
                    struct.pack('>I', 0)
                    + handler.encode('ascii')
                    + b'\0' * 12
                    + b'libextractor test\0')
 
 
 def pitm(item_id):
     return fullbox('pitm', 0, 0, struct.pack('>H', item_id))
 
 
 def infe(item_id, item_type, name):
     """ItemInfoEntry version 2: 16-bit item_ID, then the item_type."""
     return fullbox('infe', 2, 0,
                    struct.pack('>HH', item_id, 0)
                    + item_type.encode('ascii')
                    + name.encode('ascii') + b'\0')
 
 
 def iinf(entries):
     return fullbox('iinf', 0, 0,
                    struct.pack('>H', len(entries)) + b''.join(entries))
 
 
 def iref_thmb(from_id, to_id):
     return fullbox('iref', 0, 0,
                    box('thmb', struct.pack('>HHH', from_id, 1, to_id)))
 
 
 def ispe(width, height):
     return fullbox('ispe', 0, 0, struct.pack('>II', width, height))
 
 
 def pixi(depths):
     return fullbox('pixi', 0, 0, bytes([len(depths)]) + bytes(depths))
 
 
 def irot(quarter_turns):
     """ImageRotation: anti-clockwise quarter turns, 0..3."""
     return box('irot', bytes([quarter_turns & 0x03]))
 
 
 def imir(axis):
     """ImageMirror: 0 mirrors about a vertical axis, 1 about a horizontal one."""
     return box('imir', bytes([axis & 0x01]))
 
 
 def colr_nclx(primaries, transfer, matrix, full_range):
     return box('colr',
                b'nclx'
                + struct.pack('>HHH', primaries, transfer, matrix)
                + bytes([0x80 if full_range else 0x00]))
 
 
 def av1c(high_bitdepth, twelve_bit, monochrome):
     """AV1CodecConfigurationBox, the four byte fixed part."""
     flags = (high_bitdepth << 6) | (twelve_bit << 5) | (monochrome << 4) | 0x0C
     return box('av1C', bytes([0x81, 0x00, flags, 0x00]))
 
 
 def hvcc():
     """A minimal HEVCDecoderConfigurationRecord shell (no parameter sets)."""
     return box('hvcC',
                bytes([0x01, 0x01, 0x60, 0x00, 0x00, 0x00,
                       0x90, 0x00, 0x00, 0x00, 0x00, 0x00,
                       0x3C, 0xF0, 0x00, 0xFC, 0xFD, 0xF8,
                       0xF8, 0x00, 0x00, 0x0F, 0x00]))
 
 
 def ipma(entries):
     """ItemPropertyAssociation with 16-bit item IDs and 7-bit indices."""
     payload = struct.pack('>I', len(entries))
     for item_id, props in entries:
         payload += struct.pack('>HB', item_id, len(props))
         for essential, index in props:
             assert 0 < index < 0x80
             payload += bytes([(0x80 if essential else 0x00) | index])
     return fullbox('ipma', 0, 0, payload)
 
 
 def iprp(props, assoc):
     return box('iprp', box('ipco', b''.join(props)) + ipma(assoc))
 
 
 def meta(children):
     return fullbox('meta', 0, 0, b''.join(children))
 
 
 def mdat(nbytes):
     """A placeholder for the coded data; never read by the plugin."""
     return box('mdat', bytes((i * 7 + 3) & 0xFF for i in range(nbytes)))
 
 
 # ---------------------------------------------------------------- HEIC
 #
 # Major brand 'heic', so the MIME type and the HEVC codec follow from
 # the brand alone.  Three items: the primary image (id 1), a thumbnail
 # (id 2, tied to the primary by an 'iref' of type 'thmb') and an Exif
 # metadata item (id 3).
 #
 # The property container deliberately holds the *thumbnail's* 'ispe'
 # first: a parser that simply reports the first 'ispe' it finds says
 # 16x12, and only one that follows the 'ipma' association for the
 # primary item reports the true 96x64.
 heic_props = [
     ispe(16, 12),                       # 1: the thumbnail's extent
     ispe(96, 64),                       # 2: the primary item's extent
     pixi([10, 10, 10]),                 # 3: 10 bit, i.e. an HDR capture
     irot(1),                            # 4: 90 degrees anti-clockwise
     colr_nclx(9, 16, 9, True),          # 5: BT.2020 with the PQ curve
     imir(0),                            # 6: mirrored left to right
     hvcc(),                             # 7
 ]
 heic_assoc = [
     (1, [(False, 2), (False, 3), (True, 4), (False, 5), (True, 6),
          (True, 7)]),
     (2, [(False, 1)]),
 ]
 heic = (ftyp('heic', ['mif1', 'heic', 'miaf', 'MiHB'])
         + meta([hdlr('pict'),
                 pitm(1),
                 iinf([infe(1, 'hvc1', 'primary'),
                       infe(2, 'hvc1', 'thumb'),
                       infe(3, 'Exif', 'exif')]),
                 iref_thmb(2, 1),
                 iprp(heic_props, heic_assoc)])
         + mdat(512))
 
 # ---------------------------------------------------------------- AVIF
 #
 # Major brand 'mif1' with 'avif' among the compatible brands, which is
 # what several AVIF writers emit and what forces a reader to look past
 # the major brand.  One image item, no 'pixi', so the bit depth has to
 # come from the 'av1C' configuration record.
 avif_props = [
     ispe(128, 72),                      # 1
     av1c(0, 0, 0),                      # 2: 8 bit, colour
     colr_nclx(1, 13, 6, True),          # 3: BT.709 primaries, sRGB curve
 ]
 avif_assoc = [
     (1, [(False, 1), (True, 2), (False, 3)]),
 ]
 avif = (ftyp('mif1', ['mif1', 'miaf', 'MA1B', 'avif'])
         + meta([hdlr('pict'),
                 pitm(1),
                 iinf([infe(1, 'av01', 'primary')]),
                 iprp(avif_props, avif_assoc)])
         + mdat(384))
 
 for name, data in (('heif_test.heic', heic), ('heif_test.avif', avif)):
     path = out + '/' + name
     with open(path, 'wb') as f:
         f.write(data)
     print('%s: %d bytes' % (path, len(data)))
 EOF