die-python 0.4.0__cp313-abi3-win_amd64.whl

die/db/db/Binary/image.KTX.1.sg

@@ -0,0 +1,44 @@
+// Detect It Easy: detection rule file
+// Author: LinXP
+
+init("image", "");
+
+includeScript("read");
+
+function detect() {
+    if (Binary.getSize() >= 0x40) {
+        if (Binary.compare("AB'KTX 11'BB0D0A1A0A")) {
+            bDetected = true;
+            sName = "Khronos Texture (.KTX)";
+            if (Binary.isVerbose()) {
+                sOption(Binary.read_uint32(0x24) + "x" + Binary.read_uint32(0x28));
+                //TODO derive size ref https://registry.khronos.org/KTX/specs/1.0/ktxspec.v1.html
+            }
+        } else if (Binary.compare("AB'KTX 20'BB0D0A1A0A")) {
+            bDetected = true;
+            sName = "Khronos Texture (.KTX2)";
+            if (Binary.isVerbose()) {
+                sOption(Binary.read_uint32(0x14) + "x" + Binary.read_uint32(0x18));
+                //ref https://registry.khronos.org/KTX/specs/2.0/ktxspec.v2.html
+                p = 0x50; sz = 0; //max ofs among the levels' ends
+                for(i = 0; i < Math.max(1,Binary.read_uint32(0x28)); i++, p += 0x18)
+                    if((t = Binary.read_uint64(p)) > sz) { sz = t + Binary.read_uint64(p+8) }
+                sOption('sz:'+outSz(sz))
+            }
+        }
+
+        // https://github.com/BinomialLLC/basis_universal/wiki/.basis-File-Format-and-ETC1S-Texture-Video-Specification
+        else if (Binary.compare("734213004D00")) {
+            bDetected = true;
+            sName = "Basis Universal GPU Texture (.BASIS)";
+            if (Binary.isVerbose()) {
+                //sOption(Binary.read_uint32(0x14)+"x"+Binary.read_uint32(0x18));
+            }
+        }
+
+
+
+    }
+
+    return result();
+}

die/db/db/Binary/image.LBM.1.sg

@@ -0,0 +1,69 @@
+// https://github.com/horsicq/Detect-It-Easy signature file
+// Authors:
+//   Kaens TG@kaens
+
+init("image", "IFF InterLeaved BitMap (.IFF,.LBM)");
+
+function detect() {
+    if (File.compare("'FORM'") && (File.compare("'ILBM'", 8) || File.compare("'PBM '", 8))) {
+        sz = File.read_uint32(4, _BE) + 8;
+        if (File.getSize() < sz) sVersion = "malformed!short";
+        p = 0x0C;
+        end = Math.min(File.getSize(), sz);
+        w = viewportMode = hsx = -1;
+        while (p < end) {
+            hkhd = File.read_ansiString(p, 4);
+            hksz = File.read_uint32(p + 4, _BE);
+            p += 8;
+            switch (hkhd) {
+                case "BMHD":
+                    w = File.read_uint16(p, _BE);
+                    h = File.read_uint16(p + 2, _BE);
+                    x0 = File.read_int16(p + 4, _BE);
+                    y0 = File.read_int16(p + 6, _BE);
+                    numPlanes = File.read_uint8(p + 8);
+                    mask = File.read_uint8(p + 9);
+                    co = File.read_uint8(p + 0xA);
+                    tcol = File.read_uint16(p + 0xC);
+                    xa = File.read_uint8(p + 0xE);
+                    ya = File.read_uint8(p + 0xF);
+                    pw = File.read_int16(p + 0x10, _BE);
+                    ph = File.read_int16(p + 0x12, _BE);
+                    break;
+                case "CAMG":
+                    viewportMode = File.read_uint32(p, _BE);
+                    break;
+                case "GRAB":
+                    hsx = File.read_int16(p, _BE);
+                    hsy = File.read_int16(p + 2, _BE);
+                    break;
+            }
+            p += hksz;
+            if (hksz % 2) p++;
+        }
+        if (w < 0) return;
+        if (File.isVerbose()) {
+            sOption(w + "x" + h + " (" + x0 + "," + y0 + ") [" + pw + "x" + ph + "] AR" + xa + ":" + ya);
+            sOption("planes:" + numPlanes);
+            switch (co) {
+                case 0:
+                    sOption("uncompressed");
+                    break;
+                case 1:
+                    sOption("RLE");
+                    break;
+                case 2:
+                    sOption("vertical RLE");
+                    break;
+                default:
+                    sOption("unk.compression")
+            }
+            if (mask >= 2) sOption("t.col:" + Hex(tcol));
+            if (viewportMode >= 0) sOption(Hex(viewportMode), "view_port_mode:");
+            if (hsx >= 0) sOption("hotspot: (" + hsx + "," + hsy + ")")
+        }
+        bDetected = true;
+    }
+
+    return result();
+}

