/*****************************************************************************/
// tiffinfo
// Written by Michael Wilber, Haiku Translation Kit Team
//
// Version:
//
// tiffinfo is a command line program for displaying text information about
// TIFF images. This information includes a listing of every field (tag) in
// the TIFF file, for every image in the file.  Also, for some fields,
// the numerical value for the field is converted to descriptive text.
//
// This application and all source files used in its construction, except 
// where noted, are licensed under the MIT License, and have been written 
// and are:
//
// Copyright (c) 2003 Haiku Project
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
// and/or sell copies of the Software, and to permit persons to whom the 
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included 
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
/*****************************************************************************/
#include <ByteOrder.h>
#include <File.h>
#include <StorageDefs.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct IFDEntry {
        uint16 tag;
                // uniquely identifies the field
        uint16 fieldType;
                // number, string, float, etc.
        uint32 count;
                // length / number of values
                
        // The actual value or the file offset
        // where the actual value is located
        union {
                float   floatval;
                uint32  longval;
                uint16  shortvals[2];
                uint8   bytevals[4];
        };
};

enum ENTRY_TYPE {
        TIFF_BYTE = 1,
        TIFF_ASCII,
        TIFF_SHORT,
        TIFF_LONG,
        TIFF_RATIONAL,
        TIFF_SBYTE,
        TIFF_UNDEFINED,
        TIFF_SSHORT,
        TIFF_SLONG,
        TIFF_SRATIONAL,
        TIFF_FLOAT,
        TIFF_DOUBLE
};

const char *
get_type_string(uint16 type)
{
        const char *kstrTypes[] = {
                "Byte",
                "ASCII",
                "Short",
                "Long",
                "Rational",
                "Signed Byte",
                "Undefined",
                "Signed Short",
                "Signed Long",
                "Signed Rational",
                "Float",
                "Double"
        };
        
        if (type >= 1 && type <= 12)
                return kstrTypes[type - 1];
        else
                return "?";
}

const char *
get_tag_string(uint16 tag)
{
        switch (tag) {
                case 254: return "New Subfile Type";
                case 255: return "Subfile Type";
                case 256: return "Image Width";
                case 257: return "Image Height";
                case 258: return "Bits Per Sample";
                case 259: return "Compression";
                case 262: return "Photometric Interpretation";
                case 263: return "Thresholding";
                case 264: return "CellWidth";
                case 265: return "CellLength";
                case 266: return "Fill Order";
                case 269: return "Document Name";
                case 270: return "Image Description";
                case 271: return "Make";
                case 272: return "Model";
                case 273: return "Strip Offsets";
                case 274: return "Orientation";
                case 277: return "Samples Per Pixel";
                case 278: return "Rows Per Strip";
                case 279: return "Strip Byte Counts";
                case 280: return "Min Sample Value";
                case 281: return "Max Sample Value";
                case 282: return "X Resolution";
                case 283: return "Y Resolution";
                case 284: return "Planar Configuration";
                case 285: return "Page Name";
                case 286: return "X Position";
                case 287: return "Y Position";
                case 288: return "Free Offsets";
                case 289: return "Free Byte Counts";
                case 290: return "Gray Response Unit";
                case 291: return "Gray Response Curve";
                case 292: return "T4 Options";
                case 293: return "T6 Options";
                case 296: return "Resolution Unit";
                case 297: return "Page Number";
                case 305: return "Software";
                case 306: return "DateTime";
                case 315: return "Artist";
                case 316: return "Host Computer";
                case 320: return "Color Map";
                case 322: return "Tile Width";
                case 323: return "Tile Height";
                case 324: return "Tile Offsets";
                case 325: return "Tile Byte Counts";
                case 338: return "Extra Samples";
                case 339: return "Sample Format";
                case 529: return "YCbCr Coefficients";
                case 530: return "YCbCr Subsampling";
                case 531: return "YCbCr Positioning";
                case 532: return "Reference Black White";
                case 32995: return "Matteing";
                case 32996: return "Data Type"; // obseleted by SampleFormat tag
                case 32997: return "Image Depth"; // tile / strip calculations
                case 32998: return "Tile Depth"; // tile / strip calculations
                case 33432: return "Copyright";         
                case 37439: return "StoNits?";
                
                default:
                        return "?";
        }
}

