die-python 0.1.0__cp38-cp38-win_amd64.whl

die/db/db/Binary/image.JPEG.camera.2.sg

@@ -0,0 +1,16 @@
+// DIE's signature file
+// Author: Jason Hood <jadoxa@yahoo.com.au>
+
+init("camera", "");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.isJpeg()) {
+        sName = Binary.getJpegExifCameraName();
+
+        if (sName != "") {
+            bDetected = true;
+        }
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

die/db/db/Binary/image.JPEG.comment.4.sg

@@ -0,0 +1,16 @@
+// DIE's signature file
+// Author: Jason Hood <jadoxa@yahoo.com.au>
+
+init("image", "comment");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.isJpeg()) {
+        sOptions = Binary.getJpegComment();
+
+        if (sOptions != "") {
+            bDetected = true;
+        }
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

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

@@ -0,0 +1,36 @@
+// DIE's signature file
+// Author: LinXP
+
+init("image", "");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    if (Binary.getSize() >= 0x40) {
+        if (Binary.compare("'«KTX 11»'0D0A1A0A")) {
+            bDetected = true;
+            sName = "Khronos Texture (.KTX)";
+            if (Binary.isVerbose()) {
+                sOption(Binary.read_uint32(0x24) + "x" + Binary.read_uint32(0x28));
+            }
+        } else if (Binary.compare("'«KTX 20»'0D0A1A0A")) {
+            bDetected = true;
+            sName = "Khronos Texture (.KTX2)";
+            if (Binary.isVerbose()) {
+                sOption(Binary.read_uint32(0x14) + "x" + Binary.read_uint32(0x18));
+            }
+        }
+
+        // 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(bShowType, bShowVersion, bShowOptions);
+}

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(bShowType, bShowVersion, bShowOptions) {
+    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 = 1;
+    }
+
+    return result(bShowType, bShowVersion, bShowOptions);
+}

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

@@ -0,0 +1,19 @@
+// DIE's signature file
+// Author: LinXP
+// doc-ref: http://www.libpng.org/pub/mng/spec/
+
+init("image", "Multiple-image Network Graphics (.MNG)");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    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(bShowType, bShowVersion, bShowOptions);
+}

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

@@ -0,0 +1,57 @@
+// DIE's signature file
+// Authors: LinXP, Kae (TG@kaens)
+
+init("image", "ZSoft Paintbrush (.PCX)");
+
+includeScript("read");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    //ref https://www.fileformat.info/format/pcx/spec/a10e75307b3a4cc49c3bbe6db4c41fa2/view.htm
+    if (File.getSize() >= 0x0E) {
+        if (File.compare("0a") && !File.read_uint8(0x40)) {
+            switch (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/+, including 24-bit images";
+                    break;
+                default:
+                    return;
+            }
+            var rle = File.read_uint8(0x02);
+            if (rle > 1) return;
+            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;
+            if (File.isVerbose()) sOption(w + "x" + h);
+            if (rle && File.isVerbose()) sOption("RLE");
+            var bpplane = File.read_uint8(0x03),
+                nplanes = File.read_uint8(0x41);
+            if ([1, 2, 4, 8].indexOf(bpplane) < 0 || !isAllZeroes(0x4A, 0x36)) return;
+            var bpline = File.read_uint16(0x42);
+            if (bpline % 2 || bpline < h) return;
+            if (File.isVerbose()) {
+                sOption(bpplane * nplanes, "bpx:");
+                sOption(bpplane, "bpl:");
+                sOption(File.read_uint16(0x0C) + "x" + File.read_uint16(0x0E), "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 * bpplane * nplanes >> 3), "sz:")
+            }
+            bDetected = true;
+            return result(bShowType, bShowVersion, bShowOptions);
+        }
+    }
+    return
+}

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

@@ -0,0 +1,165 @@
+// DIE's signature file
+// Authors: LinXP, Kae (TG@kaens)
+// doc-ref: http://www.libpng.org/pub/png/spec/1.2/PNG-Contents.html
+
+init("image", "");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    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(bShowType, bShowVersion, bShowOptions);
+}

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

@@ -0,0 +1,63 @@
+// DIE's signature file
+// Author: LinXP
+// doc-ref: https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/
+
+init("image", "Adobe Photoshop");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    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(bShowType, bShowVersion, bShowOptions);
+}

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

@@ -0,0 +1,29 @@
+// DIE's signature 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(bShowType, bShowVersion, bShowOptions) {
+    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(bShowType, bShowVersion, bShowOptions);
+}

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

@@ -0,0 +1,36 @@
+// DIE's signature file
+// Author: LinXP
+// doc-ref: https://qoiformat.org/qoi-specification.pdf
+
+init("image", "Quite OK Image (.QOI)");
+
+function detect(bShowType, bShowVersion, bShowOptions) {
+    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(bShowType, bShowVersion, bShowOptions);
+}

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

@@ -0,0 +1,134 @@
+// https://github.com/horsicq/Detect-It-Easy signature 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), 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"); 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 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(x0 > 1600 || y0 > 1200) return false;
+    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, idlen);
+//_log("colormap? @"+Hex(p)+"  type:"+cmt+" index:"+cmin+" len:"+cmlen);
+    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;
+        }
+    }
+    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);
+}