networkwm-js 0.1.0

package/dist/database-abstraction.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseAbstraction = void 0;
+const himd_js_1 = require("himd-js");
+const databases_1 = require("./databases");
+const sort_1 = require("./sort");
+const initialization_1 = require("./initialization");
+const filesystem_1 = require("./filesystem");
+const tagged_oma_1 = require("./tagged-oma");
+const helpers_1 = require("./helpers");
+class DatabaseAbstraction {
+    constructor(filesystem) {
+        this.filesystem = filesystem;
+        this.lastTotalDuration = 0;
+        this.allTracks = [];
+        this.deletedTracks = [];
+        this.database = new databases_1.DatabaseManager(filesystem);
+    }
+    static async create(filesystem) {
+        const db = new DatabaseAbstraction(filesystem);
+        await db.database.init();
+        db._create();
+        return db;
+    }
+    _create() {
+        // Parse the group info file.
+        this.lastTotalDuration = 0;
+        this.content1ArtistAlbumTrack = contentDescriptionPairFromFiles(this.database.parsedTreeFiles["01TREE03.DAT"], this.database.parsedGroupInfoFiles["03GINF03.DAT"]);
+        this.deletedTracks = [];
+        this.allTracks = this.database.globalContentInfoFile.map((globalEntry, systemIndex) => {
+            var _a, _b;
+            // Locate the track index
+            const trackIndex = (_b = (_a = this.content1ArtistAlbumTrack.find(e => e.tracks.includes(systemIndex + 1))) === null || _a === void 0 ? void 0 : _a.tracks.indexOf(systemIndex + 1)) !== null && _b !== void 0 ? _b : 1;
+            this.lastTotalDuration += globalEntry.trackDuration;
+            const codecId = globalEntry.codecInfo[0];
+            const codecParams = globalEntry.codecInfo.slice(1);
+            const codecInfo = { codecId, codecInfo: codecParams };
+            const codecName = (0, himd_js_1.getCodecName)(codecInfo);
+            const codecKBPS = (0, himd_js_1.getKBPS)(codecInfo);
+            if (globalEntry.trackDuration === 0)
+                this.deletedTracks.push(systemIndex + 1);
+            return {
+                album: globalEntry.contents["TALB"],
+                artist: globalEntry.contents["TPE1"],
+                codecInfo: globalEntry.codecInfo,
+                encryptionState: globalEntry.encryptionState,
+                genre: globalEntry.contents["TCON"],
+                oneElementLength: globalEntry.oneElementLength,
+                title: globalEntry.contents["TIT2"],
+                trackDuration: globalEntry.trackDuration,
+                trackNumber: trackIndex,
+                systemIndex: systemIndex + 1,
+                codecName, codecKBPS
+            };
+        });
+    }
+    addNewTrack(trackInfo, codecInfo) {
+        const codecName = (0, himd_js_1.getCodecName)(codecInfo);
+        const codecKBPS = (0, himd_js_1.getKBPS)(codecInfo);
+        const newObject = {
+            ...trackInfo,
+            codecInfo: new Uint8Array([codecInfo.codecId, ...codecInfo.codecInfo.subarray(0, 3)]),
+            encryptionState: new Uint8Array([0, 1]),
+            oneElementLength: 128,
+            systemIndex: -1,
+            codecName, codecKBPS
+        };
+        // Do we have any free gaps after deleted tracks?
+        if (this.deletedTracks.length > 0) {
+            // Reuse it instead.
+            const reusedIndex = this.deletedTracks.splice(0, 1)[0];
+            this.allTracks.splice(reusedIndex - 1, 1, newObject);
+            newObject.systemIndex = reusedIndex;
+            return reusedIndex;
+        }
+        const idx = this.allTracks.push(newObject);
+        newObject.systemIndex = idx;
+        return newObject.systemIndex;
+    }
+    async uploadTrack(trackInfo, codec, rawData, session, callback) {
+        // If trackInfo.trackNumber == -1, it's the next one of this particular album
+        if (trackInfo.trackNumber == -1) {
+            trackInfo.trackNumber = this.allTracks
+                .filter(e => e.album === trackInfo.album && e.artist === trackInfo.artist)
+                .reduce((prev, c) => Math.max(prev, c.trackNumber), -1) + 1;
+        }
+        // Step 1 - Create the encrypted OMA which will later be written to the device's storage
+        const encryptedOMA = (0, tagged_oma_1.createTaggedEncryptedOMA)(rawData, trackInfo, codec);
+        // Step 2 - write track to the database
+        const globalTrackIndex = this.addNewTrack({
+            ...trackInfo,
+            trackDuration: encryptedOMA.duration,
+        }, codec);
+        // Step 3 - write track to the filesystem
+        const fh = await this.database.filesystem.open((0, helpers_1.resolvePathFromGlobalIndex)(globalTrackIndex), 'rw');
+        const data = encryptedOMA.data;
+        let remaining = data.length;
+        let i = 0;
+        callback === null || callback === void 0 ? void 0 : callback(i, data.length);
+        while (remaining) {
+            const toWrite = Math.min(2048, remaining);
+            await fh.write(data.slice(i, i + toWrite));
+            i += toWrite;
+            remaining -= toWrite;
+            callback === null || callback === void 0 ? void 0 : callback(i, data.length);
+        }
+        await fh.close();
+        // Step 4 - write MAC
+        session === null || session === void 0 ? void 0 : session.writeTrackMac(globalTrackIndex - 1, encryptedOMA.maclistValue);
+    }
+    async flushUpdates() {
+        this.reserializeDatabase();
+        this.database.reserializeTables();
+        return this.database.rewriteTables();
+    }
+    async deleteTrack(systemIndex) {
+        const track = this.allTracks[systemIndex - 1];
+        // Wipe metadata information.
+        track.trackDuration = 0;
+        track.album = "";
+        track.artist = "";
+        track.title = "";
+        this.deletedTracks.push(systemIndex);
+        // Sort
+        this.deletedTracks.sort((a, b) => a - b);
+        // Delete the file.
+        await this.filesystem.delete((0, helpers_1.resolvePathFromGlobalIndex)(systemIndex));
+    }
+    reserializeDatabase() {
+        const instrs = [
+            // TREE01 - Groups (I use [aritst - album] > [trackNumber])
+            {
+                metadataCreator: e => ({
+                    TIT2: e.album,
+                    TPE1: e.artist,
+                    TCON: '',
+                    TSOP: '',
+                    PICP: '',
+                    PIC0: '',
+                }),
+                sorting: [[{ var: 'artist' }, { literal: '-----' }, { var: 'album' }], [{ var: 'trackNumber' }]],
+            },
+            // TREE02 - [artist] > [title]
+            {
+                metadataCreator: e => ({ TIT2: e.artist }),
+                sorting: [[{ var: 'artist' }], [{ var: 'title' }]],
+            },
+            // TREE03 - [album] > [trackNumber]
+            {
+                metadataCreator: e => ({ TIT2: e.album }),
+                sorting: [[{ var: 'album' }], [{ var: 'trackNumber' }]],
+            },
+            // TREE04 - [genre] > [title]
+            // ...who came up with this order??
+            {
+                metadataCreator: e => ({ TIT2: e.genre }),
+                sorting: [[{ var: 'genre' }], [{ var: 'title' }]],
+            },
+        ];
+        for (let fileIndex = 0; fileIndex < instrs.length; fileIndex++) {
+            const sortingInstr = instrs[fileIndex];
+            const sorted = (0, sort_1.complexSort)(sortingInstr.sorting, this.allTracks.filter(e => e.trackDuration > 0));
+            const entries = [];
+            for (const _group of sorted) {
+                const group = _group;
+                const any = group.contents[0];
+                const metadata = sortingInstr.metadataCreator(any);
+                entries.push({
+                    flags: 256,
+                    metadata,
+                    oneElementLength: 128,
+                    tracks: group.contents.map(e => e.systemIndex),
+                });
+            }
+            const [tree, group] = contentDescriptionPairToFiles(this.allTracks, entries);
+            this.database.parsedGroupInfoFiles[`03GINF${(fileIndex + 1).toString().padStart(2, '0')}.DAT`] = group;
+            this.database.parsedTreeFiles[`01TREE${(fileIndex + 1).toString().padStart(2, '0')}.DAT`] = tree;
+        }
+        // Rebuild tree metadata (update total duration)
+        this.database.globalContentInfoFile = this.allTracks.map(e => ({
+            codecInfo: e.codecInfo,
+            contents: {
+                TIT2: e.title,
+                TPE1: e.artist,
+                TALB: e.album,
+                TCON: e.genre,
+                TSOP: e.artist,
+            },
+            encryptionState: e.encryptionState,
+            oneElementLength: e.oneElementLength,
+            trackDuration: e.trackDuration,
+        }));
+        let newDuration = this.allTracks.reduce((a, v) => a + v.trackDuration, 0);
+        this.database.rewriteTotalDuration(this.lastTotalDuration, newDuration);
+        this.lastTotalDuration = newDuration;
+    }
+    getTracksSortedArtistAlbum() {
+        return (0, sort_1.complexSort)([[{ var: 'artist' }], [{ var: 'album' }], [{ var: 'trackNumber' }]], this.allTracks.filter(e => e.trackDuration > 0));
+    }
+    async eraseAll() {
+        // Essentially reinitialize the filesystem.
+        // Destroy all audio files
+        const fs = this.database.filesystem;
+        // Due to how HIMDFilesystem abstraction works, delete() would immediately flush the FAT changes.
+        // Here, they will be cached.
+        const fsDelete = (fs instanceof filesystem_1.UMSCNWJSFilesystem) ? fs.fatfs.delete.bind(fs.fatfs) : fs.delete.bind(fs);
+        async function recurseDelete(dir) {
+            for (let file of await fs.list(dir)) {
+                if (file.type === 'directory') {
+                    await recurseDelete(file.name);
+                }
+                else {
+                    await fsDelete(file.name);
+                }
+            }
+            await fsDelete(dir);
+        }
+        await recurseDelete("/OMGAUDIO");
+        if (fs instanceof filesystem_1.UMSCNWJSFilesystem) {
+            await fs.fatfs.flushMetadataChanges();
+        }
+        await (0, initialization_1.initializeNW)(fs);
+        this.database = new databases_1.DatabaseManager(this.filesystem);
+        await this.database.init();
+        this._create();
+    }
+    async renameTrack(systemIndex, metadata) {
+        this.allTracks[systemIndex - 1].album = metadata.album;
+        this.allTracks[systemIndex - 1].artist = metadata.artist;
+        this.allTracks[systemIndex - 1].title = metadata.title;
+        this.allTracks[systemIndex - 1].trackNumber = metadata.trackNumber;
+        // TODO: Is this necessary??
+        // Update the metadata within the OMA file
+        const handle = await this.database.filesystem.open((0, helpers_1.resolvePathFromGlobalIndex)(systemIndex), 'rw');
+        if (!handle)
+            return;
+        await (0, tagged_oma_1.updateMetadata)(handle, metadata);
+    }
+}
+exports.DatabaseAbstraction = DatabaseAbstraction;
+function contentDescriptionPairFromFiles(treeFile, groupFile) {
+    // Step 1: Parse GROUP file. Create `groups`:
+    let groups = groupFile.map(e => ({
+        // TPLB / tree
+        flags: -1,
+        tracks: [],
+        // GROUP:
+        metadata: e.contents,
+        oneElementLength: e.oneElementLength,
+    }));
+    let groupsSortedInLookupOrder = [...treeFile.mapStartBounds].sort((a, b) => b.firstTrackApplicableInTPLB - a.firstTrackApplicableInTPLB);
+    // Step 2: Traverse trees - update groups one by one
+    main: for (let i = 0; i < treeFile.tplb.length; i++) {
+        let checkedIndex = i + 1;
+        for (let group of groupsSortedInLookupOrder) {
+            if (checkedIndex >= group.firstTrackApplicableInTPLB) {
+                // Found!
+                groups[group.groupInfoIndex - 1].flags = group.flags;
+                groups[group.groupInfoIndex - 1].tracks.push(treeFile.tplb[i]);
+                continue main;
+            }
+        }
+        throw new Error("Group not found! Data is corrupted.");
+    }
+    return groups;
+}
+function contentDescriptionPairToFiles(allContentRef, content) {
+    // Assume pairs are sorted correctly.
+    const tree = {
+        mapStartBounds: [],
+        tplb: [],
+    };
+    const groups = content.map((etr, index) => {
+        let obj = {
+            oneElementLength: 128,
+            totalDuration: etr.tracks.reduce((p, c) => p + allContentRef[c - 1].trackDuration, 0),
+            contents: etr.metadata,
+        };
+        tree.mapStartBounds.push({
+            firstTrackApplicableInTPLB: tree.tplb.length + 1,
+            flags: etr.flags,
+            groupInfoIndex: index + 1,
+        });
+        tree.tplb.push(...etr.tracks);
+        return obj;
+    });
+    return [tree, groups];
+}