void
print_ifd_value(IFDEntry &entry, BFile &file, swap_action swp)
{
        switch (entry.tag) {
                case 254: // NewSubfileType
                        if (entry.count == 1 && entry.fieldType == TIFF_LONG) {
                                if (entry.longval & 1)
                                        printf("Low Res (1) ");
                                if (entry.longval & 2)
                                        printf("Page (2) ");
                                if (entry.longval & 4)
                                        printf("Mask (4) ");
                                
                                printf("(0x%.8lx)", entry.longval);
                                return;
                        }
                        break;
                        
                case 256: // ImageWidth
                case 257: // ImageHeight
                        if (entry.count == 1) {
                                printf("%d",
                                        ((entry.fieldType == TIFF_SHORT) ?
                                                entry.shortvals[0] : static_cast<unsigned int>(entry.longval)));
                                return;
                        }
                        break;
                        
                case 259:
                        if (entry.count == 1 && entry.fieldType == TIFF_SHORT) {
                                switch (entry.shortvals[0]) {
                                        case 1:
                                                printf("No Compression (1)");
                                                return;
                                        case 2:
                                                printf("CCITT Group 3 1-Dimensional Modified Huffman run-length encoding (2)");
                                                return;
                                        case 3:
                                                printf("Fax Group 3 (3)");
                                                return;
                                        case 4:
                                                printf("Fax Group 4 (4)");
                                                return;
                                        case 5:
                                                printf("LZW (5)");
                                                return;
                                        case 32773:
                                                printf("PackBits (32773)");
                                                return;
                                }
                        }
                        break;
                        
                case 262: // PhotometricInterpretation
                        if (entry.count == 1 && entry.fieldType == TIFF_SHORT) {
                                switch (entry.shortvals[0]) {
                                        case 0:
                                                printf("White is Zero (%d)", entry.shortvals[0]);
                                                return;
                                        case 1:
                                                printf("Black is Zero (%d)", entry.shortvals[0]);
                                                return;
                                        case 2:
                                                printf("RGB (%d)", entry.shortvals[0]);
                                                return;
                                        case 3:
                                                printf("Palette Color (%d)", entry.shortvals[0]);
                                                return;
                                        case 4:
                                                printf("Transparency Mask (%d)", entry.shortvals[0]);
                                                return;
                                }
                        }
                        break;
                        
                case 274: // Orientation
                        if (entry.count == 1 && entry.fieldType == TIFF_SHORT) {
                                switch (entry.shortvals[0]) {
                                        case 1:
                                                printf("top to bottom, left to right (1)");
                                                return;
                                        case 2:
                                                printf("top to bottom, right to left (2)");
                                                return;
                                        case 3:
                                                printf("bottom to top, right to left (3)");
                                                return;
                                        case 4:
                                                printf("bottom to top, left to right (4)");
                                                return;
                                        case 5:
                                                printf("left to right, top to bottom (5)");
                                                return;
                                        case 6:
                                                printf("right to left, top to bottom (6)");
                                                return;
                                        case 7:
                                                printf("right to left, bottom to top (7)");
                                                return;
                                        case 8:
                                                printf("left to right, bottom to top (8)");
                                                return;
                                }
                        }
                        break;
                        
                case 278: // RowsPerStrip
                {
                        const uint32 ksinglestrip = 0xffffffffUL;
                        printf("%u",
                                        static_cast<unsigned int>(entry.longval));
                        if (entry.longval == ksinglestrip)
                                printf(" (All rows in first strip)");
                        return;
                }
                        
                case 284: // PlanarConfiguration
                        if (entry.count == 1 && entry.fieldType == TIFF_SHORT) {
                                if (entry.shortvals[0] == 1) {
                                        printf("Chunky (%d)", entry.shortvals[0]);
                                        return;
                                }
                                else if (entry.shortvals[0] == 2) {
                                        printf("Planar (%d)", entry.shortvals[0]);
                                        return;
                                }
                        }
                        break;
                        
                case 296: // ResolutionUnit
                        if (entry.count == 1 && entry.fieldType == TIFF_SHORT) {
                                switch (entry.shortvals[0]) {
                                        case 1:
                                                printf("None (%d)", entry.shortvals[0]);
                                                return;
                                        case 2:
                                                printf("Inch (%d)", entry.shortvals[0]);
                                                return;
                                        case 3:
                                                printf("Cenimeter (%d)", entry.shortvals[0]);
                                                return;
                                }
                        }
                        break;
                        
                default:
                        if (entry.fieldType == TIFF_ASCII) {
                                char ascfield[256] = { 0 };
                                
                                if (entry.count <= 4)
                                        memcpy(ascfield, &entry.longval, entry.count);
                                else if (entry.count > 4 && entry.count < 256) {
                                        ssize_t nread = file.ReadAt(entry.longval, ascfield, entry.count);
                                        if (nread != static_cast<ssize_t>(entry.count))
                                                ascfield[0] = '\0';
                                }
                                
                                if (ascfield[0] != '\0') {
                                        printf("%s", ascfield);
                                        return;
                                }
                        } else if (entry.fieldType == TIFF_RATIONAL && entry.count == 1) {
                                struct { uint32 numerator; uint32 denominator; } rational;
                                
                                ssize_t nread = file.ReadAt(entry.longval, &rational, 8);
                                if (nread == 8 &&
                                        swap_data(B_UINT32_TYPE, &rational, 8, swp) == B_OK) {
                                        
                                        printf("%u / %u (offset: 0x%.8lx)",
                                                static_cast<unsigned int>(rational.numerator),
                                                static_cast<unsigned int>(rational.denominator),
                                                entry.longval);
                                        return;
                                }                               
                        } else if (entry.fieldType == TIFF_SRATIONAL && entry.count == 1) {
                                struct { int32 numerator; int32 denominator; } srational;
                                
                                ssize_t nread = file.ReadAt(entry.longval, &srational, 8);
                                if (nread == 8 &&
                                        swap_data(B_INT32_TYPE, &srational, 8, swp) == B_OK) {
                                        
                                        printf("%d / %d (offset: 0x%.8lx)",
                                                static_cast<int>(srational.numerator),
                                                static_cast<int>(srational.denominator),
                                                entry.longval);
                                        return;
                                }                               
                        } else if (entry.fieldType == TIFF_LONG && entry.count == 1) {
                                printf("%u",
                                        static_cast<unsigned int>(entry.longval));
                                return;
                        } else if (entry.fieldType == TIFF_SLONG && entry.count == 1) {
                                printf("%d",
                                        static_cast<int>(entry.longval));
                                return;
                        } else if (entry.fieldType == TIFF_SHORT && entry.count <= 2) {
                                for (uint32 i = 0; i < entry.count; i++) {
                                        if (i > 0)
                                                printf(", ");
                                        printf("%u", entry.shortvals[i]);
                                }
                                return;
                        } else if (entry.fieldType == TIFF_SSHORT && entry.count <= 2) {
                                for (uint32 i = 0; i < entry.count; i++) {
                                        if (i > 0)
                                                printf(", ");
                                        printf("%d", entry.shortvals[i]);
                                }
                                return;
                        } else if (entry.fieldType == TIFF_BYTE && entry.count <= 4) {
                                for (uint32 i = 0; i < entry.count; i++) {
                                        if (i > 0)
                                                printf(", ");
                                        printf("%u", entry.bytevals[i]);
                                }
                                return;
                        } else if (entry.fieldType == TIFF_SBYTE && entry.count <= 4) {
                                for (uint32 i = 0; i < entry.count; i++) {
                                        if (i > 0)
                                                printf(", ");
                                        printf("%d", entry.bytevals[i]);
                                }
                                return;
                        } else if (entry.fieldType == TIFF_UNDEFINED && entry.count <= 4) {
                                for (uint32 i = 0; i < entry.count; i++) {
                                        if (i > 0)
                                                printf(", ");
                                        printf("0x%.2lx",
                                                static_cast<unsigned long>(entry.bytevals[i]));
                                }
                                return;
                        }
                        break;
        }
        printf("0x%.8lx", entry.longval);
}

