/*****************************************************************************/
// pnginfo
// Written by Michael Wilber, Haiku Translation Kit Team
//
// Version:
//
// pnginfo is a command line program for displaying text information about
// PNG images.
//
// 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) 2004 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <png.h>
#include <ByteOrder.h>
#include <File.h>
#include <TranslatorFormats.h>
#include <StorageDefs.h>

 /* The png_jmpbuf() macro, used in error handling, became available in
  * libpng version 1.0.6.  If you want to be able to run your code with older
  * versions of libpng, you must define the macro yourself (but only if it
  * is not already defined by libpng!).
  */

#ifndef png_jmpbuf
#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
#endif

//// libpng Callback functions!
BPositionIO *
get_pio(png_structp ppng)
{
        BPositionIO *pio = NULL;
        pio = static_cast<BPositionIO *>(png_get_io_ptr(ppng));
        return pio;
}

void
pngcb_read_data(png_structp ppng, png_bytep pdata, png_size_t length)
{
        BPositionIO *pio = get_pio(ppng);
        pio->Read(pdata, static_cast<size_t>(length));
}

void
pngcb_write_data(png_structp ppng, png_bytep pdata, png_size_t length)
{
        BPositionIO *pio = get_pio(ppng);
        pio->Write(pdata, static_cast<size_t>(length));
}

void
pngcb_flush_data(png_structp ppng)
{
        // I don't think I really need to do anything here
}
//// End: libpng Callback functions

void
PrintPNGInfo(const char *path)
{
        printf("\n--- %s ---\n", path);
        
        BFile *pfile;
        pfile = new BFile(path, B_READ_ONLY);
        if (!pfile || pfile->InitCheck() != B_OK) {
                printf("Error: unable to open the file\n");
                return;
        }
        BPositionIO *pio = static_cast<BPositionIO *>(pfile);

        const int32 kSigSize = 8;
        uint8 buf[kSigSize];
        if (pio->Read(buf, kSigSize) != kSigSize) {
                printf("Error: unable to read PNG signature\n");
                return;
        }
        if (!png_check_sig(buf, kSigSize)) {
                // if first 8 bytes of stream don't match PNG signature bail
                printf("Error: file doesn't begin with PNG signature\n");
                return;
        }

        // use libpng to get info about the file
        png_structp ppng = NULL;
        png_infop pinfo = NULL;
        while (ppng == NULL) {
                // create PNG read pointer with default error handling routines
                ppng = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
                if (!ppng)
                        break;
                // alocate / init memory for image information
                pinfo = png_create_info_struct(ppng);
                if (!pinfo)
                        break;
                // set error handling
                if (setjmp(png_jmpbuf(ppng))) {
                        // When an error occurs in libpng, it uses
                        // the longjmp function to continue execution
                        // from this point
                        printf("Error: error in libpng function\n");
                        break;
                }
                
                // set read callback function
                png_set_read_fn(ppng, static_cast<void *>(pio), pngcb_read_data);
                
                // Read in PNG image info
                png_set_sig_bytes(ppng, 8);
                png_read_info(ppng, pinfo);

                png_uint_32 width, height;
                int bit_depth, color_type, interlace_type, compression_type, filter_type;
                png_get_IHDR(ppng, pinfo, &width, &height, &bit_depth, &color_type,
                        &interlace_type, &compression_type, &filter_type);

                printf("                   width: %lu\n", width);
                printf("                  height: %lu\n", height);
                printf("               row bytes: %lu\n", pinfo->rowbytes);
                printf("bit depth (bits/channel): %d\n", bit_depth);
                printf("                channels: %d\n", pinfo->channels);
                printf("pixel depth (bits/pixel): %d\n", pinfo->pixel_depth);
                printf("              color type: ");
                const char *desc = NULL;
                switch (color_type) {
                        case PNG_COLOR_TYPE_GRAY:
                                desc = "Grayscale";
                                break;
                        case PNG_COLOR_TYPE_PALETTE:
                                desc = "Palette";
                                break;
                        case PNG_COLOR_TYPE_RGB:
                                desc = "RGB";
                                break;
                        case PNG_COLOR_TYPE_RGB_ALPHA:
                                desc = "RGB + Alpha";
                                break;
                        case PNG_COLOR_TYPE_GRAY_ALPHA:
                                desc = "Grayscale + Alpha";
                                break;
                        default:
                                desc = "Unknown";
                                break;
                }
                printf("%s (%d)\n", desc, color_type);
                
                printf("             interlacing: ");
                switch (interlace_type) {
                        case PNG_INTERLACE_NONE:
                                desc = "None";
                                break;
                        case PNG_INTERLACE_ADAM7:
                                desc = "Adam7";
                                break;
                        default:
                                desc = "Unknown";
                                break;
                }
                printf("%s (%d)\n", desc, interlace_type);
                
                printf("        compression type: ");
                switch (compression_type) {
                        case PNG_COMPRESSION_TYPE_DEFAULT:
                                desc = "Default: Deflate method 8, 32K window";
                                break;
                        default:
                                desc = "Unknown";
                                break;
                }
                printf("%s (%d)\n", desc, compression_type);
                
                printf("             filter type: ");
                switch (filter_type) {
                        case PNG_FILTER_TYPE_DEFAULT:
                                desc = "Single row per-byte";
                                break;
                        case PNG_INTRAPIXEL_DIFFERENCING:
                                desc = "Intrapixel Differencing [for MNG files]";
                                break;
                        default:
                                desc = "Unknown";
                                break;
                }
                printf("%s (%d)\n", desc, filter_type);
        }
        if (ppng) {
                // free PNG handle / info structures
                if (!pinfo)
                        png_destroy_read_struct(&ppng, png_infopp_NULL, png_infopp_NULL);
                else
                        png_destroy_read_struct(&ppng, &pinfo, png_infopp_NULL);
        }
        
        delete pfile;
        pfile = NULL;
}

int
main(int argc, char **argv)
{
        if (argc == 1) {
                printf("\npnginfo - reports information about PNG images\n");
                printf("\nUsage:\n");
                printf("pnginfo [options] filename.png\n\n");
        }
        else {
                int32 first = 1;
                for (int32 i = first; i < argc; i++)
                        PrintPNGInfo(argv[i]);
        }
        
        printf("\n");
        
        return 0;
}