package/dist/databases.d.ts

@@ -0,0 +1,85 @@
+import { HiMDFilesystem, HiMDCodecName } from "himd-js";
+import { TableFile } from "./tables";
+export interface TreeFile {
+    mapStartBounds: {
+        firstTrackApplicableInTPLB: number;
+        groupInfoIndex: number;
+        flags: number;
+    }[];
+    tplb: number[];
+}
+export interface ContentEntry {
+    encryptionState: Uint8Array;
+    codecInfo: Uint8Array;
+    trackDuration: number;
+    oneElementLength: number;
+    contents: {
+        [key: string]: string;
+    };
+}
+export interface GroupEntry {
+    totalDuration: number;
+    oneElementLength: number;
+    contents: {
+        [key: string]: string;
+    };
+}
+export interface TrackMetadata {
+    album: string;
+    artist: string;
+    title: string;
+    genre: string;
+    trackDuration: number;
+    trackNumber: number;
+}
+export declare class DatabaseManager {
+    filesystem: HiMDFilesystem;
+    tableFiles: {
+        [fileName: string]: TableFile;
+    };
+    parsedTreeFiles: {
+        [fileName: string]: TreeFile;
+    };
+    parsedGroupInfoFiles: {
+        [fileName: string]: GroupEntry[];
+    };
+    globalContentInfoFile: ContentEntry[];
+    constructor(filesystem: HiMDFilesystem);
+    init(): Promise<void>;
+    reserializeTables(): void;
+    rewriteTables(): Promise<void>;
+    protected getGlobalTrack(track: number): {
+        album: string;
+        artist: string;
+        genre: string;
+        title: string;
+        duration: number;
+        codecName: HiMDCodecName;
+        codecKBPS: number;
+    };
+    rewriteTotalDuration(oldValue: number, newValue: number): void;
+    listContentGroups(): {
+        groupName: string | null;
+        contents: {
+            title: string;
+            artist: string;
+            genre: string;
+            album: string;
+            duration: number;
+            codecName: HiMDCodecName;
+            codecKBPS: number;
+        }[];
+    }[];
+    listContentArtists(): {
+        [artist: string]: {
+            [album: string]: {
+                track: string;
+                index: -1;
+                duration: number;
+                codecName: HiMDCodecName;
+                codecKBPS: number;
+            }[];
+        };
+    };
+}
+//# sourceMappingURL=databases.d.ts.map

