HsHaruPDF-0.0.0: haru/hpdf_image_png.c

/*
 * << Haru Free PDF Library 2.0.3 >> -- hpdf_image.c
 *
 * Copyright (c) 1999-2006 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.
 * It is provided "as is" without express or implied warranty.
 *
 */

#include "hpdf_conf.h"
#include "hpdf_utils.h"
#include "hpdf_image.h"

#ifndef HPDF_NOPNGLIB
#include <png.h>

static void
PngErrorFunc  (png_structp       png_ptr,
               const char  *msg);


static void
PngReadFunc  (png_structp   png_ptr,
              png_bytep     data,
              png_uint_32   length)
{
    HPDF_UINT len = length;
    HPDF_Stream stream = (HPDF_Stream)png_get_io_ptr (png_ptr);

    HPDF_Stream_Read (stream, data, &len);
}


static HPDF_STATUS
LoadPngData  (HPDF_Dict     image,
              HPDF_Stream   png_data,
              HPDF_BOOL     delayed_loading);


static void
PngErrorFunc  (png_structp       png_ptr,
               const char  *msg);


static HPDF_STATUS
ReadPngData_Interlaced  (HPDF_Dict    image,
                         png_structp  png_ptr,
                         png_infop    info_ptr);


static HPDF_STATUS
ReadPngData  (HPDF_Dict    image,
              png_structp  png_ptr,
              png_infop    info_ptr);


static HPDF_STATUS
CreatePallet (HPDF_Dict    image,
              png_structp  png_ptr,
              png_infop    info_ptr);


static HPDF_STATUS
PngBeforeWrite  (HPDF_Dict obj);


static HPDF_STATUS
PngAfterWrite  (HPDF_Dict obj);


/*---------------------------------------------------------------------------*/

static void
PngErrorFunc  (png_structp       png_ptr,
               const char  *msg)
{
    char error_number[16];
    HPDF_UINT i;
    HPDF_STATUS detail_no;
    HPDF_Error error;

    /* pick out error-number from error message */
    HPDF_MemSet (error_number, 0, 16);

     for (i = 0; i < 15; i++) {
         error_number[i] = *(msg + i);
         if (*(msg + i + 1) == ' ')
             break;
     }

     error = (HPDF_Error)png_get_error_ptr (png_ptr);
     detail_no = (HPDF_STATUS)HPDF_AToI (error_number);
     HPDF_SetError (error, HPDF_LIBPNG_ERROR, detail_no);
}


static HPDF_STATUS
ReadPngData_Interlaced  (HPDF_Dict    image,
                         png_structp  png_ptr,
                         png_infop    info_ptr)
{
    png_uint_32 len = png_get_rowbytes(png_ptr, info_ptr);
    png_bytep* row_pointers = HPDF_GetMem (image->mmgr,
                info_ptr->height * sizeof (png_bytep));

    if (row_pointers) {
        HPDF_UINT i;

        HPDF_MemSet (row_pointers, 0, info_ptr->height * sizeof (png_bytep));
        for (i = 0; i < (HPDF_UINT)info_ptr->height; i++) {
            row_pointers[i] = HPDF_GetMem (image->mmgr, len);

            if (image->error->error_no != HPDF_OK)
                break;
        }

        if (image->error->error_no == HPDF_OK) {
/*      } else {                                              remove this line */
            png_read_image(png_ptr, row_pointers);
/*            if (image->error->error_no != HPDF_OK) {        remove this line */
            if (image->error->error_no == HPDF_OK) {       /* add this line */
                for (i = 0; i < (HPDF_UINT)info_ptr->height; i++) {
                    if (HPDF_Stream_Write (image->stream, row_pointers[i], len) !=
                            HPDF_OK)
                        break;
                }
            }
        }

        /* clean up */
        for (i = 0; i < (HPDF_UINT)info_ptr->height; i++) {
            HPDF_FreeMem (image->mmgr, row_pointers[i]);
/*          i--                                               remove this line */
        }

        HPDF_FreeMem (image->mmgr, row_pointers);
    }

    return image->error->error_no;
}

static HPDF_STATUS
ReadPngData  (HPDF_Dict    image,
              png_structp  png_ptr,
              png_infop    info_ptr)
{
    png_uint_32 len = png_get_rowbytes(png_ptr, info_ptr);
    png_bytep buf_ptr = HPDF_GetMem (image->mmgr, len);

    if (buf_ptr) {
        HPDF_UINT i;

        for (i = 0; i < (HPDF_UINT)info_ptr->height; i++) {
            png_read_rows(png_ptr, (png_byte**)&buf_ptr, NULL, 1);
            if (image->error->error_no != HPDF_OK)
                break;

            if (HPDF_Stream_Write (image->stream, buf_ptr, len) != HPDF_OK)
                break;
        }

        HPDF_FreeMem (image->mmgr, buf_ptr);
    }

    return image->error->error_no;
}