int swap_value_field(IFDEntry &entry, swap_action swp)
{
        switch (entry.fieldType) {
                case TIFF_BYTE:
                case TIFF_ASCII:
                case TIFF_SBYTE:
                case TIFF_UNDEFINED:
                        if (entry.count > 4) {
                                if (swap_data(B_UINT32_TYPE, &entry.longval, 4, swp) != B_OK)
                                        return 0;
                        }
                        return 1;
                        
                case TIFF_LONG:
                case TIFF_SLONG:
                case TIFF_RATIONAL:
                case TIFF_SRATIONAL:
                case TIFF_DOUBLE:
                        if (swap_data(B_UINT32_TYPE, &entry.longval, 4, swp) != B_OK)
                                return 0;
                        return 1;
                        
                case TIFF_FLOAT:
                        if (swap_data(B_FLOAT_TYPE, &entry.floatval, 4, swp) != B_OK)
                                return 0;
                        return 1;
                        
                case TIFF_SHORT:
                case TIFF_SSHORT:
                        if (entry.count <= 2) {
                                if (swap_data(B_UINT16_TYPE, &entry.shortvals,
                                        entry.count * 2, swp) != B_OK)
                                        return 0;
                        } else {
                                if (swap_data(B_UINT32_TYPE, &entry.longval, 4, swp) != B_OK)
                                        return 0;
                        }
                                
                        return 1;
        }
        
        // no error, but unknown type
        return 2;
}