package/dist/databases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"databases.d.ts","sourceRoot":"","sources":["../src/databases.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,cAAc,EAAyB,aAAa,EAAE,MAAM,SAAS,CAAC;AAI1F,OAAO,EAAc,SAAS,EAAkB,MAAM,UAAU,CAAC;AA4DjE,MAAM,WAAW,QAAQ;IAAE,cAAc,EAAE;QAAE,0BAA0B,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAC;AAC3I,MAAM,WAAW,YAAY;IAAG,eAAe,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,UAAU,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAA;CAAC;AACvK,MAAM,WAAW,UAAU;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAAA;CAAC;AAChH,MAAM,WAAW,aAAa;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC;AACxI,qBAAa,eAAe;IAML,UAAU,EAAE,cAAc;IAL7C,UAAU,EAAE;QAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;KAAC,CAAK;IAChD,eAAe,EAAE;QAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAA;KAAC,CAAM;IACrD,oBAAoB,EAAE;QAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CAAA;KAAC,CAAM;IAC9D,qBAAqB,EAAE,YAAY,EAAE,CAAM;gBAExB,UAAU,EAAE,cAAc;IAEvC,IAAI;IAoFH,iBAAiB;IAsEX,aAAa;IAU1B,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM;;;;;;;;;IAkB/B,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAYvD,iBAAiB,IAAI;QAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,QAAQ,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,aAAa,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAAC,EAAE;IAkC9L,kBAAkB,IAAI;QAAC,CAAC,MAAM,EAAE,MAAM,GAAG;YAAC,CAAC,KAAK,EAAE,MAAM,GAAG;gBAAC,KAAK,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBAAC,QAAQ,EAAE,MAAM,CAAC;gBAAC,SAAS,EAAE,aAAa,CAAC;gBAAC,SAAS,EAAE,MAAM,CAAA;aAAE,EAAE,CAAA;SAAC,CAAA;KAAC;CAwBnK"}