static HPDF_STATUS
CreatePallet (HPDF_Dict    image,
              png_structp  png_ptr,
              png_infop    info_ptr)
{
    HPDF_INT num_pl = 0;
    png_color *src_pl = NULL;
    HPDF_BYTE *ppallet;
    HPDF_BYTE *p;
    HPDF_UINT i;
    HPDF_Array array;

    /* png_get_PLTE does not call PngErrorFunc even if it failed.
     * so we call HPDF_Set_Error to set error-code.
     */
    if (png_get_PLTE(png_ptr, info_ptr, (png_color**)&src_pl, &num_pl) !=
            PNG_INFO_PLTE)
        return HPDF_SetError (image->error, HPDF_LIBPNG_ERROR,
                    HPDF_CANNOT_GET_PALLET);


    /* make a pallet array for indexed image. */
    ppallet = HPDF_GetMem (image->mmgr, num_pl * 3);
    if (!ppallet)
        return image->error->error_no;

    p = ppallet;
    for (i = 0; i < num_pl; i++, src_pl++) {
        *p++ = src_pl->red;
        *p++ = src_pl->green;
        *p++ = src_pl->blue;
    }

    array = HPDF_Array_New (image->mmgr);
    if (array) {
        HPDF_Binary b;

        HPDF_Dict_Add (image, "ColorSpace", array);

        HPDF_Array_AddName (array, "Indexed");
        HPDF_Array_AddName (array, "DeviceRGB");
        HPDF_Array_AddNumber (array, num_pl - 1);

        b = HPDF_Binary_New (image->mmgr, ppallet, num_pl * 3);
        if (b)
            HPDF_Array_Add (array, b);
    }

    HPDF_FreeMem (image->mmgr, ppallet);

    return image->error->error_no;
}

#define HPDF_PNG_BYTES_TO_CHECK 8

HPDF_Image
HPDF_Image_LoadPngImage  (HPDF_MMgr        mmgr,
                          HPDF_Stream      png_data,
                          HPDF_Xref        xref,
                          HPDF_BOOL        delayed_loading)
{
    HPDF_STATUS ret;
    HPDF_Dict image;
    png_byte header[HPDF_PNG_BYTES_TO_CHECK];
    HPDF_UINT len = HPDF_PNG_BYTES_TO_CHECK;

    HPDF_PTRACE ((" HPDF_Image_LoadPngImage\n"));

    HPDF_MemSet (header, 0x00, HPDF_PNG_BYTES_TO_CHECK);
    ret = HPDF_Stream_Read (png_data, header, &len);
    if (ret != HPDF_OK ||
            png_sig_cmp (header, (png_size_t)0, HPDF_PNG_BYTES_TO_CHECK)) {
        HPDF_SetError (mmgr->error, HPDF_INVALID_PNG_IMAGE, 0);
        return NULL;
    }

    image = HPDF_DictStream_New (mmgr, xref);
    if (!image)
        return NULL;

    image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT;
    ret += HPDF_Dict_AddName (image, "Type", "XObject");
    ret += HPDF_Dict_AddName (image, "Subtype", "Image");
    if (ret != HPDF_OK)
        return NULL;

    if (LoadPngData (image, png_data, delayed_loading) != HPDF_OK)
        return NULL;

    return image;
}


static HPDF_STATUS
LoadPngData  (HPDF_Dict     image,
              HPDF_Stream   png_data,
              HPDF_BOOL     delayed_loading)

