Add code

mp4muxer_alac.py

@@ -0,0 +1,809 @@
+from datetime import datetime
+from tags import Tags
+
+
+def dt_to_unix_ts(ts: datetime) -> int:
+    return int(ts.timestamp())
+
+
+def dt_to_mp4_ts(ts: datetime) -> int:
+    return int(ts.timestamp()) + 2082844800
+
+
+def s2b(s: str):
+    return bytearray(s.encode("ascii"))
+
+
+def i2b(i: int, size: int = 4):
+    return bytearray(i.to_bytes(size, "big"))
+
+
+class MP4MuxerALAC:
+    def __init__(self) -> None:
+        self.data: bytearray = bytearray()
+        self.timestamp: datetime = datetime.now()
+        self.sample_rate: int = 0
+        self.number_of_samples: int = 0
+        self.bit_depth: int = 0
+        self.samples_per_frame: int = 4096
+        self.channel_count: int = 2
+        self.sample_sizes: list[int] = []
+        # these are the only important ones
+        self.offsets: dict = {
+            "stco": 0,
+            "mdat": 0,
+        }
+
+        self.total_duration: int = 0
+        self.mdat_data: bytearray = bytearray()
+        self.tags: Tags = None
+
+    def create(self) -> None:
+        self.ftyp()
+        self.moov()
+        self.free()
+        self.mdat()
+        self.rewrite_stco_chunk()
+
+    def out(self, filename: str) -> None:
+        with open(filename, "wb") as f:
+            f.write(self.data)
+
+    def w(self, b: bytearray):
+        if isinstance(b, bytes):
+            b = bytearray(b)
+        self.data.extend(b)
+
+    def set_sample_rate(self, sr: int) -> None:
+        self.sample_rate = sr
+
+    def set_number_of_samples(self, nr: int) -> None:
+        self.number_of_samples = nr
+
+    def set_bit_depth(self, bd: int) -> None:
+        self.bit_depth = bd
+
+    def set_sample_sizes(self, ss: int) -> None:
+        self.sample_sizes = ss
+
+    def set_total_duration(self, td: int) -> None:
+        self.total_duration = td
+
+    def set_mdat_data(self, m: bytearray) -> None:
+        self.mdat_data = m
+
+    def set_tags(self, t: Tags) -> None:
+        self.tags = t
+
+    def set_timestamp(self, t: datetime) -> None:
+        self.timestamp = t
+
+    def ftyp(self) -> None:
+        major_brand: str = "M4A "
+        minor_version: int = 0
+        compatible_brands: list[str] = ["M4A ", "mp42", "isom"]
+        size: int = 16 + (len(compatible_brands) * 4)
+
+        self.w(i2b(size))
+        self.w(s2b("ftyp"))
+        self.w(s2b(major_brand))
+        self.w(i2b(minor_version))
+        for c in compatible_brands:
+            self.w(s2b(c))
+
+    def moov_size(self) -> int:
+        total_size: int = 8
+        total_size += self.mvhd_size()
+        total_size += self.trak_size()
+        if self.tags:
+            total_size += self.udta_size()
+        return total_size
+
+    def moov(self) -> None:
+        self.w(i2b(self.moov_size()))
+        self.w(s2b("moov"))
+        self.mvhd()
+        self.trak()
+        if self.tags:
+            self.udta()
+
+    def mvhd_size(self) -> int:
+        return 108
+
+    def mvhd(self) -> None:
+        version: int = 0
+        creation_time: datetime = self.timestamp
+        modification_time: datetime = self.timestamp
+        time_scale: int = self.sample_rate
+        duration: int = self.total_duration
+        rate: int = 0x10000  # 1.0
+        volume: int = 0x100  # 1.0
+        next_track_id: int = 2
+
+        self.w(i2b(self.mvhd_size()))
+        self.w(s2b("mvhd"))
+        self.w(i2b(version))
+        self.w(i2b(dt_to_mp4_ts(creation_time)))
+        self.w(i2b(dt_to_mp4_ts(modification_time)))
+        self.w(i2b(time_scale))
+        self.w(i2b(duration))
+        self.w(i2b(rate))
+        self.w(i2b(volume, 2))
+
+        # const bit(16) reserved = 0
+        self.w(i2b(0, 2))
+        # const unsigned int(32)[2] reserved = 0
+        self.w(i2b(0, 8))
+        # template int(32)[9] matrix
+        # { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 }
+        self.w(i2b(0x10000))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0x10000))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0x40000000))
+        # Unity matrix
+        # bit(32)[6] pre_defined = 0
+        self.w(i2b(0, 24))
+        self.w(i2b(next_track_id))
+
+    def trak_size(self) -> int:
+        total_size: int = 8
+        total_size += self.tkhd_size()
+        total_size += self.mdia_size()
+        return total_size
+
+    def trak(self) -> None:
+        self.w(i2b(self.trak_size()))
+        self.w(s2b("trak"))
+        self.tkhd()
+        self.mdia()
+
+    def tkhd_size(self) -> int:
+        return 92
+
+    def tkhd(self) -> None:
+        flags: int = 1
+        creation_time: datetime = self.timestamp
+        modification_time: datetime = self.timestamp
+        track_id: int = 1
+        duration: int = self.total_duration
+        layer: int = 0
+        alternate_group: int = 0
+        volume: int = 0x100  # 1.0
+        width: int = 0
+        height: int = 0
+
+        self.w(i2b(self.tkhd_size()))
+        self.w(s2b("tkhd"))
+
+        self.w(i2b(flags))
+        self.w(i2b(dt_to_mp4_ts(creation_time)))
+        self.w(i2b(dt_to_mp4_ts(modification_time)))
+        self.w(i2b(track_id))
+
+        # const unsigned int (32) reserved = 0
+        self.w(i2b(0))
+        self.w(i2b(duration))
+        # reserved
+        self.w(i2b(0))
+        # const unsigned int (32) [2] reserved = 0
+        self.w(i2b(0))
+        self.w(i2b(layer, 2))
+        self.w(i2b(alternate_group, 2))
+        # template int (16) volume = {if track_is_audio 0x0100 else 0}
+        self.w(i2b(volume, 2))
+        # const unsigned int (16) reserved = 0
+        self.w(i2b(0, 2))
+        # template int (32) [9] matrix
+        # { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 }
+        self.w(i2b(0x10000))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0x10000))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0))
+        self.w(i2b(0x40000000))
+        # Unity matrix
+        # unsigned int (32) width
+        self.w(i2b(width))
+        # unsigned int (32) height
+        self.w(i2b(height))
+
+    def mdia_size(self) -> int:
+        total_size: int = 8
+        total_size += self.mdhd_size()
+        total_size += self.hdlr_size()
+        total_size += self.minf_size()
+        return total_size
+
+    def mdia(self) -> None:
+        self.w(i2b(self.mdia_size()))
+        self.w(s2b("mdia"))
+        self.mdhd()
+        self.hdlr()
+        self.minf()
+
+    def mdhd_size(self) -> int:
+        return 32
+
+    def mdhd(self) -> None:
+        version: int = 0
+        flags: int = 0
+        creation_time: datetime = self.timestamp
+        modification_time: datetime = self.timestamp
+        time_scale: int = self.sample_rate
+        duration: int = self.total_duration
+        language: int = 0x55C4  # undefined
+        quality: int = 0
+
+        self.w(i2b(self.mdhd_size()))
+        self.w(s2b("mdhd"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(dt_to_mp4_ts(creation_time)))
+        self.w(i2b(dt_to_mp4_ts(modification_time)))
+        self.w(i2b(time_scale))
+        self.w(i2b(duration))
+        self.w(i2b(language, 2))
+        self.w(i2b(quality, 2))
+
+    def hdlr_size(self) -> int:
+        return 32
+
+    def hdlr(self) -> None:
+        version: int = 0
+        flags: int = 0
+        component_type = "mhlr"  # media handler
+        component_subtype = "soun"
+        component_name = 0
+        component_flags = 0
+        component_flags_mask = 0
+
+        self.w(i2b(self.hdlr_size()))
+        self.w(s2b("hdlr"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(s2b(component_type))
+        self.w(s2b(component_subtype))
+        self.w(i2b(component_name))
+        self.w(i2b(component_flags))
+        self.w(i2b(component_flags_mask))
+
+    def minf_size(self) -> int:
+        total_size: int = 8
+        total_size += self.smhd_size()
+        total_size += self.dinf_size()
+        total_size += self.stbl_size()
+        return total_size
+
+    def minf(self) -> None:
+        self.w(i2b(self.minf_size()))
+        self.w(s2b("minf"))
+        self.smhd()
+        self.dinf()
+        self.stbl()
+
+    def smhd_size(self) -> int:
+        return 16
+
+    def smhd(self) -> None:
+        version: int = 0
+        flags: int = 0
+        audio_balance: int = 0
+
+        self.w(i2b(self.smhd_size()))
+        self.w(s2b("smhd"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(audio_balance, 2))
+        self.w(i2b(0, 2))  # reserved
+
+    def dinf_size(self) -> int:
+        total_size: int = 8
+        total_size += self.dref_size()
+        return total_size
+
+    def dinf(self) -> None:
+        self.w(i2b(self.dinf_size()))
+        self.w(s2b("dinf"))
+        self.dref()
+        pass
+
+    def dref_size(self) -> int:
+        return 28
+
+    def dref(self) -> None:
+        version: int = 0
+        flags: int = 0
+        entry_count: int = 1
+        self.w(i2b(self.dref_size()))
+        self.w(s2b("dref"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(entry_count))
+
+        data_location_size: int = 12
+        data_location_name: str = "url "
+        data_location_version: int = 0
+        data_location_flags: int = 1  # same file
+
+        self.w(i2b(data_location_size))
+        self.w(s2b(data_location_name))
+        self.w(i2b(data_location_version, 1))
+        self.w(i2b(data_location_flags, 3))
+
+    def stbl_size(self) -> int:
+        total_size: int = 8
+        total_size += self.stsd_size()
+        total_size += self.stts_size()
+        total_size += self.stsz_size()
+        total_size += self.stsc_size()
+        total_size += self.stco_size()
+        return total_size
+
+    def stbl(self) -> None:
+        self.w(i2b(self.stbl_size()))
+        self.w(s2b("stbl"))
+        self.stsd()
+        self.stts()
+        self.stsz()
+        self.stsc()
+        self.stco()
+
+    def stsd_size(self) -> int:
+        return 88
+
+    def stsd(self) -> None:
+        version: int = 0
+        flags: int = 0
+        count: int = 1
+        audio_size: int = 72
+        audio_name: str = "alac"
+        channel_count: int = self.channel_count
+        sample_size: int = self.bit_depth
+        sample_rate: int = self.sample_rate
+        samples_per_frame: int = self.samples_per_frame
+        max_coded_frame_size: int = max(self.sample_sizes)
+
+        self.w(i2b(self.stsd_size()))
+        self.w(s2b("stsd"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(count))
+        self.w(i2b(audio_size))
+        self.w(s2b(audio_name))
+        self.w(i2b(0, 6))  # reserved
+        self.w(i2b(1, 2))  # data reference index
+        self.w(i2b(0))  # reserved
+        self.w(i2b(0))  # reserved
+        self.w(i2b(channel_count, 2))
+        self.w(i2b(sample_size, 2))
+        self.w(i2b(0, 2))  # pre-defined
+        self.w(i2b(0, 2))  # reserved
+        if sample_rate <= 65535:
+            self.w(i2b(sample_rate, 2))
+        else:
+            self.w(i2b(0, 2))
+        self.w(i2b(0, 2))  # sample rate (again? set to zero for some reason)
+        # magic cookie starts here
+        self.w(i2b(36))  # size
+        self.w(s2b("alac"))
+        self.w(i2b(0))  # reserved
+        self.w(i2b(samples_per_frame))
+        self.w(i2b(0, 1))  # reserved
+        self.w(i2b(sample_size, 1))
+        self.w(i2b(40, 1))  # rice history mult, pb, tuning parameter
+        self.w(i2b(10, 1))  # rice initial history, mb, tuning parameter
+        self.w(i2b(14, 1))  # rice kmodifier, kb, tuning parameter
+        self.w(i2b(channel_count, 1))
+        self.w(i2b(255, 2))  # maxRun, currently unused
+        self.w(i2b(max_coded_frame_size))
+
+        self.w(i2b(self.sample_rate * self.bit_depth * self.channel_count))  # bitrate
+        self.w(i2b(sample_rate))
+
+    def stts_size(self) -> int:
+        total_size: int = 16
+        # size of the stts box depends on the number of entries
+        number_of_entries: int = 2
+        if self.total_duration % self.samples_per_frame == 0:
+            number_of_entries = 1
+        total_size += 8 * number_of_entries
+        return total_size
+
+    def stts(self) -> None:
+        version: int = 0
+        flags: int = 0
+        number_of_entries: int = 2
+        if self.total_duration % self.samples_per_frame == 0:
+            number_of_entries = 1
+        self.w(i2b(self.stts_size()))
+        self.w(s2b("stts"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(number_of_entries))
+
+        if number_of_entries == 1:
+            self.w(i2b(len(self.sample_sizes)))
+            self.w(i2b(self.samples_per_frame))
+        elif number_of_entries == 2:
+            self.w(i2b(len(self.sample_sizes) - 1))
+            self.w(i2b(self.samples_per_frame))
+            self.w(i2b(1))
+            self.w(i2b(self.total_duration % self.samples_per_frame))
+
+    def stsz_size(self) -> int:
+        total_size: int = 20
+        total_size += 4 * len(self.sample_sizes)
+        return total_size
+
+    def stsz(self) -> None:
+        version: int = 0
+        flags: int = 0
+        sample_size: int = 0
+        sample_count: int = len(self.sample_sizes)
+
+        self.w(i2b(self.stsz_size()))
+        self.w(s2b("stsz"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(sample_size))
+        self.w(i2b(sample_count))
+
+        for s in self.sample_sizes:
+            self.w(i2b(s))
+
+    def stsc_size(self) -> int:
+        number_of_entries: int = 1
+        entries_per_second: int = int(round(self.sample_rate / 4096))
+        last_entry: int = len(self.sample_sizes) % entries_per_second
+        if last_entry != 0:
+            number_of_entries = 2
+
+        total_size: int = 16 + (number_of_entries * 12)
+        return total_size
+
+    # we only write a single chunk
+    # not sure what the side effects of this move are
+    def stsc(self) -> None:
+        version: int = 0
+        flags: int = 0
+        number_of_entries: int = 1
+        entries_per_second: int = int(round(self.sample_rate / 4096))
+        last_entry: int = len(self.sample_sizes) % entries_per_second
+        first_chunk_count = int(
+            (len(self.sample_sizes) - last_entry) / entries_per_second
+        )
+        entries = []
+        entries.append(
+            {
+                "first_chunk": 1,
+                "samples_per_chunk": entries_per_second,
+                "sample_description_index": 1,
+            }
+        )
+        if last_entry != 0:
+            number_of_entries = 2
+            entries.append(
+                {
+                    "first_chunk": first_chunk_count + 1,
+                    "samples_per_chunk": last_entry,
+                    "sample_description_index": 1,
+                }
+            )
+
+        self.w(i2b(self.stsc_size()))
+        self.w(s2b("stsc"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(number_of_entries))
+
+        for s in entries:
+            first_chunk: int = s["first_chunk"]
+            samples_per_chunk: int = s["samples_per_chunk"]
+            sample_description_index: int = s["sample_description_index"]
+            self.w(i2b(first_chunk))
+            self.w(i2b(samples_per_chunk))
+            self.w(i2b(sample_description_index))
+
+    def stco_size(self) -> int:
+        total_size: int = 16
+        entries_per_second: int = int(round(self.sample_rate / 4096))
+        last_entry: int = len(self.sample_sizes) % entries_per_second
+        first_chunk_count = int(
+            (len(self.sample_sizes) - last_entry) / entries_per_second
+        )
+        number_of_stco_entries = first_chunk_count
+        if last_entry != 0:
+            number_of_stco_entries += 1
+        total_size += 4 * number_of_stco_entries
+        return total_size
+
+    def stco(self) -> None:
+        version: int = 0
+        flags: int = 0
+        self.offsets["stco"] = len(self.data)
+        entries_per_second: int = int(round(self.sample_rate / 4096))
+        last_entry: int = len(self.sample_sizes) % entries_per_second
+        first_chunk_count = int(
+            (len(self.sample_sizes) - last_entry) / entries_per_second
+        )
+        number_of_stco_entries = first_chunk_count
+        if last_entry != 0:
+            number_of_stco_entries += 1
+
+        self.w(i2b(self.stco_size()))
+        self.w(s2b("stco"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+
+        self.w(i2b(number_of_stco_entries))
+
+        for s in range(number_of_stco_entries):
+            self.w(i2b(0xFFFFFFFF))  # placeholder value
+
+    def free(self) -> None:
+        self.w(i2b(8))
+        self.w(s2b("free"))
+
+    def mdat(self) -> None:
+        self.offsets["mdat"] = len(self.data)
+        self.w(i2b(8 + len(self.mdat_data)))
+        self.w(s2b("mdat"))
+        self.w(self.mdat_data)
+
+    def rewrite_stco_chunk(self) -> None:
+        stco_pos: int = self.offsets["stco"] + 16
+        first_chunk_offset: int = self.offsets["mdat"] + 8
+        entries_per_second: int = int(round(self.sample_rate / 4096))
+        last_entry: int = len(self.sample_sizes) % entries_per_second
+        first_chunk_count = int(
+            (len(self.sample_sizes) - last_entry) / entries_per_second
+        )
+        number_of_stco_entries = first_chunk_count
+        if last_entry != 0:
+            number_of_stco_entries += 1
+
+        for s in range(number_of_stco_entries):
+            bytes_to_write = i2b(
+                first_chunk_offset + (sum(self.sample_sizes[: entries_per_second * s]))
+            )
+            for index, b in enumerate(bytes_to_write):
+                self.data[stco_pos + (s * 4) + index] = b
+
+    def udta_size(self) -> int:
+        return 8 + self.meta_size()
+
+    def udta(self) -> None:
+        self.w(i2b(self.udta_size()))
+        self.w(s2b("udta"))
+        self.meta()
+
+    def meta_size(self) -> int:
+        total_size: int = 12
+        total_size += self.meta_hdlr_size()
+        total_size += self.ilst_size()
+        return total_size
+
+    def meta(self) -> None:
+        version: int = 0
+        flags: int = 0
+
+        self.w(i2b(self.meta_size()))
+        self.w(s2b("meta"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+
+        self.meta_hdlr()
+        self.ilst()
+
+    def meta_hdlr_size(self) -> int:
+        return 33
+
+    def meta_hdlr(self) -> None:
+        version: int = 0
+        flags: int = 0
+        type_quicktime: int = 0
+        metadata_type: str = "mdir"
+        manufacturer: str = "appl"
+        component_reserved_flags: int = 0
+        component_reserved_flags_mask: int = 0
+        component_type_name: int = 0
+
+        self.w(i2b(self.meta_hdlr_size()))
+        self.w(s2b("hdlr"))
+        self.w(i2b(version, 1))
+        self.w(i2b(flags, 3))
+        self.w(i2b(type_quicktime))
+        self.w(s2b(metadata_type))
+        self.w(s2b(manufacturer))
+        self.w(i2b(component_reserved_flags))
+        self.w(i2b(component_reserved_flags_mask))
+        self.w(i2b(component_type_name, 1))
+
+    def ilst_size(self) -> int:
+        total_size: int = 8
+        if self.tags.track_name:
+            total_size += 24 + len(self.tags.track_name.encode("utf-8"))
+        if self.tags.artist:
+            total_size += 24 + len(self.tags.artist.encode("utf-8"))
+        if self.tags.album_artist:
+            total_size += 24 + len(self.tags.album_artist.encode("utf-8"))
+        if self.tags.composer:
+            total_size += 24 + len(self.tags.composer.encode("utf-8"))
+        if self.tags.album_name:
+            total_size += 24 + len(self.tags.album_name.encode("utf-8"))
+        if self.tags.genre:
+            total_size += 24 + len(self.tags.genre.encode("utf-8"))
+        if self.tags.date:
+            total_size += 24 + len(self.tags.date.encode("utf-8"))
+        if self.tags.isrc:
+            total_size += 24 + len(self.tags.isrc.encode("utf-8"))
+        if self.tags.copyright:
+            total_size += 24 + len(self.tags.copyright.encode("utf-8"))
+        if self.tags.track_number or self.tags.total_number_of_tracks:
+            total_size += 32
+        if self.tags.disc_number or self.tags.total_number_of_discs:
+            total_size += 32
+        if self.tags.upc:
+            total_size += len(self.tags.upc.encode("utf-8")) + 64 + len("UPC")
+        if self.tags.label:
+            total_size += len(self.tags.label.encode("utf-8")) + 64 + len("LABEL")
+        if self.tags.apple_store_catalog_id:
+            total_size += 28
+        if self.tags.playlist_id:
+            total_size += 28
+        if self.tags.album_title_id:
+            total_size += 28
+        if self.tags.cover_data:
+            total_size += 24 + len(self.tags.cover_data)
+        return total_size
+
+    def write_mp4_tag_utf8(self, box: bytes, content: str):
+        b: bytearray = bytearray(content.encode("utf-8"))
+        data_size: int = len(b) + 16
+        self.w(i2b(data_size + 8))
+        self.w(box)
+        self.w(i2b(data_size))
+        self.w(s2b("data"))
+        # 0 = binary; 1 = utf-8
+        kind: int = 1
+        language: int = 0
+        self.w(i2b(kind))
+        self.w(i2b(language))
+        self.w(b)
+
+    def write_mp4_tag_int(self, box: bytes, content: int):
+        kind: int = 21  # signed integer
+        language: int = 0
+        size: int = 24 + len(box)
+        self.w(i2b(size))
+        self.w(box)
+        size -= 8
+        self.w(i2b(size))
+        self.w(s2b("data"))
+        self.w(i2b(kind))
+        self.w(i2b(language))
+        self.w(i2b(content))
+
+    def write_itunes_tag_utf8(self, box: str, content: str):
+        b: bytearray = bytearray(content.encode("utf-8"))
+        full_size: int = len(b) + 64 + len(box)
+        self.w(i2b(full_size))
+        self.w(s2b("----"))
+        mean_size: int = 28
+        self.w(i2b(mean_size))
+        self.w(s2b("mean"))
+        self.w(i2b(0))  # unknown
+        self.w(s2b("com.apple.iTunes"))
+        name_size: int = 12 + len(box)
+        self.w(i2b(name_size))
+        self.w(s2b("name"))
+        self.w(i2b(0))  # unknown
+        self.w(s2b(box))
+        data_size = len(b) + 16
+        self.w(i2b(data_size))
+        self.w(s2b("data"))
+        # 0 = binary; 1 = utf-8
+        kind: int = 1
+        language: int = 0
+        self.w(i2b(kind))
+        self.w(i2b(language))
+        self.w(b)
+
+    def write_mp4_tag_tuple_int(self, box: bytes, curr: int, total: int):
+        self.w(i2b(32))  # size
+        self.w(box)
+        self.w(i2b(24))  # data size
+        self.w(s2b("data"))
+        kind: int = 0  # binary
+        language: int = 0
+        self.w(i2b(kind))
+        self.w(i2b(language))
+        self.w(i2b(0, 2))  # reserved
+        self.w(i2b(curr, 2))
+        self.w(i2b(total, 2))
+        self.w(i2b(0, 2))  # reserved
+
+    def ilst(self) -> None:
+        self.w(i2b(self.ilst_size()))
+        self.w(s2b("ilst"))
+
+        if self.tags.track_name:
+            self.write_mp4_tag_utf8(b"\xA9\x6E\x61\x6D", self.tags.track_name)  # ©nam
+        if self.tags.artist:
+            self.write_mp4_tag_utf8(b"\xA9\x41\x52\x54", self.tags.artist)  # ©ART
+        if self.tags.album_artist:
+            self.write_mp4_tag_utf8(b"\x61\x41\x52\x54", self.tags.album_artist)  # aART
+        if self.tags.composer:
+            self.write_mp4_tag_utf8(b"\xA9\x77\x72\x74", self.tags.composer)  # ©wrt
+        if self.tags.album_name:
+            self.write_mp4_tag_utf8(b"\xA9\x61\x6C\x62", self.tags.album_name)  # ©alb
+        if self.tags.genre:
+            self.write_mp4_tag_utf8(b"\xA9\x67\x65\x6E", self.tags.genre)  # ©gen
+        if self.tags.date:
+            self.write_mp4_tag_utf8(b"\xA9\x64\x61\x79", self.tags.date)  # ©day
+        if self.tags.isrc:
+            self.write_mp4_tag_utf8(b"\x49\x53\x52\x43", self.tags.isrc)  # ISRC
+        if self.tags.copyright:
+            self.write_mp4_tag_utf8(b"\x63\x70\x72\x74", self.tags.copyright)  # cprt
+
+        if self.tags.apple_store_catalog_id:
+            self.write_mp4_tag_int(
+                b"\x63\x6E\x49\x44", self.tags.apple_store_catalog_id
+            )  # cnID
+        if self.tags.playlist_id:
+            self.write_mp4_tag_int(b"\x70\x6C\x49\x44", self.tags.playlist_id)  # plID
+        if self.tags.album_title_id:
+            self.write_mp4_tag_int(
+                b"\x61\x74\x49\x44", self.tags.album_title_id
+            )  # atID
+
+        if self.tags.upc:
+            self.write_itunes_tag_utf8("UPC", self.tags.upc)
+        if self.tags.label:
+            self.write_itunes_tag_utf8("LABEL", self.tags.label)
+
+        if self.tags.track_number or self.tags.total_number_of_tracks:
+            curr: int = 0
+            if self.tags.track_number:
+                curr = self.tags.track_number
+            total: int = 0
+            if self.tags.total_number_of_tracks:
+                total = self.tags.total_number_of_tracks
+
+            self.write_mp4_tag_tuple_int(b"\x74\x72\x6B\x6E", curr, total)
+
+        if self.tags.disc_number or self.tags.total_number_of_discs:
+            curr: int = 0
+            if self.tags.disc_number:
+                curr = self.tags.disc_number
+            total: int = 0
+            if self.tags.total_number_of_discs:
+                total = self.tags.total_number_of_discs
+
+            self.write_mp4_tag_tuple_int(b"\x64\x69\x73\x6B", curr, total)
+
+        if self.tags.cover_data:
+            if self.tags.cover_format == "jpeg":
+                kind: int = 13
+            elif self.tags.cover_format == "png":
+                kind: int = 14
+            language: int = 0
+            b: bytearray = self.tags.cover_data
+
+            full_size: int = len(b) + 24
+            self.w(i2b(full_size))
+            self.w(s2b("covr"))
+            data_size: int = full_size - 8
+            self.w(i2b(data_size))
+            self.w(s2b("data"))
+            self.w(i2b(kind))
+            self.w(i2b(language))
+            self.w(b)