hpdf 2.0.8

data/ext/hpdf_image_png.c

@@ -0,0 +1,424 @@
+/*
+ * << 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 */
+

data/ext/hpdf_info.c

@@ -0,0 +1,164 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- hpdf_info.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_info.h"
+
+static const char  *HPDF_INFO_ATTR_NAMES[] = {
+    "CreationDate",
+    "ModDate",
+    "Author",
+    "Creator",
+    "Producer",
+    "Title",
+    "Subject",
+    "Keywords",
+    NULL
+};
+
+
+static const char*
+InfoTypeToName  (HPDF_InfoType  type);
+
+
+/*---------------------------------------------------------------------------*/
+
+static const char*
+InfoTypeToName  (HPDF_InfoType  type)
+{
+    HPDF_UINT idx = (HPDF_UINT)type;
+
+    return HPDF_INFO_ATTR_NAMES[idx];
+}
+
+
+HPDF_STATUS
+HPDF_Info_SetInfoAttr (HPDF_Dict        info,
+                       HPDF_InfoType    type,
+                       const char  *value,
+                       HPDF_Encoder     encoder)
+{
+    const char* name = InfoTypeToName (type);
+
+    HPDF_PTRACE((" HPDF_Info_SetInfoAttr\n"));
+
+    if (type <= HPDF_INFO_MOD_DATE)
+        return HPDF_SetError (info->error, HPDF_INVALID_PARAMETER, 0);
+
+    return HPDF_Dict_Add (info, name, HPDF_String_New (info->mmgr, value,
+            encoder));
+}
+
+
+const char*
+HPDF_Info_GetInfoAttr (HPDF_Dict      info,
+                       HPDF_InfoType  type)
+{
+    const char* name = InfoTypeToName (type);
+    HPDF_String s;
+
+    HPDF_PTRACE((" HPDF_Info_GetInfoAttr\n"));
+
+    if (!info)
+        return NULL;
+
+    s = HPDF_Dict_GetItem (info, name, HPDF_OCLASS_STRING);
+
+    if (!s)
+        return NULL;
+    else
+        return s->value;
+}
+
+
+HPDF_STATUS
+HPDF_Info_SetInfoDateAttr (HPDF_Dict      info,
+                           HPDF_InfoType  type,
+                           HPDF_Date      value)
+{
+    char tmp[HPDF_DATE_TIME_STR_LEN + 1];
+    char* ptmp;
+    const char* name = InfoTypeToName (type);
+
+    HPDF_PTRACE((" HPDF_Info_SetInfoDateAttr\n"));
+
+    if (type > HPDF_INFO_MOD_DATE)
+        return HPDF_SetError (info->error, HPDF_INVALID_PARAMETER, 0);
+
+    HPDF_MemSet (tmp, 0, HPDF_DATE_TIME_STR_LEN + 1);
+    if (value.month < 1 || 12 < value.month ||
+        value.day < 1 ||
+        23 < value.hour ||
+        59 < value.minutes ||
+        59 < value.seconds ||
+        (value.ind != '+' && value.ind != '-' && value.ind != 'Z' &&
+                value.ind != ' ') ||
+        23 < value.off_hour ||
+        59 < value.off_minutes) {
+        return HPDF_SetError (info->error, HPDF_INVALID_DATE_TIME, 0);
+    }
+
+    switch (value.month) {
+        case 1:
+        case 3:
+        case 5:
+        case 7:
+        case 8:
+        case 10:
+        case 12:
+            if (value.day > 31)
+                return HPDF_SetError (info->error, HPDF_INVALID_DATE_TIME, 0);
+
+            break;
+        case 4:
+        case 6:
+        case 9:
+        case 11:
+            if (value.day > 30)
+                return HPDF_SetError (info->error, HPDF_INVALID_DATE_TIME, 0);
+
+            break;
+        case 2:
+            if (value.day > 29 || (value.day == 29 &&
+                (value.year % 4 != 0 ||
+                (value.year % 100 == 0 && value.year % 400 != 0))))
+                return HPDF_SetError (info->error, HPDF_INVALID_DATE_TIME, 0);
+
+            break;
+        default:
+            return HPDF_SetError (info->error, HPDF_INVALID_DATE_TIME, 0);
+    }
+
+    ptmp = HPDF_MemCpy (tmp, "D:", 2);
+    ptmp = HPDF_IToA2 (ptmp, value.year, 5);
+    ptmp = HPDF_IToA2 (ptmp, value.month, 3);
+    ptmp = HPDF_IToA2 (ptmp, value.day, 3);
+    ptmp = HPDF_IToA2 (ptmp, value.hour, 3);
+    ptmp = HPDF_IToA2 (ptmp, value.minutes, 3);
+    ptmp = HPDF_IToA2 (ptmp, value.seconds, 3);
+    if (value.ind != ' ') {
+        *ptmp++ = value.ind;
+        ptmp = HPDF_IToA2 (ptmp, value.off_hour, 3);
+        *ptmp++ = '\'';
+        ptmp = HPDF_IToA2 (ptmp, value.off_minutes, 3);
+        *ptmp++ = '\'';
+    }
+    *ptmp = 0;
+
+    return HPDF_Dict_Add (info, name, HPDF_String_New (info->mmgr, tmp,
+                NULL));
+}
+
+