NdsImageLayoutPlanner.cs

namespace NdsForge;

internal static class NdsImageLayoutPlanner
{
    public static NdsImageBuildLayout Plan(
        NdsImageBuilder builder,
        NdsImageBuildContent content,
        NdsImageBuildOptions options)
    {
        bool ndstoolProfile = options.Profile == NdsImageBuildProfile.Ndstool1503;
        long cursor = options.HeaderSize;
        NdsRegion arm9 = PlaceProgram(
            ref cursor,
            content.Arm9Data.Length,
            content.Arm9DeclaredLength,
            options.SectionAlignment);
        NdsRegion? arm9Footer = content.Arm9TrailingData.IsEmpty
            ? null
            : Place(ref cursor, content.Arm9TrailingData.Length, alignment: 1);
        NdsRegion arm9Overlays = content.Arm9OverlayTable.Length == 0
            ? default
            : Place(ref cursor, content.Arm9OverlayTable.Length, ndstoolProfile ? 1 : options.SectionAlignment);
        NdsRegion arm7 = PlaceProgram(
            ref cursor,
            content.Arm7Data.Length,
            content.Arm7DeclaredLength,
            options.SectionAlignment);
        NdsRegion arm7Overlays = content.Arm7OverlayTable.Length == 0
            ? default
            : Place(ref cursor, content.Arm7OverlayTable.Length, ndstoolProfile ? 1 : options.SectionAlignment);
        NdsRegion fnt = Place(ref cursor, content.FileSystem.FileNameTable.Length, options.SectionAlignment);
        NdsRegion fat = Place(ref cursor, checked(content.Allocations.Length * 8), options.SectionAlignment);
        NdsRegion? banner = builder.Banner is null
            ? null
            : Place(ref cursor, builder.Banner.RawData.Length, options.SectionAlignment);
        NdsRegion[] files = PlaceAllocations(ref cursor, content, options, ndstoolProfile);
        return PlanImageEnd(
            builder,
            content,
            options,
            arm9,
            arm9Footer,
            arm9Overlays,
            arm7,
            arm7Overlays,
            fnt,
            fat,
            banner,
            files,
            cursor,
            ndstoolProfile);
    }

    private static NdsRegion[] PlaceAllocations(
        ref long cursor,
        NdsImageBuildContent content,
        NdsImageBuildOptions options,
        bool ndstoolProfile)
    {
        var files = new NdsRegion[content.Allocations.Length];
        int alignment = ndstoolProfile ? options.SectionAlignment : options.FileAlignment;
        for (int fileId = 0; fileId < files.Length; fileId++)
        {
            files[fileId] = Place(ref cursor, content.Allocations[fileId].Length, alignment);
        }
 
        return files;
    }

    private static NdsImageBuildLayout PlanImageEnd(
        NdsImageBuilder builder,
        NdsImageBuildContent content,
        NdsImageBuildOptions options,
        NdsRegion arm9,
        NdsRegion? arm9Footer,
        NdsRegion arm9Overlays,
        NdsRegion arm7,
        NdsRegion arm7Overlays,
        NdsRegion fnt,
        NdsRegion fat,
        NdsRegion? banner,
        NdsRegion[] files,
        long commonContentEnd,
        bool ndstoolProfile)
    {
        long cursor = commonContentEnd;
        NdsRegion? arm9i = null;
        NdsRegion? arm7i = null;
        NdsRegion ntrDigest = default;
        NdsRegion twlDigest = default;
        NdsRegion sectorHashTable = default;
        NdsRegion blockHashTable = default;
        long usedSize;
        long physicalSize;
        if (builder.Kind == NdsImageKind.NintendoDs)
        {
            physicalSize = Align(commonContentEnd, options.FileAlignment);
            usedSize = ndstoolProfile ? physicalSize : commonContentEnd;
        }
        else
        {
            usedSize = Align(commonContentEnd, options.FileAlignment);
            cursor = usedSize;
            arm9i = Place(ref cursor, content.Arm9iData.Length, alignment: 0x400);
            arm7i = Place(ref cursor, content.Arm7iData.Length, options.SectionAlignment);
            if (builder.DsiMetadata!.Digests is not null)
            {
                NdsDsiDigestOptions digestOptions = builder.DsiMetadata.Digests;
                ntrDigest = new(arm9.Offset, checked(usedSize - arm9.Offset));
                twlDigest = new(arm9i.Value.Offset, checked(arm7i.Value.End - arm9i.Value.Offset));
                long sectorCount = checked(
                    DivideRoundUp(ntrDigest.Length, digestOptions.SectorSize) +
                    DivideRoundUp(twlDigest.Length, digestOptions.SectorSize));
                sectorHashTable = Place(ref cursor, checked(sectorCount * 20), digestOptions.SectorSize);
                long blockCount = DivideRoundUp(sectorCount, digestOptions.BlockSectorCount);
                blockHashTable = Place(ref cursor, checked(blockCount * 20), options.SectionAlignment);
            }
 
            physicalSize = Align(cursor, options.SectionAlignment);
        }
 
        if (physicalSize > uint.MaxValue)
        {
            throw new InvalidDataException("The generated image exceeds the DS header's 32-bit offset and size fields.");
        }
 
        return new(
            arm9,
            arm9Footer,
            arm9Overlays,
            arm7,
            arm7Overlays,
            fnt,
            fat,
            banner,
            files,
            arm9i,
            arm7i,
            ntrDigest,
            twlDigest,
            sectorHashTable,
            blockHashTable,
            usedSize,
            physicalSize);
    }

    private static NdsRegion Place(ref long cursor, long length, int alignment)
    {
        cursor = Align(cursor, alignment);
        var region = new NdsRegion(cursor, length);
        cursor = region.End;
        return region;
    }

    private static NdsRegion PlaceProgram(
        ref long cursor,
        int physicalLength,
        int declaredLength,
        int alignment)
    {
        if (declaredLength < physicalLength)
        {
            throw new InvalidDataException("A Program's declared length cannot exclude physical executable bytes.");
        }
 
        cursor = Align(cursor, alignment);
        var region = new NdsRegion(cursor, declaredLength);
        cursor = checked(cursor + physicalLength);
        return region;
    }

    private static long Align(long value, int alignment) => checked((value + alignment - 1) & -alignment);

    private static long DivideRoundUp(long value, int divisor) => checked((value + divisor - 1) / divisor);
}