int
report_ifd_entries(BFile &file, uint16 entrycount, swap_action swp)
{
        IFDEntry entry;
        
        if (sizeof(IFDEntry) != 12) {
                printf("IFDEntry size must be 12\n");
                return 0;
        }
        
        off_t offset = file.Position();
        for (uint16 i = 0; i < entrycount; offset += 12, i++) {
                ssize_t nread = file.Read(&entry, 12);
                if (nread != 12) {
                        printf("unable to read entire ifd entry\n");
                        return 0;
                }       
                if (swap_data(B_UINT16_TYPE, &entry.tag, 4, swp) != B_OK ||
                        swap_data(B_UINT32_TYPE, &entry.count, 4, swp) != B_OK) {
                        printf("swap_data failed\n");
                        return 0;
                }
                
                if (!swap_value_field(entry, swp)) {
                        printf("swap_value_field failed\n");
                        return 0;
                }
                
                printf("\nOffset: 0x%.8lx\n", static_cast<unsigned long>(offset));
                printf(  "   Tag: %s (%d)\n", get_tag_string(entry.tag), entry.tag);
                printf(  "  Type: %s (%d)\n", get_type_string(entry.fieldType),
                        entry.fieldType);
                printf(  " Count: %d\n", static_cast<int>(entry.count));
                printf(  " Value: ");
                print_ifd_value(entry, file, swp);
                printf("\n");
        }
        
        return 1;
}

int
report_ifd(BFile &file, uint32 ifdoffset, swap_action swp)
{
        printf("\n<< BEGIN: IFD at 0x%.8lx >>\n\n", ifdoffset);
        
        if (file.Seek(ifdoffset, SEEK_SET) != ifdoffset) {
                printf("failed to seek to IFD offset: %d\n",
                        static_cast<unsigned int>(ifdoffset));
                return 0;
        }
        
        uint16 entrycount = 0;
        ssize_t nread = file.Read(&entrycount, 2);
        if (nread != 2) {
                printf("unable to read entry count\n");
                return 0;
        }
        if (swap_data(B_UINT16_TYPE, &entrycount, sizeof(uint16), swp) != B_OK) {
                printf("failed to swap entrycount\n");
                return 0;
        }
        printf("Entry Count: %d\n", entrycount);
        
        // Print out entries
        int ret = report_ifd_entries(file, entrycount, swp);
        
        if (ret) {
                uint32 nextIFDOffset = 0;
                
                nread = file.Read(&nextIFDOffset, 4);
                if (nread != 4) {
                        printf("unable to read next IFD\n");
                        return 0;
                }
                if (swap_data(B_UINT32_TYPE, &nextIFDOffset, sizeof(uint32), swp) != B_OK) {
                        printf("failed to swap next IFD\n");
                        return 0;
                }
                
                printf("Next IFD Offset: 0x%.8lx\n", nextIFDOffset);
                printf("\n<< END: IFD at 0x%.8lx >>\n\n", ifdoffset);
                
                if (nextIFDOffset != 0)
                        return report_ifd(file, nextIFDOffset, swp);
                else
                        return 1;
                
        } else
                return 0;
}

int generate_report(const char *filepath)
{
        BFile file(filepath, B_READ_ONLY);
        
        if (file.InitCheck() == B_OK) {
        
                uint8 buffer[64];
                
                // Byte Order
                const uint8 kleSig[] = { 0x49, 0x49, 0x2a, 0x00 };
                const uint8 kbeSig[] = { 0x4d, 0x4d, 0x00, 0x2a };
                
                ssize_t nread = file.Read(buffer, 4);
                if (nread != 4) {
                        printf("Unable to read first 4 bytes\n");
                        return 0;
                }
                
                swap_action swp;
                if (memcmp(buffer, kleSig, 4) == 0) {
                        swp = B_SWAP_LENDIAN_TO_HOST;
                        printf("Byte Order: little endian\n");
                        
                } else if (memcmp(buffer, kbeSig, 4) == 0) {
                        swp = B_SWAP_BENDIAN_TO_HOST;
                        printf("Byte Order: big endian\n");
                        
                } else {
                        printf("Invalid byte order value\n");
                        return 0;
                }
                
                // Location of first IFD
                uint32 firstIFDOffset = 0;
                nread = file.Read(&firstIFDOffset, 4);
                if (nread != 4) {
                        printf("Unable to read first IFD offset\n");
                        return 0;
                }
                if (swap_data(B_UINT32_TYPE, &firstIFDOffset, sizeof(uint32), swp) != B_OK) {
                        printf("swap_data() error\n");
                        return 0;
                }
                printf("First IFD: 0x%.8lx\n", firstIFDOffset);
                
                // print out first IFD
                report_ifd(file, firstIFDOffset, swp);
        
                return 1;
        }
        
        return 0;
}

int main(int argc, char **argv)
{
        printf("\n");
                // put a line break at the beginning of output
                // to improve readability
        
        if (argc == 2) {
        
                printf("TIFF Image: %s\n\n", argv[1]);
                generate_report(argv[1]);
                
        } else {
        
                printf("tiffinfo - reports information about a TIFF image\n");
                printf("\nUsage:\n");
                printf("tiffinfo filename.tif\n\n");    
        }
        
        return 0;
}