die/db/db/Binary/image.MNG.1.sg

@@ -0,0 +1,19 @@
+// Detect It Easy: detection rule file
+// Author: LinXP
+// doc-ref: http://www.libpng.org/pub/mng/spec/
+
+init("image", "Multiple-image Network Graphics (.MNG)");
+
+function detect() {
+    if (Binary.getSize() >= 0x40) {
+        if (Binary.compare("8A'MNG\r\n'1A0A........'MHDR'")) {
+            bDetected = true;
+            if (Binary.isVerbose()) {
+                sOption(Binary.read_uint32(0x10, _BE) + "x" + Binary.read_uint32(0x14, _BE));
+                sOption("frames:" + Binary.read_uint32(0x18, _BE));
+            }
+        }
+    }
+
+    return result();
+}

die/db/db/Binary/image.PCX.1.sg

@@ -0,0 +1,69 @@
+// Detect It Easy: detection rule file
+// Authors: LinXP, Kae (TG@kaens)
+
+init("image", "ZSoft PiCture eXchange file (.PCX)");
+
+includeScript("read");
+
+function detect() {
+    //ref https://www.fileformat.info/format/pcx/spec/a10e75307b3a4cc49c3bbe6db4c41fa2/view.htm
+    if (File.getSize() >= 0x50) {
+        if (File.compare("0a") && !File.read_uint8(0x40)) {
+            switch (nv = File.read_uint8(0x01)) {
+                case 0:
+                    sVersion = "v2.5 using a fixed EGA palette";
+                    break;
+                case 2:
+                    sVersion = "v2.8 using a modifiable EGA palette";
+                    break;
+                case 3:
+                    sVersion = "v2.8 using no palette";
+                    break;
+                case 4:
+                    sVersion = "Windows";
+                    break;
+                case 5:
+                    sVersion = "v3.0+ or 24-bit";
+                    break;
+                default:
+                    return;
+            }
+            var sus = '', inv = 0; // strictly-speaking-invalid or highly unlikely parameter counter
+            var rle = File.read_uint8(0x02);
+            if (rle > 1) return;
+            if (!rle) { inv++; sus += '!uncompressed' }
+            var w = File.read_uint16(0x08) - File.read_uint16(0x04) + 1,
+                h = File.read_uint16(0x0A) - File.read_uint16(0x06) + 1;
+            if (w <= 0 || h <= 0) return;
+            var bpplane = File.read_uint8(0x03),
+                nplanes = File.read_uint8(0x41),
+                bpx = bpplane * nplanes,
+                pal = false;
+            if ([1, 2, 4, 8, 24].indexOf(bpplane) < 0) return;
+            if (!nplanes || nplanes > 4) return;
+            if (!X.c("00",0x40)) { inv++; sus += '!resnon0' }
+            if (!isAllZeroes(0x4A, 0x36)) ext = true;
+            if (pal && ([0, 3].indexOf(nv) < 0 || bpx > 4)) { inv++; sus += '!badpalette' }
+            var bpline = File.read_uint16(0x42); if (bpline % 2) return;
+            if (bpline < w*bpx >> 3) { inv++; sus += '!bpline'+bpline+'<w'+(w*bpx/8) }
+            if (inv > 2) return;
+            if (inv) sVersion = sVersion.appendS('sus'+sus,'/')
+            if (File.isVerbose()) {
+                sOption(w + "x" + h);
+                if (rle) sOption("RLE");
+                if (ext) sOption("extra_block");
+                sOption(bpx, "bit/pixel:");
+                sOption(bpplane, "bit/plane:");
+                if(bpline < w*bpx >> 3) sOption(bpline, "scanline:");
+                sOption(File.read_uint16(0x0C) + "x" + File.read_uint16(0x0E), "res:", " dpi");
+                var scrw = File.read_uint16(0x46),
+                    scrh = File.read_uint16(0x48);
+                if (scrw * scrh) sOption(scrw + "x" + scrh, "screen:");
+                if (!rle) sOption(0x80 + (w * h * bpx >> 3), "sz:") //but it's never not RLE, sorry
+            }
+            bDetected = true;
+        }
+    }
+
+    return result();
+}