package/dist/databases.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseManager = void 0;
+const node_mass_storage_1 = require("node-mass-storage");
+const himd_js_1 = require("himd-js");
+const bytemanip_1 = require("./bytemanip");
+const id3_1 = require("./id3");
+const tables_1 = require("./tables");
+const utils_1 = require("./utils");
+const FILES_TO_LOAD = [
+    // Group definition files:
+    "01TREE01.DAT",
+    "01TREE02.DAT",
+    "01TREE03.DAT",
+    "01TREE04.DAT",
+    // Tree keyinfo file:
+    "02TREINF.DAT",
+    // Group string resource files:
+    "03GINF01.DAT",
+    "03GINF02.DAT",
+    "03GINF03.DAT",
+    "03GINF04.DAT",
+    // Global content descriptor file:
+    "04CNTINF.DAT",
+];
+const textEncoder = new TextEncoder();
+const textDecoderStd = new TextDecoder();
+const textDecoderUTF16 = new TextDecoder("UTF-16BE");
+function readPackedTags(data, offset, elementsCount, elementLength) {
+    const contents = {};
+    for (let i = 0; i < elementsCount; i++) {
+        let tagNameB, encodingType, rawContents;
+        [tagNameB, offset] = (0, bytemanip_1.readBytes)(data, offset, 4);
+        [encodingType, offset] = (0, bytemanip_1.readUint16)(data, offset);
+        [rawContents, offset] = (0, bytemanip_1.readBytes)(data, offset, elementLength - 6);
+        const tagName = textDecoderStd.decode(tagNameB);
+        (0, utils_1.assert)(encodingType === 2, "Invalid string encoding!");
+        // Trim all zeros:
+        let rawContentsStr = textDecoderUTF16.decode(rawContents);
+        let newLength = rawContentsStr.length;
+        while (rawContentsStr.charCodeAt(newLength - 1) === 0)
+            --newLength;
+        rawContentsStr = rawContentsStr.substring(0, newLength);
+        contents[tagName] = rawContentsStr.trim();
+    }
+    return [contents, offset];
+}
+function writePackedTags(tags, elementLength) {
+    let offset = 0;
+    let content = new Uint8Array(Object.keys(tags).length * elementLength);
+    for (let [k, v] of Object.entries(tags)) {
+        if (k.startsWith("_"))
+            continue;
+        content.set(textEncoder.encode(k), offset);
+        offset += 4;
+        content.set((0, id3_1.encodeUTF16BEStringEA3)(v, true), offset + 1);
+        offset += elementLength - 4;
+    }
+    return content;
+}
+;
+class DatabaseManager {
+    constructor(filesystem) {
+        this.filesystem = filesystem;
+        this.tableFiles = {};
+        this.parsedTreeFiles = {};
+        this.parsedGroupInfoFiles = {};
+        this.globalContentInfoFile = [];
+    }
+    async init() {
+        for (let file of FILES_TO_LOAD) {
+            const fd = await this.filesystem.open('OMGAUDIO/' + file, 'ro');
+            const contents = await fd.read();
+            const table = (0, tables_1.parseTable)(contents);
+            this.tableFiles[file] = table;
+            if (file.startsWith("03GINF")) {
+                // Group info file. Parse it.
+                // Make sure the format is readable
+                (0, utils_1.assert)(table.name === 'GPIF', "Invalid group info table name");
+                (0, utils_1.assert)(table.classes.length === 1, "Invalid class amount in GINF");
+                (0, utils_1.assert)(table.classes[0].className === "GPFB", "Invalid class name in GINF");
+                // Known format - we're dealing with the standard map
+                this.parsedGroupInfoFiles[file] = [];
+                for (let entry of table.contents[0].elements) {
+                    // Read the header
+                    const data = new DataView(entry.buffer);
+                    let trackId, elementsCount, elementLength;
+                    let offset = 8;
+                    [trackId, offset] = (0, bytemanip_1.readUint32)(data, offset);
+                    [elementsCount, offset] = (0, bytemanip_1.readUint16)(data, offset);
+                    [elementLength, offset] = (0, bytemanip_1.readUint16)(data, offset);
+                    (0, utils_1.assert)(elementLength > 0x10, "The group info table does not make sense.");
+                    // Read and parse every element
+                    let contents;
+                    [contents, offset] = readPackedTags(data, offset, elementsCount, elementLength);
+                    // Bundle the info
+                    this.parsedGroupInfoFiles[file].push({ totalDuration: trackId, oneElementLength: elementLength, contents });
+                }
+            }
+            else if (file.startsWith("01TREE")) {
+                // Tree file. Parse
+                // Make sure the format is known / readable
+                (0, utils_1.assert)(table.name === "TREE", "Invalid root tree table name!");
+                (0, utils_1.assert)(table.classes.length === 2, "Invalid amount of classes in tree file!");
+                (0, utils_1.assert)(table.classes[0].className === "GPLB", "Invalid Groupinfo-match class in tree file!");
+                (0, utils_1.assert)(table.classes[1].className === "TPLB", "Invalid track index in tree file!");
+                // Ok - format is good
+                // Parse the entries.
+                const gplbEntries = [];
+                for (let gplbEntry of table.contents[0].elements) {
+                    const data = new DataView(gplbEntry.buffer);
+                    let offset = 0;
+                    let groupInfoIndex, firstTrackApplicableInTPLB, flags;
+                    [groupInfoIndex, offset] = (0, bytemanip_1.readUint16)(data, offset);
+                    [flags, offset] = (0, bytemanip_1.readUint16)(data, offset);
+                    [firstTrackApplicableInTPLB, offset] = (0, bytemanip_1.readUint16)(data, offset);
+                    gplbEntries.push({ firstTrackApplicableInTPLB, flags, groupInfoIndex });
+                }
+                // Parse TPLB
+                const tplbEntries = [];
+                for (let e of table.contents[1].elements) {
+                    tplbEntries.push((0, bytemanip_1.getUint16)(e));
+                }
+                this.parsedTreeFiles[file] = { mapStartBounds: gplbEntries, tplb: tplbEntries };
+            }
+        }
+        // Parse global content info file.
+        {
+            const rootTable = this.tableFiles["04CNTINF.DAT"];
+            (0, utils_1.assert)(rootTable.name === 'CNIF', "Invalid root table name");
+            (0, utils_1.assert)(rootTable.classes.length === 1, "Invalid class amount in root");
+            (0, utils_1.assert)(rootTable.classes[0].className === "CNFB", "Invalid class name in root");
+            for (let contentBlock of rootTable.contents[0].elements) {
+                const data = new DataView(contentBlock.buffer);
+                let zeros, encryptionState, codecInfo, trackId, elementsCount, elementLength, contents;
+                let offset = 0;
+                [zeros, offset] = (0, bytemanip_1.readBytes)(data, offset, 2);
+                [encryptionState, offset] = (0, bytemanip_1.readBytes)(data, offset, 2);
+                [codecInfo, offset] = (0, bytemanip_1.readBytes)(data, offset, 4);
+                [trackId, offset] = (0, bytemanip_1.readUint32)(data, offset);
+                [elementsCount, offset] = (0, bytemanip_1.readUint16)(data, offset);
+                [elementLength, offset] = (0, bytemanip_1.readUint16)(data, offset);
+                [contents, offset] = readPackedTags(data, offset, elementsCount, elementLength);
+                (0, utils_1.assert)(zeros.every(e => e === 0), "Unexpected data in root content block header");
+                this.globalContentInfoFile.push({ codecInfo, contents, oneElementLength: elementLength, encryptionState, trackDuration: trackId });
+            }
+        }
+    }
+    reserializeTables() {
+        // Write global content info file
+        {
+            const rootTable = this.tableFiles["04CNTINF.DAT"];
+            rootTable.contents[0].elements = [];
+            for (let contentBlock of this.globalContentInfoFile) {
+                const content = new Uint8Array(rootTable.contents[0].oneElementLength);
+                let offset = 0;
+                content.set([0, 0], offset);
+                offset += 2;
+                content.set(contentBlock.encryptionState, offset);
+                offset += 2;
+                content.set(contentBlock.codecInfo, offset);
+                offset += 4;
+                content.set((0, bytemanip_1.writeUint32)(contentBlock.trackDuration), offset);
+                offset += 4;
+                content.set((0, bytemanip_1.writeUint16)(Object.keys(contentBlock.contents).length), offset);
+                offset += 2;
+                content.set((0, bytemanip_1.writeUint16)(contentBlock.oneElementLength), offset);
+                offset += 2;
+                // Write all entries
+                content.set(writePackedTags(contentBlock.contents, contentBlock.oneElementLength), offset);
+                rootTable.contents[0].elements.push(content);
+            }
+        }
+        // Rebuild groupinfo
+        for (let groupInfoFile in this.parsedGroupInfoFiles) {
+            const parsed = this.parsedGroupInfoFiles[groupInfoFile];
+            const table = this.tableFiles[groupInfoFile];
+            table.contents[0].elements = [];
+            for (let element of parsed) {
+                let content = new Uint8Array(table.contents[0].oneElementLength).fill(0);
+                let offset = 8;
+                content.set((0, bytemanip_1.writeUint32)(element.totalDuration), offset);
+                offset += 4;
+                content.set((0, bytemanip_1.writeUint16)(Object.keys(element.contents).length), offset);
+                offset += 2;
+                content.set((0, bytemanip_1.writeUint16)(element.oneElementLength), offset);
+                offset += 2;
+                content.set(writePackedTags(element.contents, element.oneElementLength), offset);
+                table.contents[0].elements.push(content);
+            }
+        }
+        // Rebuild trees
+        for (let treeFile in this.parsedTreeFiles) {
+            const parsed = this.parsedTreeFiles[treeFile];
+            const table = this.tableFiles[treeFile];
+            table.contents[0].elements = [];
+            // Serialize the maps
+            for (let mapEntry of parsed.mapStartBounds) {
+                const entry = new Uint8Array(table.contents[0].oneElementLength);
+                let offset = 0;
+                entry.set((0, bytemanip_1.writeUint16)(mapEntry.groupInfoIndex), offset);
+                offset += 2;
+                entry.set((0, bytemanip_1.writeUint16)(mapEntry.flags), offset);
+                offset += 2;
+                entry.set((0, bytemanip_1.writeUint16)(mapEntry.firstTrackApplicableInTPLB), offset);
+                table.contents[0].elements.push(entry);
+            }
+            // Serialize the tplb
+            table.contents[1].elements = [];
+            for (let tplbEntry of parsed.tplb) {
+                table.contents[1].elements.push((0, bytemanip_1.writeUint16)(tplbEntry));
+            }
+        }
+    }
+    async rewriteTables() {
+        this.reserializeTables();
+        for (let filename in this.tableFiles) {
+            const tableContents = (0, tables_1.serializeTable)(this.tableFiles[filename], filename.startsWith("01TREE"));
+            const fd = await this.filesystem.open("OMGAUDIO/" + filename, 'rw');
+            await fd.write(tableContents);
+            await fd.close();
+        }
+    }
+    getGlobalTrack(track) {
+        const globalTrack = this.globalContentInfoFile[track - 1];
+        const codecId = globalTrack.codecInfo[0];
+        const codecParams = globalTrack.codecInfo.slice(1);
+        const codecInfo = { codecId, codecInfo: codecParams };
+        const codecName = (0, himd_js_1.getCodecName)(codecInfo);
+        const codecKBPS = (0, himd_js_1.getKBPS)(codecInfo);
+        return {
+            album: globalTrack.contents['TALB'],
+            artist: globalTrack.contents['TPE1'],
+            genre: globalTrack.contents['TCON'],
+            title: globalTrack.contents['TIT2'],
+            duration: Math.ceil(globalTrack.trackDuration / 1000),
+            codecName, codecKBPS,
+        };
+    }
+    rewriteTotalDuration(oldValue, newValue) {
+        const newKeyAsUint = (0, node_mass_storage_1.getBEUint32AsBytes)(newValue);
+        for (let entry of this.tableFiles["02TREINF.DAT"].contents[0].elements.slice(0, 4)) {
+            // After index 4, there be dragons
+            if ((0, node_mass_storage_1.getBEUint32)(entry.slice(8, 8 + 4)) === oldValue) {
+                entry.set(newKeyAsUint, 8);
+            }
+        }
+    }
+    // TODO: TRACK ORDERING
+    listContentGroups() {
+        const groupedEncountered = [];
+        const groups = [];
+        // 01TREE01.DAT is groups
+        const tree = this.parsedTreeFiles["01TREE01.DAT"];
+        const desc = this.parsedGroupInfoFiles["03GINF01.DAT"];
+        for (let trackIndex = 0; trackIndex < tree.tplb.length; trackIndex++) {
+            const track = tree.tplb[trackIndex];
+            let gplbEntry = -1;
+            // If Sony can depend on GPLBs being ordered correctly, so can I.
+            for (let i = tree.mapStartBounds.length - 1; i >= 0; i--) {
+                const gplb = tree.mapStartBounds[i];
+                if ((trackIndex + 1) >= gplb.firstTrackApplicableInTPLB) {
+                    gplbEntry = gplb.groupInfoIndex;
+                    break;
+                }
+            }
+            if (gplbEntry !== -1) {
+                groupedEncountered.push(track);
+                if (groups.length < gplbEntry) {
+                    groups.push({ groupName: desc[gplbEntry - 1].contents['TIT2'], contents: [] });
+                }
+                groups[gplbEntry - 1].contents.push(this.getGlobalTrack(track));
+            }
+        }
+        let ungrouped = Array(this.globalContentInfoFile.length).fill(0).map((_, i) => i + 1).filter(e => !groupedEncountered.includes(e));
+        const ungroupedGroup = { groupName: null, contents: ungrouped.map(this.getGlobalTrack.bind(this)) };
+        groups.splice(0, 0, ungroupedGroup);
+        return groups;
+    }
+    listContentArtists() {
+        const artists = {};
+        for (let i = 1; i <= this.globalContentInfoFile.length; i++) {
+            const track = this.getGlobalTrack(i);
+            if (!(track.artist in artists)) {
+                artists[track.artist] = {};
+            }
+            const artist = artists[track.artist];
+            if (!(track.album in artist)) {
+                artist[track.album] = [];
+            }
+            const album = artist[track.album];
+            album.push({
+                track: track.title,
+                index: -1,
+                duration: track.duration,
+                codecName: track.codecName,
+                codecKBPS: track.codecKBPS,
+            });
+        }
+        return artists;
+    }
+}
+exports.DatabaseManager = DatabaseManager;