add support for grayscale palette generation when palette footer is absent

Author: codengine

AmigaRawImageConverter/Options.cs

@@ -18,6 +18,10 @@ internal class Options
     [Option('p', "raw-file-pattern", Default = "*.raw", HelpText = "The filename pattern to match for RAW files.")]
     public string RawFilePattern { get; set; } = "*.raw";
 
+    [Option("require-palette", Default = true,
+        HelpText = "Require palette footer; if false, use grayscale palette and treat all bytes as planar data.")]
+    public bool RequirePalette { get; set; }
+
     [Option("min-planes", Default = 3, HelpText = "Minimum bitplane count to evaluate when guessing geometry.")]
     public int MinPlanes { get; set; }
 

AmigaRawImageConverter/Program.cs

@@ -68,15 +68,28 @@ private static int Run(Options opts)
     private static void ConvertOne(string inputPath, string outputPath, Options opts)
     {
         var raw = File.ReadAllBytes(inputPath);
-        if (raw.Length < PaletteLength)
+        ReadOnlySpan<byte> planar;
+        Rgba32[] palette;
+
+        if (opts.RequirePalette)
         {
-            throw new InvalidOperationException("File too small to contain palette.");
-        }
+            if (raw.Length < PaletteLength)
+            {
+                throw new InvalidOperationException("File too small to contain palette.");
+            }
 
-        var paletteTail = raw.AsSpan(raw.Length - PaletteLength, PaletteLength);
-        var palette = DecodePalette(paletteTail);
+            var paletteTail = raw.AsSpan(raw.Length - PaletteLength, PaletteLength);
+            palette = DecodePalette(paletteTail);
+            planar = raw.AsSpan(0, raw.Length - PaletteLength);
+        }
+        else
+        {
+            planar = raw;
+            var maxPlanes = Math.Max(opts.MinPlanes, opts.MaxPlanes);
+            var paletteSize = 1 << Math.Max(1, maxPlanes);
+            palette = BuildGrayscalePalette(paletteSize);
+        }
 
-        var planar = raw.AsSpan(0, raw.Length - PaletteLength);
         var paletteColors = palette.Length;
         var candidates = GuessCandidates(planar, paletteColors, opts)
             .OrderBy(c => c.score)
@@ -225,6 +238,19 @@ private static Rgba32[] DecodePalette(ReadOnlySpan<byte> tail)
         return colors;
     }
 
+    private static Rgba32[] BuildGrayscalePalette(int size)
+    {
+        var palette = new Rgba32[size];
+        var max = Math.Max(1, size - 1);
+        for (var i = 0; i < size; i++)
+        {
+            var v = (byte)(i * 255 / max);
+            palette[i] = new Rgba32(v, v, v, 255);
+        }
+
+        return palette;
+    }
+
     private static byte[,] DecodePlanar(ReadOnlySpan<byte> planar, (int Width, int Height) geom, int planes)
     {
         var width = geom.Width;

README.md

@@ -9,7 +9,7 @@ The tool auto-detects likely geometries and emits the top N PNGs per input.
 - Uses the embedded palette (last 32 bytes) decoded as Amiga RGB4.
 - Detects geometry by measuring row smoothness/banding; sorts best-first.
 - Outputs multiple candidates with descriptive suffixes (`_candNN_<WxH>.png`).
-- Works on single files or whole directories; configurable max candidates, bitplane range, and geometry search ranges.
+- Works on single files or whole directories; configurable max candidates, bitplane range, palette requirement, and geometry search ranges.
 - Cross-platform (.NET 8 + ImageSharp)
 
 ## Requirements
@@ -51,6 +51,7 @@ Candidate PNGs are written under the chosen output directory with names based on
 ## CLI options
 - `-n`, `--max-candidates` (default: 5): How many best geometry candidates to emit per file.
 - `-p`, `--raw-file-pattern` (default: `*.raw`): Filename pattern to match for RAW files when input is a directory.
+- `--require-palette` (default: true): If true, expect a palette footer; if false, use all bytes as planar data and generate a grayscale palette.
 - `--min-planes` (default: 3): Minimum bitplane count to evaluate when guessing geometry.
 - `--max-planes` (default: 6): Maximum bitplane count to evaluate when guessing geometry.
 - `--min-width` (default: 64): Minimum image width (pixels) to evaluate when guessing geometry.
@@ -60,7 +61,7 @@ Candidate PNGs are written under the chosen output directory with names based on
 - `--width-increment` (default: 16): Step (pixels) between tested widths when scanning candidates.
 
 ## Notes on geometry detection
-- Defaults to scanning 3–6 bitplanes (common Amiga modes); plane counts that need more palette entries than are present are skipped.
+- Defaults to scanning 3–6 bitplanes (common Amiga modes); plane counts that need more palette entries than are present are skipped. With `--require-palette false`, a grayscale palette sized to the maximum plane count is generated.
 - By default scans widths from 64 to 640 pixels in steps of 16 (`--min-width`, `--max-width`, `--width-increment`).
 - Width must be divisible by 8 and exactly consume the planar data (given height and plane count) or the candidate is skipped.
 - Scores candidates by row smoothness (mean + stddev of row deltas); lower is better.
@@ -71,7 +72,7 @@ The last 32 bytes are 16 big-endian words, layout `0RRR GGGG BBBB` (4 bits/chann
 each channel is scaled to 0–255 for PNG output.
 
 ## Limitations & gotchas
-- Expects the palette to be the final 32 bytes; extra non-planar data at the end will confuse detection.
-- Palette contains 16 entries (Amiga RGB4); bitplane counts requiring more colors are ignored.
+- When `--require-palette` is true, expects the palette to be the final 32 bytes; extra non-planar data at the end will confuse detection.
+- With autogenerated grayscale palette, bitplane counts requiring more colors than the generated palette size (based on max planes) are ignored.
 - Width/height search ranges are controlled via CLI options; exotic sizes outside the search window will not be considered.
 - Smoothness scoring can still pick a wrong candidate for very noisy or synthetic images—inspect the outputs.