die/db/db/Binary/image.PNG.1.sg

@@ -0,0 +1,165 @@
+// Detect It Easy: detection rule file
+// Authors: LinXP, Kae (TG@kaens)
+// doc-ref: http://www.libpng.org/pub/png/spec/1.2/PNG-Contents.html
+
+init("image", "");
+
+function detect() {
+    if (File.compare("89'PNG'0D0A1A0A........'IHDR'")) {
+        bDetected = true;
+        sName = "Portable Network Graphics (.PNG)";
+        ct = File.read_uint8(0x19);
+        switch (ct) {
+            case 0:
+                sOption("grey");
+                break;
+            case 2:
+                sOption("RGB");
+                break;
+            case 3:
+                sOption("indexed");
+                break;
+            case 4:
+                sOption("grey+alpha");
+                break;
+            case 6:
+                sOption("RGBA");
+                break;
+            default:
+                sOption("unk.colour type");
+        }
+        if (File.read_uint8(0x1C)) sOption("interlaced");
+        if (File.compare("00000008'acTL'", 0x21)) {}
+        if (File.isVerbose()) {
+            var p = 8,
+                col = 0,
+                end = simplea = musthaveplte = false,
+                w = h = "?",
+                af = icc = title = auth = desc = timestamp = sw = warn = cmt = sd = "";
+            mainloop: while (!end && p < File.getSize()) {
+                hksz = File.read_uint32(p, _BE);
+                hkhd = File.read_ansiString(p + 4, 4);
+                if (p + 12 + hksz > File.getSize()) { sVersion += "!short"; break }
+                // the CRC algo in DiE seems to be different for this:
+                // crc = File.calculateCRC32(p,8+hksz); ccrc = File.read_uint32(p+8+hksz,_BE);
+                // if(crc != ccrc) sVersion += "!badchunk "//+hkhd+"@"+Hex(p);
+                p += 8;
+                switch (hkhd) {
+                    case "IEND":
+                        end = true;
+                        break;
+                    case "IHDR":
+                        w = File.read_uint32(p, _BE);
+                        h = File.read_uint32(p + 4, _BE);
+                        col = 1 << File.read_uint8(p + 8);
+                        musthaveplte = File.read_uint8(p + 9) == 3;
+                        break;
+                    case "PLTE":
+                        musthaveplte = false;
+                        break;
+                    case "tRNS":
+                        simplea = true;
+                        break;
+                    case "iCCP":
+                        icc = File.read_codePageString(p, 79, "CP850");
+                        break;
+                    case "iTXt":
+                    case "tEXt":
+                        var i = p;
+                        if (hkhd === "iTXt") {
+                            t1 = File.read_codePageString(i, 79, "CP850").toLowerCase();
+                            i += t1.length + 1;
+                            if (!File.read_uint8(i += 2)) break; //not messing with compressed tags
+                            t = File.read_codePageString(i, 0x100, "CP850");
+                            i += t.length + 1; //language tag
+                            t = File.read_codePageString(i, 0x100, "CP850");
+                            i += t.length + 1; //translated keyword
+                            t2 = File.read_utf8String(i, hksz - i);
+                        } else {
+                            t1 = File.read_codePageString(p, 79, "CP850").toLowerCase();
+                            i += t1.length + 1;
+                            t2 = File.read_codePageString(i, hksz - i, "CP850")
+                        }
+                        _log("t1:" + t1.slice(0, 4));
+                        switch (t1) {
+                            case "title":
+                                title = t2;
+                                break;
+                            case "author":
+                                auth = t2;
+                                break;
+                            case "description":
+                                desc = t2;
+                                break;
+                            case "creation time":
+                                timestamp = t2;
+                                break;
+                            case "software":
+                                sw = t2;
+                                break;
+                            case "warning":
+                                warn = t2;
+                                break;
+                            case "comment":
+                                cmt = t2;
+                                break;
+                            default:
+                                if (t1.slice(0, 4) == "xml:") desc = desc.append("XML info found")
+                        }
+                        break;
+                    case "sBIT":
+                        switch (ct) {
+                            case 0:
+                                sd = File.read_uint8(p);
+                                break;
+                            case 2:
+                            case 3:
+                                sd = "R" + File.read_uint8(p) + "G" + File.read_uint8(p + 1) +
+                                    "B" + File.read_uint8(p + 2);
+                                break;
+                            case 4:
+                                sd = "g" + File.read_uint8(p) + "a" + File.read_uint8(p + 1);
+                                break;
+                            case 6:
+                                sd = "R" + File.read_uint8(p) + "G" + File.read_uint8(p + 1) +
+                                    "B" + File.read_uint8(p + 2) + "a" + File.read_uint8(p + 3);
+                                break;
+                        }
+                    case "tIME":
+                        timestamp = "UTC" + File.read_uint16(p, _BE) + "-" +
+                            File.read_uint8(p + 2) + "-" + File.read_uint8(p + 3) + "T" +
+                            File.read_uint8(p + 4) + ":" + File.read_uint8(p + 5) + ":" + File.read_uint8(p + 6);
+                        break;
+                    case "acTL":
+                        sName = "Animated Portable Network Graphics (.PNG)";
+                        af = Binary.read_uint32(p, _BE);
+                        break;
+                    default:
+                        for (i = 0; i < 4; i++) {
+                            var c = hkhd[i];
+                            if (c < 'A' || (c > 'Z' && c < 'a') || c > 'z') { sVersion += "!badchunkheader"; break }
+                        }
+                }
+                p += 4 + hksz;
+            }
+            if (musthaveplte) sVersion += "!badpalette";
+            if (!end) sVersion += "!noIEND";
+            sOption(w + "x" + h);
+            sOption(col, "colours:");
+            sOption(af, "frames:");
+            sOption(sd, "src.depth:");
+            if (simplea) sOption("simple alpha");
+            sOptionT(icc);
+            sOption(title);
+            sOption(auth, "by:");
+            sOption(timestamp, "on:");
+            sOption(sw, "in:");
+            sOption(warn, "/!\\:");
+            sOption(addEllipsis(desc, 70, 0x200));
+            sOption(cmt);
+            sOption(p, "sz:")
+        }
+    }
+
+    return result();
+}