{
    HPDF_STATUS ret;
    png_structp png_ptr = NULL;
    png_infop info_ptr = NULL;

    HPDF_PTRACE ((" HPDF_Image_LoadPngImage\n"));

    /* create read_struct. */
    png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
        image->error, PngErrorFunc, PngErrorFunc);

    if (png_ptr == NULL) {
        HPDF_SetError (image->error, HPDF_FAILD_TO_ALLOC_MEM, 0);
        return HPDF_FAILD_TO_ALLOC_MEM;
    }

    /* create info-struct */
    info_ptr = png_create_info_struct (png_ptr);

    if (info_ptr == NULL) {
        HPDF_SetError (image->error, HPDF_FAILD_TO_ALLOC_MEM, 0);
        goto Exit;
    }

    png_set_sig_bytes (png_ptr, HPDF_PNG_BYTES_TO_CHECK);
    png_set_read_fn (png_ptr, (void *)png_data, (png_rw_ptr)&PngReadFunc);

    /* reading info structure. */
    png_read_info(png_ptr, info_ptr);
    if (image->error->error_no != HPDF_OK)
        goto Exit;

    /* 16bit image and alpha color type are not supported. */
    if (info_ptr->bit_depth == 16)
        png_set_strip_16(png_ptr);

    if (PNG_COLOR_MASK_ALPHA & info_ptr->color_type) {
        /* png image with alpha chanel is not supported. */
        png_set_strip_alpha(png_ptr);
    }

    png_read_update_info(png_ptr, info_ptr);
    if (image->error->error_no  != HPDF_OK)
        goto Exit;

    /* if the image has color palette, copy the pallet of the image to
     * create color map.
     */
    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
        ret = CreatePallet(image, png_ptr, info_ptr);
    else if (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)
        ret = HPDF_Dict_AddName (image, "ColorSpace", "DeviceGray");
    else
        ret = HPDF_Dict_AddName (image, "ColorSpace", "DeviceRGB");

    if (ret != HPDF_OK)
        goto Exit;

    /* read image-data
     * if the image is interlaced, read whole image at once.
     * if delayed_loading is HPDF_TRUE, the data does not load this phase.
     */
    if (delayed_loading) {
        image->before_write_fn = PngBeforeWrite;
        image->after_write_fn = PngAfterWrite;
    } else {
        if (png_get_interlace_type(png_ptr, info_ptr) != PNG_INTERLACE_NONE)
            ret = ReadPngData_Interlaced(image, png_ptr, info_ptr);
        else
            ret = ReadPngData(image, png_ptr, info_ptr);

        if (ret != HPDF_OK)
            goto Exit;
    }

    /* setting the info of the image. */
    if (HPDF_Dict_AddNumber (image, "Width", (HPDF_UINT)info_ptr->width)
        != HPDF_OK)
        goto Exit;

    if (HPDF_Dict_AddNumber (image, "Height", (HPDF_UINT)info_ptr->height)
        != HPDF_OK)
        goto Exit;

    if (HPDF_Dict_AddNumber (image, "BitsPerComponent",
                (HPDF_UINT)info_ptr->bit_depth) != HPDF_OK)
        goto Exit;

    /* clean up */
    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

    return HPDF_OK;

Exit:
    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

    return image->error->error_no;
}


static HPDF_STATUS
PngBeforeWrite  (HPDF_Dict obj)
{
    HPDF_STATUS ret;
    png_byte header[HPDF_PNG_BYTES_TO_CHECK];
    HPDF_UINT len = HPDF_PNG_BYTES_TO_CHECK;
    HPDF_Stream png_data;
    HPDF_String s;

    HPDF_PTRACE ((" PngBeforeWrite\n"));

    HPDF_MemStream_FreeData(obj->stream);

    s = HPDF_Dict_GetItem (obj, "_FILE_NAME", HPDF_OCLASS_STRING);
    if (!s)
        return HPDF_SetError (obj->error, HPDF_MISSING_FILE_NAME_ENTRY, 0);

    png_data = HPDF_FileReader_New (obj->mmgr, s->value);
    if (!HPDF_Stream_Validate (png_data))
        return obj->error->error_no;

    HPDF_MemSet (header, 0x00, HPDF_PNG_BYTES_TO_CHECK);
    ret = HPDF_Stream_Read (png_data, header, &len);
    if (ret != HPDF_OK ||
            png_sig_cmp (header, (png_size_t)0, HPDF_PNG_BYTES_TO_CHECK)) {
        HPDF_Stream_Free(png_data);
        return HPDF_SetError (obj->error, HPDF_INVALID_PNG_IMAGE, 0);
    }

    if ((ret = LoadPngData (obj, png_data, HPDF_FALSE)) != HPDF_OK) {
        HPDF_Stream_Free(png_data);
        return ret;
    }

    HPDF_Stream_Free(png_data);

    return HPDF_OK;
}


static HPDF_STATUS
PngAfterWrite  (HPDF_Dict obj)
{
   HPDF_PTRACE ((" PngAfterWrite\n"));

   HPDF_MemStream_FreeData(obj->stream);

   return HPDF_OK;
}


#endif /* HPDF_NOPNGLIB */