root/trunk/orca/gl/png_load.c

//============================================================================
//
// Orca PNG Loader
//
//============================================================================


#include <assert.h>
#include <png.h>
#include "gx.h"
#include "os.h"
#include "ovalue.h"


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


//#define PRINT_IMAGE

static void make_image( png_structp png, png_infop info )
{
    OBinary* bin;
    png_uint_32 width, height;
    int bit_depth, color_type, interlace_type, compression_type, filter_type;
    png_bytepp row_pointers;

    png_get_IHDR( png, info, &width, &height, &bit_depth, &color_type,
                  &interlace_type, &compression_type, &filter_type );

#ifdef PRINT_IMAGE
    dprint( "\n%ldx%ld bit_depth: %d color_type: %d\n", width, height,
            bit_depth, color_type );
#endif

    if( bit_depth == 8 )
    {
        int png_bpp = bit_depth / 8;
        int format = OR_IMG_GRAY;

        if( color_type == PNG_COLOR_TYPE_PALETTE )
        {
            orError( "png palette not supported" );
            return;
        }
        else if( color_type == PNG_COLOR_TYPE_RGB )
        {
            png_bpp *= 3;
            format = OR_IMG_RGB;
        }
        else if( color_type == PNG_COLOR_TYPE_RGB_ALPHA )
        {
            png_bpp *= 4;
            format = OR_IMG_RGBA;
        }

        bin = orMakeImage( format, width, height );
        {
        OValue* a1 = orTOS;
        orResult( OT_IMAGE, orBinaryN(bin) );
        }

        if( bin->byteArray )
        {
            png_uint_32 y;
            int png_bpl = width * png_bpp;
#define bpl     png_bpl
            //int bpl = orImageBytesPerLine(img);
            char* dest = (char*) orImagePixels(bin);

            //dprint( "KR %ldx%ld depth: %d color: %d bpp: %d\n",
            //        width, height, bit_depth, color_type, png_bpp );

            row_pointers = png_get_rows( png, info );

            for( y = 0; y < height; y++ )
            {
                memCpy( dest, row_pointers[ y ], png_bpl );
                dest += bpl;
#ifdef PRINT_IMAGE
                png_bytep c, end;
                c = row_pointers[ y ];
                end = c + png_bpl;
                for( ; c != end; ++c )
                {
                    dprint( "%02x", *c );
                }
                dprint( "\n" );
#endif
            }
        }
    }
    else
    {
        orError( "png bit_depth %d not supported", bit_depth );
    }
}


/**
  Generic PNG read function using the high-level png_read_png().
*/
static int load_png( FILE *fp, unsigned int sig_read )
{
    png_structp png;
    png_infop info;

    png = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
                                  /*
                                  (png_voidp) user_error_ptr,
                                  user_error_fn,
                                  user_warning_fn );
                                  */
    if( ! png )
        return 0;

    /* Allocate/initialize the memory for image information.  REQUIRED. */
    info = png_create_info_struct( png );
    if( ! info )
    {
        png_destroy_read_struct( &png, (png_infopp)NULL, (png_infopp)NULL );
        return 0;
    }

    if( setjmp( png_jmpbuf(png) ) )
    {
        /* If we get here, we had a problem reading the file */
        png_destroy_read_struct( &png, &info, (png_infopp) NULL );
        return 0;
    }

    png_init_io( png, fp ); /* Using standard C streams */
    //png_set_read_fn( png, (void*) user_io_ptr, user_read_fn );

    /* If we have already read some of the signature */
    png_set_sig_bytes( png, sig_read );

#if 0
    row_pointers = png_malloc(png_ptr, height*sizeof(png_bytep));
    for( int i=0; i<height, i++ )
        row_pointers[i]=png_malloc(png_ptr, width*pixel_size);
    png_set_rows(png_ptr, info_ptr, &row_pointers); 
#endif

    /* hilevel read */
    png_read_png( png, info, 
                  PNG_TRANSFORM_STRIP_16 |
                  PNG_TRANSFORM_PACKING |
                  PNG_TRANSFORM_EXPAND,
                  NULL );

    // At this point the image has been read (make_image calls png_get_IHDR).
    make_image( png, info );

    /* clean up after the read, and free any memory allocated - REQUIRED */
    png_destroy_read_struct( &png, &info, (png_infopp) NULL );

    return 1;
}


int png_loader( char* filename, uint8_t* sig, int sigLen )
{
    if( png_sig_cmp( sig, 0, sigLen ) == 0 )
    {
        FILE* fp = fopen( filename, "rb" );
        if( fp )
        {
            load_png( fp, 0 );
            fclose( fp );
        }
        return 1;
    }
    return 0;
}


/*EOF*/