die/db/db/Binary/image.PSD.1.sg

@@ -0,0 +1,63 @@
+// Detect It Easy: detection rule file
+// Author: LinXP
+// doc-ref: https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/
+
+init("image", "Adobe Photoshop");
+
+function detect() {
+    if (Binary.getSize() >= 0x20) {
+        if (Binary.compare("'8BPS'")) {
+            bDetected = true;
+            switch (File.read_uint16(0x04, _BE)) // Version check
+            {
+                case 1:
+                    sName += " (.PSD)";
+                    sVersion = "v1.0";
+                    break;
+                case 2:
+                    sName += " BIG (.PSB)";
+                    sVersion = "v2.0";
+                    break;
+                default:
+                    bDetected = false;
+            }
+            var channelCount = Binary.read_uint16(0x0C, _BE);
+            var imageHeight = Binary.read_uint32(0x0E, _BE);
+            var imageWidth = Binary.read_uint32(0x12, _BE);
+            var bitsPerChannel = Binary.read_uint16(0x16, _BE);
+            var colorMode = Binary.read_uint16(0x18, _BE);
+            sOption(imageWidth + "x" + imageHeight);
+            switch (colorMode) {
+                case 0:
+                    sOption("Bitmap");
+                    break;
+                case 1:
+                    sOption("Gray-scale");
+                    break;
+                case 2:
+                    sOption("Indexed");
+                    break;
+                case 3:
+                    sOption("RGB");
+                    break;
+                case 4:
+                    sOption("CMYK");
+                    break;
+                case 7:
+                    sOption("Multichannel");
+                    break;
+                case 8:
+                    sOption("Duotone");
+                    break;
+                case 9:
+                    sOption("Lab");
+                    break;
+                default:
+                    bDetected = false;
+            }
+            sOption((channelCount * bitsPerChannel) + "-bit");
+        }
+    }
+
+    return result();
+}

die/db/db/Binary/image.PVR.1.sg

@@ -0,0 +1,29 @@
+// Detect It Easy: detection rule file
+// Author: LinXP
+// doc-ref: http://powervr-graphics.github.io/WebGL_SDK/WebGL_SDK/Documentation/Specifications/PVR%20File%20Format.Specification.pdf
+init("image", "");
+
+function detect() {
+    var PixelFormat = ['PVRTC 2bpp RGB', 'PVRTC 2bpp RGBA', 'PVRTC 4bpp RGB', 'PVRTC 4bpp RGBA', 'PVRTC-II 2bpp', 'PVRTC-II 4bpp',
+        'ETC1', 'BC1\\DXT1', 'DXT2', 'BC2\\DXT3', 'DXT4', 'BC3\\DXT5', 'BC4', 'BC5', 'BC6', 'BC7', 'UYVY', 'YUY2', 'BW1bpp', 'R9G9B9E5 Shared Exponent', 'RGBG8888', 'GRGB8888',
+        'ETC2 RGB', 'ETC2 RGBA', 'ETC2 RGB A1', 'EAC R11', 'EAC RG11',
+        'ASTC_4x4', 'ASTC_5x4', 'ASTC_5x5', 'ASTC_6x5', 'ASTC_6x6', 'ASTC_8x5', 'ASTC_8x6', 'ASTC_8x8', 'ASTC_10x5', 'ASTC_10x6', 'ASTC_10x8', 'ASTC_10x10',
+        'ASTC_12x10', 'ASTC_12x12', 'ASTC_3x3x3', 'ASTC_4x3x3', 'ASTC_4x4x3', 'ASTC_4x4x4', 'ASTC_5x4x4', 'ASTC_5x5x4', 'ASTC_5x5x5', 'ASTC_6x5x5', 'ASTC_6x6x5', 'ASTC_6x6x6'
+    ];
+
+    if (Binary.getSize() >= 0x34) {
+        if (Binary.compare("'PVR'03")) {
+            bDetected = true;
+            sName = "PowerVR PVR texture (.PVR)";
+            if (Binary.isVerbose()) {
+                sOption(Binary.read_uint32(0x18) + "x" + Binary.read_uint32(0x1c));
+                sOption(PixelFormat[Binary.read_uint64(0x08)]);
+                if (Binary.read_uint32(0x10)) { sOption("Linear RGB"); } else { sOption("Standard RGB"); }
+            }
+        }
+
+
+    }
+
+    return result();
+}

die/db/db/Binary/image.QOI.1.sg

@@ -0,0 +1,36 @@
+// Detect It Easy: detection rule file
+// Author: LinXP
+// doc-ref: https://qoiformat.org/qoi-specification.pdf
+
+init("image", "Quite OK Image (.QOI)");
+
+function detect() {
+    if (Binary.getSize() >= 0x0E) {
+        if (Binary.compare("'qoif'")) {
+            bDetected = true;
+            sOptions = sOptions.append(Binary.read_uint32(0x04, _BE) + "x" + Binary.read_uint32(0x08, _BE));
+            switch (File.read_uint8(0x0C)) {
+                case 3:
+                    sOption("RGB");
+                    break;
+                case 4:
+                    sOption("RGBA");
+                    break;
+                default:
+                    bDetected = false;
+            }
+            switch (File.read_uint8(0x0D)) {
+                case 0:
+                    sOption("sRGB with linear alpha");
+                    break;
+                case 1:
+                    sOption("all channels linear");
+                    break;
+                default:
+                    bDetected = false;
+            }
+        }
+    }
+
+    return result();
+}

die/db/db/Binary/image.TGA.1.sg

@@ -0,0 +1,149 @@
+// Detect It Easy: detection rule file
+// Author: Kaens (TG@kaens)
+
+init("image","Truevision Advanced Raster Graphics Adapter bitmap (.TGA,.ICB,.VDA,.VST)");
+
+includeScript("read");
+
+function detect(bShowType,bShowVersion,bShowOptions) {
+	//ref https://github.com/ImageMagick/ImageMagick/blob/main/coders/tga.c
+	// & https://www.dca.fee.unicamp.br/~martino/disciplinas/ea978/tgaffs.pdf
+	if(File.getSize() < 0x12) return false;
+	var msg = bad = "", idlen = File.read_uint8(0), cmt = File.read_uint8(1), col = 0, depth = 0,
+	  it = File.read_uint8(2), bpp = File.read_uint8(0x10), strcls = "", co = "none";
+	if((bpp < 1 || bpp >= 17) && bpp != 24 && bpp != 32) return false;
+	switch(it) {
+		case 1: if(!cmt) return; strcls = "pseudo";
+			if(File.isVerbose()) sOption("colormap"); break;
+		case 2: if(File.isVerbose()) sOption("RGB"); col = "24bit"; break;
+		case 3: if(File.isVerbose()) sOption("monochrome"); break;
+		case 9: if(!cmt) return; co = "rle"; strcls = "pseudo";
+			if(File.isVerbose()) sOption("RLE colormap"); break;
+		case 10: co = "rle"; if(File.isVerbose()) sOption("RLE RGB"); col = "24bit"; break;
+		case 11: co = "rle"; if(File.isVerbose()) sOption("RLE monochrome"); break;
+		case 32: if(!cmt) return; co = "hdr"; strcls = "pseudo";
+			if(File.isVerbose()) sOption("H/d/RLE colormap"); break;
+		case 33: if(!cmt) return; co = "hdrq"; strcls = "pseudo";
+			if(File.isVerbose()) sOption("H/d/RLE 4-pass colormap"); break;
+		default: return;
+	}
+	var sus = 0, cmin = File.read_uint16(3), cmlen = File.read_uint16(5), cmsz = File.read_uint8(7),
+	  x0 = File.read_uint16(8), y0 = File.read_uint16(0xA),
+	  w = File.read_uint16(0xC), h = File.read_uint16(0xE), attr = File.read_uint8(0x11);
+	if(!w || !h || w > 4096 || h > 2048 || x0 > 1600 || y0 > 1200 || cmsz > 32) return false;
+	// suspiciousness is probably the only way to filter out all the FPs, so let's measure that
+	if(x0) sus++; if(y0) sus++; if(w < 4) sus++; if(h < 4) sus++; if(w > 1600) sus++; if(h > 1200) sus++;
+	if(!cmsz && cmlen) return false;
+	if(cmt == 1 && (it == 2 || it == 10)) sus++; //shouldn't have colour maps with True-color
+	if(cmsz < 15 || isWithin(cmsz,17,23) || isWithin(cmsz,25,31)) sus++; if(cmlen > 256) sus++; if(cmin) sus++;
+	if(it == 0) { if(cmin) sus++; if(cmlen) sus++; if(cmsz) sus++ }
+	if(it != 1 && it != 9 && it != 32 && it != 33) depth = bpp <= 8 ? 8 : (bpp <= 16 ? 5 : 8);
+	else depth = cmsz <= 8 ? 8 : (cmsz <= 16 ? 5 : 8);
+	var col = 1 << depth;
+	if(strcls == "pseudo")
+		if(cmt) col = cmin+cmlen;
+		else { col = 1 << bpp; if(col > File.getSize()) return }
+	p = 0x12;
+	if(idlen) msg = File.read_ansiString(p, idlen); p += idlen;
+//_log("colormap? @"+Hex(p)+"  type:"+cmt+" index:"+cmin+" len:"+cmlen+" size:"+cmsz);
+	if(cmt) {
+		if(col < cmin) col = cmin;
+		switch(cmsz) {
+		case 8: default: p += col; break;
+		case 15: case 16: p += col*2; break;
+		case 24: p += col*3; break;
+		case 32: p += col*4; break;
+		}
+	}
+	if(cmlen > col) sus++;
+	if(sus > 3) {
+//_log('TGAFault: '+sus+'-fold suspicious!');
+		return
+	}
+
+	//unpack!
+	var pix = base = flag = skip = index = runlen = ofs = 0, ofsss = 1;
+	if(((attr&0xC0)>>6) == 2) ofsss = 2;
+	if(co != "hdr" && co != "hdrq")
+		for(var y = 0; y < h && p < File.getSize(); y++) {
+			for(var x = 0; x < w && p < File.getSize(); x++) {
+				if(co == "rle")
+					if(runlen) {runlen--; skip = flag != 0 }
+					else {
+						runlen = File.read_uint8(p++);
+						skip = 0; flag = runlen&0x80; if(flag) runlen -= 0x80;
+					}
+				if(!skip) switch(bpp) {
+					case 1: if(!(x&7)) p++; break;
+					case 8: default: p++; break;
+					case 15: case 16: p += 2; break;
+					case 24: p += 3; break;
+					case 32: p += 4; break;
+					}
+			}
+		}
+	else p = 0; //giving up on reading huffman/delta etc. (not even Imagemagick can do that)
+	ofs += ofsss; if(ofs > w) { base++; ofs = base }
+	if(p > File.getSize())
+		if(File.isHeuristicScan())
+			bad = bad.addIfNone("!short");
+		else return; //because the format is shaky and FPs are more than possible
+
+	ea = 0;
+	if(File.isHeuristicScan()) {
+		ext = File.findSignature(p,0x1000,"'TRUEVISION-XFILE.'00");
+		if(ext > 0) {
+			function isNewTGA() {
+				//let's see if it's not us accidentally catching the next resource.
+				ea = File.read_uint32(ext-8); var dd = File.read_uint32(ext-4);
+				if(p > ext-8 || (ea && p > ea) || (dd && p > dd) || ((dd||ea) && ea == dd) ||
+					(ea && ea+File.read_uint16(ea) > ext) ||
+					(dd && ea && ea < dd && ea+File.read_uint16(ea) > dd))
+					return false; //false alarm
+				if(dd) {
+					var ddtn = File.read_uint16(dd); var dsz = ddtn*10+2;
+					if(dd+dsz > ext || (ea && dd+dsz > ea)) return false; 
+					for(i=0; i < ddtn; i++) {
+						var dtp = File.read_uint32(dd+4+i*10), dtsz = File.read_uint32(dd+8+i*10);
+						if(dtp+dtsz > ext || dtp+dtsz < p) return false;
+					}
+				}
+				if(ea) {
+					if(File.read_uint16(ea) == 495) sV = "v2.0"; else sV = "v2.x";
+					auth = File.read_ansiString(ea+2,41);
+					xmsg = File.read_ansiString(ea+43,324);
+					timestamp = File.read_uint16(ea+371)+"-"+File.read_uint16(ea+369)+"-"+
+					  File.read_uint16(ea+367)+" "+
+					  File.read_uint16(ea+373)+":"+File.read_uint16(ea+375)+":"+File.read_uint16(ea+377);
+					sw = File.read_ansiString(ea+426,41).trim()+" v"+
+					  Math.floor(File.read_uint16(ea+467)/100).toString()+'.'+
+					  (File.read_uint16(ea+467)%100).toString()+File.read_ansiString(ea+469,1),
+					gamma = (File.read_uint16(ea+478)/File.read_uint16(ea+480)).toFixed(1);
+				}
+				else sV = "v2.x";
+				return true
+			}
+
+			if(isNewTGA()) {
+				sVersion = sV; p = ext+18;
+			}
+		} else sVersion = "v1.x";
+	}
+	else sVersion = "v1.x";
+	if(File.isVerbose()) {
+		sOption(w+"x"+h+" ("+x0+","+y0+")");
+		sOption(bpp,"bpp:");
+		if(bpp < 24) sOption(col,"colours:");
+		if(ea) {
+			sOption(gamma,"gamma:");
+			sOptionT(auth,"by:"); sOption(timestamp,"on:"); sOption(sw,"in:"); sOption(xmsg)
+		}
+		if(co != "rle" || File.isDeepScan()) sOption(outSz(p),"sz:")
+	}
+	if(bad != "") sVersion += "/malformed"+bad;
+
+	bDetected = true;
+	return result(bShowType,bShowVersion,bShowOptions);
+
+    return result();
+}