HPDF_Page HPDF_Page_New (HPDF_MMgr mmgr, HPDF_Xref xref) { HPDF_STATUS ret; HPDF_PageAttr attr; HPDF_Page page; HPDF_PTRACE((" HPDF_Page_New\n")); page = HPDF_Dict_New (mmgr); if (!page) return NULL; page->header.obj_class |= HPDF_OSUBCLASS_PAGE; page->free_fn = Page_OnFree; page->before_write_fn = Page_BeforeWrite; attr = HPDF_GetMem (page->mmgr, sizeof(HPDF_PageAttr_Rec)); if (!attr) { HPDF_Dict_Free (page); return NULL; } page->attr = attr; HPDF_MemSet (attr, 0, sizeof(HPDF_PageAttr_Rec)); attr->gmode = HPDF_GMODE_PAGE_DESCRIPTION; attr->cur_pos = HPDF_ToPoint (0, 0); attr->text_pos = HPDF_ToPoint (0, 0); ret = HPDF_Xref_Add (xref, page); if (ret != HPDF_OK) return NULL; attr->gstate = HPDF_GState_New (page->mmgr, NULL); attr->contents = HPDF_DictStream_New (page->mmgr, xref); if (!attr->gstate || !attr->contents) return NULL; attr->stream = attr->contents->stream; attr->xref = xref; /* add requiered elements */ ret += HPDF_Dict_AddName (page, "Type", "Page"); ret += HPDF_Dict_Add (page, "MediaBox", HPDF_Box_Array_New (page->mmgr, HPDF_ToBox (0, 0, (HPDF_INT16)(HPDF_DEF_PAGE_WIDTH), (HPDF_INT16)(HPDF_DEF_PAGE_HEIGHT)))); ret += HPDF_Dict_Add (page, "Contents", attr->contents); ret += AddResource (page); if (ret != HPDF_OK) return NULL; return page; }
HPDF_Image HPDF_Image_LoadJpegImage (HPDF_MMgr mmgr, HPDF_Stream jpeg_data, HPDF_Xref xref) { HPDF_Dict image; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE ((" HPDF_Image_LoadJpegImage\n")); image = HPDF_DictStream_New (mmgr, xref); if (!image) return NULL; image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT; /* add requiered elements */ image->filter = HPDF_STREAM_FILTER_DCT_DECODE; ret += HPDF_Dict_AddName (image, "Type", "XObject"); ret += HPDF_Dict_AddName (image, "Subtype", "Image"); if (ret != HPDF_OK) return NULL; if (LoadJpegHeader (image, jpeg_data) != HPDF_OK) return NULL; if (HPDF_Stream_Seek (jpeg_data, 0, HPDF_SEEK_SET) != HPDF_OK) return NULL; for (;;) { HPDF_BYTE buf[HPDF_STREAM_BUF_SIZ]; HPDF_UINT len = HPDF_STREAM_BUF_SIZ; HPDF_STATUS ret = HPDF_Stream_Read (jpeg_data, buf, &len); if (ret != HPDF_OK) { if (ret == HPDF_STREAM_EOF) { if (len > 0) { ret = HPDF_Stream_Write (image->stream, buf, len); if (ret != HPDF_OK) return NULL; } break; } else return NULL; } if (HPDF_Stream_Write (image->stream, buf, len) != HPDF_OK) return NULL; } return image; }
HPDF_EmbeddedFile HPDF_EmbeddedFile_New (HPDF_MMgr mmgr, HPDF_Xref xref, const char *file) { HPDF_STATUS ret = HPDF_OK; HPDF_Dict ef; /* the dictionary for the embedded file: /Type /EF */ HPDF_String name; /* the name of the file: /F (name) */ HPDF_Dict eff; /* ef has an /EF <<blah>> key - this is it */ HPDF_Dict filestream; /* the stream that /EF <</F _ _ R>> refers to */ HPDF_Stream stream; ef = HPDF_Dict_New (mmgr); if (!ef) return NULL; if (HPDF_Xref_Add (xref, ef) != HPDF_OK) return NULL; filestream = HPDF_DictStream_New (mmgr, xref); if (!filestream) return NULL; stream = HPDF_FileReader_New (mmgr, file); if (!stream) return NULL; HPDF_Stream_Free(filestream->stream); filestream->stream = stream; filestream->filter = HPDF_STREAM_FILTER_FLATE_DECODE; eff = HPDF_Dict_New (mmgr); if (!eff) return NULL; name = HPDF_String_New (mmgr, file, NULL); if (!name) return NULL; ret += HPDF_Dict_AddName (ef, "Type", "F"); ret += HPDF_Dict_Add (ef, "F", name); ret += HPDF_Dict_Add (ef, "EF", eff); ret += HPDF_Dict_Add (eff, "F", filestream); if (ret != HPDF_OK) return NULL; return ef; }
HPDF_EXPORT(HPDF_JavaScript) HPDF_CreateJavaScript( HPDF_Doc pdf, const char *code ) { HPDF_JavaScript javaScript; int len ; HPDF_PTRACE ((" HPDF_CreateJavaScript\n")); javaScript = (HPDF_JavaScript) HPDF_DictStream_New(pdf->mmgr, pdf->xref); if (!javaScript) { return NULL; } len = (HPDF_UINT)strlen(code); if (HPDF_Stream_Write (javaScript->stream, (HPDF_BYTE *)code, len) != HPDF_OK) { HPDF_Dict_Free(javaScript); return NULL; } return javaScript; }
HPDF_U3D HPDF_U3D_LoadU3DFromMem ( HPDF_MMgr mmgr, const HPDF_BYTE *buf, HPDF_UINT size, HPDF_Xref xref ) { HPDF_Dict image; HPDF_STATUS ret = HPDF_OK; HPDF_PTRACE ((" HPDF_U3D_LoadU3DFromMem\n")); image = HPDF_DictStream_New (mmgr, xref); if (!image) { return NULL; } image->header.obj_class |= HPDF_OSUBCLASS_XOBJECT; ret = HPDF_Dict_AddName (image, "Type", "XObject"); if (ret != HPDF_OK) { HPDF_Dict_Free(image); return NULL; } ret = HPDF_Dict_AddName (image, "Subtype", "Image"); if (ret != HPDF_OK) { HPDF_Dict_Free(image); return NULL; } if (HPDF_Stream_Write (image->stream, buf, size) != HPDF_OK) { HPDF_Dict_Free(image); return NULL; } return image; }
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, xref, png_data, delayed_loading) != HPDF_OK) return NULL; return image; }
HPDF_U3D HPDF_U3D_LoadU3D (HPDF_MMgr mmgr, HPDF_Stream u3d_data, HPDF_Xref xref) { HPDF_Dict u3d; const char *type; HPDF_PTRACE ((" HPDF_U3D_LoadU3D\n")); u3d = HPDF_DictStream_New (mmgr, xref); if (!u3d) { return NULL; } u3d->header.obj_class |= HPDF_OSUBCLASS_XOBJECT; /* add required elements */ u3d->filter = HPDF_STREAM_FILTER_NONE; if (HPDF_Dict_AddName (u3d, "Type", "3D") != HPDF_OK) { HPDF_Dict_Free(u3d); return NULL; } if (Get3DStreamType (u3d_data, &type) != HPDF_OK) { HPDF_Dict_Free(u3d); return NULL; } if (HPDF_Dict_AddName (u3d, "Subtype", type) != HPDF_OK) { HPDF_Dict_Free(u3d); return NULL; } for (;;) { HPDF_BYTE buf[HPDF_STREAM_BUF_SIZ]; HPDF_UINT len = HPDF_STREAM_BUF_SIZ; HPDF_STATUS ret = HPDF_Stream_Read (u3d_data, buf, &len); if (ret != HPDF_OK) { if (ret == HPDF_STREAM_EOF) { if (len > 0) { ret = HPDF_Stream_Write (u3d->stream, buf, len); if (ret != HPDF_OK) { HPDF_Dict_Free(u3d); return NULL; } } break; } else { HPDF_Dict_Free(u3d); return NULL; } } if (HPDF_Stream_Write (u3d->stream, buf, len) != HPDF_OK) { HPDF_Dict_Free(u3d); return NULL; } } return u3d; }
HPDF_Shading_New (HPDF_Doc pdf, HPDF_ShadingType type, HPDF_ColorSpace colorSpace, HPDF_REAL xMin, HPDF_REAL xMax, HPDF_REAL yMin, HPDF_REAL yMax) { HPDF_Shading shading; HPDF_Array decodeArray; HPDF_STATUS ret = HPDF_OK; int i; HPDF_PTRACE((" HPDF_Shading_New\n")); if (!HPDF_HasDoc(pdf)) { return NULL; } /* Validate shading type: */ switch (type) { case HPDF_SHADING_FREE_FORM_TRIANGLE_MESH: break; default: HPDF_SetError (pdf->mmgr->error, HPDF_INVALID_SHADING_TYPE, 0); return NULL; } decodeArray = HPDF_Array_New(pdf->mmgr); if (!decodeArray) { return NULL; } /* X-range */ ret += HPDF_Array_AddReal(decodeArray, xMin); ret += HPDF_Array_AddReal(decodeArray, xMax); /* Y-range */ ret += HPDF_Array_AddReal(decodeArray, yMin); ret += HPDF_Array_AddReal(decodeArray, yMax); const char *colName = NULL; switch (colorSpace) { case HPDF_CS_DEVICE_RGB: colName = COL_RGB; for (i = 0; i < 3; ++i) { ret += HPDF_Array_AddReal(decodeArray, 0.0); ret += HPDF_Array_AddReal(decodeArray, 1.0); } break; default: HPDF_SetError(pdf->mmgr->error, HPDF_INVALID_COLOR_SPACE, 0); return NULL; } if (ret != HPDF_OK) { return NULL; } shading = HPDF_DictStream_New(pdf->mmgr, pdf->xref); if (!shading) { return NULL; } shading->header.obj_class |= HPDF_OSUBCLASS_SHADING; ret += HPDF_Dict_AddNumber(shading, "ShadingType", type); ret += HPDF_Dict_AddName(shading, "ColorSpace", colName); switch (type) { case HPDF_SHADING_FREE_FORM_TRIANGLE_MESH: ret += HPDF_Dict_AddNumber(shading, "BitsPerCoordinate", 32); ret += HPDF_Dict_AddNumber(shading, "BitsPerComponent", 8); ret += HPDF_Dict_AddNumber(shading, "BitsPerFlag", 8); ret += HPDF_Dict_Add(shading, "Decode", decodeArray); break; default: HPDF_SetError (pdf->mmgr->error, HPDF_INVALID_SHADING_TYPE, 0); return NULL; } if (ret != HPDF_OK) { return NULL; } return shading; }
HPDF_Image HPDF_Image_LoadRawImageFromMem (HPDF_MMgr mmgr, const HPDF_BYTE *buf, HPDF_Xref xref, HPDF_UINT width, HPDF_UINT height, HPDF_ColorSpace color_space, HPDF_UINT bits_per_component) { HPDF_Dict image; HPDF_STATUS ret = HPDF_OK; HPDF_UINT size=0; HPDF_PTRACE ((" HPDF_Image_LoadRawImageFromMem\n")); if (color_space != HPDF_CS_DEVICE_GRAY && color_space != HPDF_CS_DEVICE_RGB && color_space != HPDF_CS_DEVICE_CMYK) { HPDF_SetError (mmgr->error, HPDF_INVALID_COLOR_SPACE, 0); return NULL; } if (bits_per_component != 1 && bits_per_component != 2 && bits_per_component != 4 && bits_per_component != 8) { HPDF_SetError (mmgr->error, HPDF_INVALID_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; switch (color_space) { case HPDF_CS_DEVICE_GRAY: size = (HPDF_UINT)((HPDF_DOUBLE)width * height / (8 / bits_per_component) + 0.876); ret = HPDF_Dict_AddName (image, "ColorSpace", COL_GRAY); break; case HPDF_CS_DEVICE_RGB: size = (HPDF_UINT)((HPDF_DOUBLE)width * height / (8 / bits_per_component) + 0.876); size *= 3; ret = HPDF_Dict_AddName (image, "ColorSpace", COL_RGB); break; case HPDF_CS_DEVICE_CMYK: size = (HPDF_UINT)((HPDF_DOUBLE)width * height / (8 / bits_per_component) + 0.876); size *= 4; ret = HPDF_Dict_AddName (image, "ColorSpace", COL_CMYK); break; default:; } if (ret != HPDF_OK) return NULL; if (HPDF_Dict_AddNumber (image, "Width", width) != HPDF_OK) return NULL; if (HPDF_Dict_AddNumber (image, "Height", height) != HPDF_OK) return NULL; if (HPDF_Dict_AddNumber (image, "BitsPerComponent", bits_per_component) != HPDF_OK) return NULL; if (HPDF_Stream_Write (image->stream, buf, size) != HPDF_OK) return NULL; return image; }
HPDF_Font HPDF_Type3RasterFont_New(HPDF_MMgr mmgr, HPDF_FontDef fontdef, HPDF_Encoder encoder, HPDF_Xref xref) { HPDF_Dict font; HPDF_FontAttr attr; HPDF_Type3RasterFontDefAttr fontdef_attr; HPDF_BasicEncoderAttr encoder_attr; HPDF_STATUS ret = 0; HPDF_UINT i; HPDF_PTRACE((" HPDF_Type3RasterFont_New\n")); /* check whether the fontdef object and the encoder object is valid. */ if (encoder->type != HPDF_ENCODER_TYPE_SINGLE_BYTE) { HPDF_SetError(mmgr->error, HPDF_INVALID_ENCODER_TYPE, 0); return NULL; } if (fontdef->type != HPDF_FONTDEF_TYPE_TYPE3RASTER) { HPDF_SetError(mmgr->error, HPDF_INVALID_FONTDEF_TYPE, 0); return NULL; } font = HPDF_Dict_New(mmgr); if (!font) return NULL; font->header.obj_class |= HPDF_OSUBCLASS_FONT; attr = HPDF_GetMem(mmgr, sizeof(HPDF_FontAttr_Rec)); if (!attr) { HPDF_Dict_Free(font); return NULL; } font->header.obj_class |= HPDF_OSUBCLASS_FONT; font->write_fn = Type3RasterFont_OnWrite; font->free_fn = Type3RasterFont_OnFree; HPDF_MemSet(attr, 0, sizeof(HPDF_FontAttr_Rec)); font->attr = attr; attr->type = HPDF_FONT_TYPE3; attr->writing_mode = HPDF_WMODE_HORIZONTAL; attr->text_width_fn = Type3RasterFont_TextWidth; attr->measure_text_fn = Type3RasterFont_MeasureText; attr->fontdef = fontdef; attr->encoder = encoder; attr->xref = xref; /* singlebyte-font has a widths-array which is an array of 256 signed * short integer. */ attr->widths = HPDF_GetMem(mmgr, sizeof(HPDF_INT16) * 256); if (!attr->widths) { HPDF_Dict_Free(font); return NULL; } encoder_attr = (HPDF_BasicEncoderAttr)encoder->attr; HPDF_MemSet(attr->widths, 0, sizeof(HPDF_INT16) * 256); for (i = 0 /*encoder_attr->first_char*/; i <= 255 /*encoder_attr->last_char*/; i++) { HPDF_UINT16 w = HPDF_Type3RasterFontDef_GetWidth(fontdef, i); attr->widths[i] = w; } fontdef_attr = (HPDF_Type3RasterFontDefAttr)fontdef->attr; ret += HPDF_Dict_AddName(font, "Name", fontdef->base_font); ret += HPDF_Dict_AddName(font, "Type", "Font"); ret += HPDF_Dict_AddName(font, "Subtype", "Type3"); HPDF_REAL scale_x = 72.0f / (HPDF_REAL)fontdef_attr->dpi_x; HPDF_REAL scale_y = 72.0f / (HPDF_REAL)fontdef_attr->dpi_y; HPDF_TransMatrix font_matrix; font_matrix.a = scale_x; font_matrix.b = 0; font_matrix.c = 0; font_matrix.d = scale_y; font_matrix.x = 0; font_matrix.y = 0; HPDF_Array array = HPDF_Array_New(mmgr); ret += HPDF_Array_AddReal(array, font_matrix.a); ret += HPDF_Array_AddReal(array, font_matrix.b); ret += HPDF_Array_AddReal(array, font_matrix.c); ret += HPDF_Array_AddReal(array, font_matrix.d); ret += HPDF_Array_AddReal(array, font_matrix.x); ret += HPDF_Array_AddReal(array, font_matrix.y); ret += HPDF_Dict_Add(font, "FontMatrix", array); HPDF_Array diff_array = HPDF_Array_New(mmgr); ret += HPDF_Array_AddNumber(diff_array, 0); for (i = 0; i < 256; ++i) { char name[3]; sprintf(name, "%02X", i); ret += HPDF_Array_AddName(diff_array, name); } HPDF_Dict encoding = HPDF_Dict_New(mmgr); ret += HPDF_Dict_Add(encoding, "Differences", diff_array); ret += HPDF_Dict_Add(font, "Encoding", encoding); HPDF_Dict char_procs = HPDF_Dict_New(mmgr); for (i = 0; i < 256; ++i) { char name[3]; sprintf(name, "%02X", i); HPDF_Dict char_stream_dict = HPDF_DictStream_New(mmgr, xref); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].width / scale_x); HPDF_Stream_WriteStr(char_stream_dict->stream, " 0 "); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].left / scale_x); HPDF_Stream_WriteStr(char_stream_dict->stream, " "); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].bottom / scale_y); HPDF_Stream_WriteStr(char_stream_dict->stream, " "); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].right / scale_x); HPDF_Stream_WriteStr(char_stream_dict->stream, " "); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].top / scale_y); HPDF_Stream_WriteStr(char_stream_dict->stream, " d1\012"); HPDF_Stream_WriteStr(char_stream_dict->stream, "q\012"); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].pixels_x); HPDF_Stream_WriteStr(char_stream_dict->stream, " 0 0 "); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].pixels_y); HPDF_Stream_WriteStr(char_stream_dict->stream, " "); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].left / scale_x); HPDF_Stream_WriteStr(char_stream_dict->stream, " "); HPDF_Stream_WriteReal(char_stream_dict->stream, fontdef_attr->chars[i].bottom / scale_y); HPDF_Stream_WriteStr(char_stream_dict->stream, " cm\012"); HPDF_Stream_WriteStr(char_stream_dict->stream, "BI\012"); HPDF_Stream_WriteStr(char_stream_dict->stream, "/IM true\012"); HPDF_Stream_WriteStr(char_stream_dict->stream, "/W "); HPDF_Stream_WriteInt(char_stream_dict->stream, fontdef_attr->chars[i].pixels_x); HPDF_Stream_WriteStr(char_stream_dict->stream, " /H "); HPDF_Stream_WriteInt(char_stream_dict->stream, fontdef_attr->chars[i].pixels_y); HPDF_Stream_WriteStr(char_stream_dict->stream, "\012/BPC 1\012"); HPDF_Stream_WriteStr(char_stream_dict->stream, "/D [1 0]\012"); HPDF_Stream_WriteStr(char_stream_dict->stream, "ID\012"); if (fontdef_attr->chars[i].raster_data != NULL) HPDF_Stream_Write(char_stream_dict->stream, fontdef_attr->chars[i].raster_data, fontdef_attr->chars[i].raster_data_size); HPDF_Stream_WriteStr(char_stream_dict->stream, "\012EI\012"); HPDF_Stream_WriteStr(char_stream_dict->stream, "Q"); ret += HPDF_Dict_Add(char_procs, name, char_stream_dict); if (fontdef_attr->chars[i].left < fontdef->font_bbox.left) fontdef->font_bbox.left = fontdef_attr->chars[i].left; if (fontdef_attr->chars[i].bottom < fontdef->font_bbox.bottom) fontdef->font_bbox.bottom = fontdef_attr->chars[i].bottom; if (fontdef_attr->chars[i].right > fontdef->font_bbox.right) fontdef->font_bbox.right = fontdef_attr->chars[i].right; if (fontdef_attr->chars[i].top > fontdef->font_bbox.top) fontdef->font_bbox.top = fontdef_attr->chars[i].top; } fontdef->font_bbox.left /= scale_x; fontdef->font_bbox.bottom /= scale_y; fontdef->font_bbox.right /= scale_x; fontdef->font_bbox.top /= scale_y; ret += HPDF_Dict_Add(font, "CharProcs", char_procs); array = HPDF_Box_Array_New(mmgr, fontdef->font_bbox); ret += HPDF_Dict_Add(font, "FontBBox", array); if (ret != HPDF_OK) { HPDF_Dict_Free(font); return NULL; } if (HPDF_Xref_Add(xref, font) != HPDF_OK) return NULL; return font; }
static HPDF_STATUS CreateDescriptor (HPDF_Font font) { HPDF_FontAttr font_attr = (HPDF_FontAttr)font->attr; HPDF_FontDef def = font_attr->fontdef; HPDF_TTFontDefAttr def_attr = (HPDF_TTFontDefAttr)def->attr; HPDF_PTRACE ((" HPDF_TTFont_CreateDescriptor\n")); if (!font_attr->fontdef->descriptor) { HPDF_Dict descriptor = HPDF_Dict_New (font->mmgr); HPDF_STATUS ret = 0; HPDF_Array array; if (!descriptor) return HPDF_Error_GetCode (font->error); ret += HPDF_Xref_Add (font_attr->xref, descriptor); ret += HPDF_Dict_AddName (descriptor, "Type", "FontDescriptor"); ret += HPDF_Dict_AddNumber (descriptor, "Ascent", def->ascent); ret += HPDF_Dict_AddNumber (descriptor, "Descent", def->descent); ret += HPDF_Dict_AddNumber (descriptor, "Flags", def->flags); array = HPDF_Box_Array_New (font->mmgr, def->font_bbox); ret += HPDF_Dict_Add (descriptor, "FontBBox", array); ret += HPDF_Dict_AddName (descriptor, "FontName", def_attr->base_font); ret += HPDF_Dict_AddNumber (descriptor, "ItalicAngle", def->italic_angle); ret += HPDF_Dict_AddNumber (descriptor, "StemV", def->stemv); ret += HPDF_Dict_AddNumber (descriptor, "XHeight", def->x_height); if (def_attr->char_set) ret += HPDF_Dict_AddName (descriptor, "CharSet", def_attr->char_set); if (ret != HPDF_OK) return HPDF_Error_GetCode (font->error); if (def_attr->embedding) { HPDF_Dict font_data = HPDF_DictStream_New (font->mmgr, font_attr->xref); if (!font_data) return HPDF_Error_GetCode (font->error); if (HPDF_TTFontDef_SaveFontData (font_attr->fontdef, font_data->stream) != HPDF_OK) return HPDF_Error_GetCode (font->error); ret += HPDF_Dict_Add (descriptor, "FontFile2", font_data); ret += HPDF_Dict_AddNumber (font_data, "Length1", def_attr->length1); ret += HPDF_Dict_AddNumber (font_data, "Length2", 0); ret += HPDF_Dict_AddNumber (font_data, "Length3", 0); font_data->filter = font->filter; } if (ret != HPDF_OK) return HPDF_Error_GetCode (font->error); font_attr->fontdef->descriptor = descriptor; } return HPDF_Dict_Add (font, "FontDescriptor", font_attr->fontdef->descriptor); }
HPDF_STATUS HPDF_PDFA_SetPDFAConformance (HPDF_Doc pdf,HPDF_PDFAType pdfatype) { HPDF_OutputIntent xmp; HPDF_STATUS ret; const char *info = NULL; if (!HPDF_HasDoc(pdf)) { return HPDF_INVALID_DOCUMENT; } xmp = HPDF_DictStream_New(pdf->mmgr,pdf->xref); if (!xmp) { return HPDF_INVALID_STREAM; } HPDF_Dict_AddName(xmp,"Type","Metadata"); HPDF_Dict_AddName(xmp,"SubType","XML"); ret = HPDF_OK; ret += HPDF_Stream_WriteStr(xmp->stream, XMP_HEADER); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PRODUCER_STARTTAG); info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_PRODUCER); ret += HPDF_Stream_WriteStr(xmp->stream, info); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PRODUCER_ENDTAG); /* Add CreateDate, ModifyDate, and CreatorTool */ ret += HPDF_Stream_WriteStr(xmp->stream, XMP_INFODATA_STARTTAG); info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_CREATION_DATE); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATE_DATE_STARTTAG); /* Convert date to XMP compatible format */ ret += ConvertDateToXMDate(xmp->stream, info); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATE_DATE_ENDTAG); info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_MOD_DATE); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_MOD_DATE_STARTTAG); ret += ConvertDateToXMDate(xmp->stream, info); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_MOD_DATE_ENDTAG); info = (const char *)HPDF_GetInfoAttr(pdf, HPDF_INFO_CREATOR); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATORTOOL_STARTTAG); ret += HPDF_Stream_WriteStr(xmp->stream, info); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_CREATORTOOL_ENDTAG); ret += HPDF_Stream_WriteStr(xmp->stream, XMP_INFODATA_ENDTAG); switch(pdfatype) { case HPDF_PDFA_1A: ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PDFA1A); break; case HPDF_PDFA_1B: ret += HPDF_Stream_WriteStr(xmp->stream, XMP_PDFA1B); break; } ret += HPDF_Stream_WriteStr(xmp->stream, XMP_FOOTER); if (ret != HPDF_OK) { return HPDF_INVALID_STREAM; } if ((ret = HPDF_Dict_Add(pdf->catalog, "Metadata", xmp)) != HPDF_OK) { return ret; } return HPDF_PDFA_GenerateID(pdf); }
static HPDF_STATUS Type1Font_CreateDescriptor (HPDF_MMgr mmgr, HPDF_Font font, HPDF_Xref xref) { HPDF_FontAttr font_attr = (HPDF_FontAttr)font->attr; HPDF_FontDef def = font_attr->fontdef; HPDF_Type1FontDefAttr def_attr = (HPDF_Type1FontDefAttr)def->attr; HPDF_PTRACE ((" HPDF_Type1Font_CreateDescriptor\n")); if (!font_attr->fontdef->descriptor) { HPDF_Dict descriptor = HPDF_Dict_New (mmgr); HPDF_STATUS ret = 0; HPDF_Array array; if (!descriptor) return HPDF_Error_GetCode (font->error); ret += HPDF_Xref_Add (xref, descriptor); ret += HPDF_Dict_AddName (descriptor, "Type", "FontDescriptor"); ret += HPDF_Dict_AddNumber (descriptor, "Ascent", def->ascent); ret += HPDF_Dict_AddNumber (descriptor, "Descent", def->descent); if (def->cap_height) { ret += HPDF_Dict_AddNumber (descriptor, "CapHeight", def->cap_height); } ret += HPDF_Dict_AddNumber (descriptor, "Flags", def->flags); array = HPDF_Box_Array_New (mmgr, def->font_bbox); ret += HPDF_Dict_Add (descriptor, "FontBBox", array); if(strncmp (font_attr->fontdef->base_font, "HPDF_", 5) == 0 && font_attr->fontdef->is_form_font == HPDF_TRUE) { ret += HPDF_Dict_AddName (descriptor, "FontName", font_attr->fontdef->base_font + 5); } else { ret += HPDF_Dict_AddName (descriptor, "FontName", font_attr->fontdef->base_font); } ret += HPDF_Dict_AddNumber (descriptor, "ItalicAngle", def->italic_angle); ret += HPDF_Dict_AddNumber (descriptor, "StemV", def->stemv); ret += HPDF_Dict_AddNumber (descriptor, "XHeight", def->x_height); if (def_attr->char_set) ret += HPDF_Dict_AddName (descriptor, "CharSet", def_attr->char_set); if (ret != HPDF_OK) return HPDF_Error_GetCode (font->error); if (def_attr->font_data) { HPDF_Dict font_data = HPDF_DictStream_New (mmgr, xref); if (!font_data) return HPDF_Error_GetCode (font->error); if (HPDF_Stream_WriteToStream (def_attr->font_data, font_data->stream, HPDF_STREAM_FILTER_NONE, NULL) != HPDF_OK) return HPDF_Error_GetCode (font->error); ret += HPDF_Dict_Add (descriptor, "FontFile", font_data); ret += HPDF_Dict_AddNumber (font_data, "Length1", def_attr->length1); ret += HPDF_Dict_AddNumber (font_data, "Length2", def_attr->length2); ret += HPDF_Dict_AddNumber (font_data, "Length3", def_attr->length3); font_data->filter = font->filter; } if (ret != HPDF_OK) return HPDF_Error_GetCode (font->error); font_attr->fontdef->descriptor = descriptor; } return HPDF_Dict_Add (font, "FontDescriptor", font_attr->fontdef->descriptor); }
static HPDF_STATUS LoadPngData (HPDF_Dict image, HPDF_Xref xref, HPDF_Stream png_data, HPDF_BOOL delayed_loading) { HPDF_STATUS ret = HPDF_OK; png_uint_32 width, height; int bit_depth, color_type; 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; } png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL); /* 16bit images are not supported. */ if (bit_depth == 16) { png_set_strip_16(png_ptr); } png_read_update_info(png_ptr, info_ptr); if (image->error->error_no != HPDF_OK) { goto Exit; } /* check palette-based images for transparent areas and load them immediately if found */ if (xref && PNG_COLOR_TYPE_PALETTE & color_type) { png_bytep trans; int num_trans; HPDF_Dict smask; png_bytep smask_data; if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) || !png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL)) { goto no_transparent_color_in_palette; } smask = HPDF_DictStream_New (image->mmgr, xref); if (!smask) { ret = HPDF_FAILD_TO_ALLOC_MEM; goto Exit; } smask->header.obj_class |= HPDF_OSUBCLASS_XOBJECT; ret = HPDF_Dict_AddName (smask, "Type", "XObject"); ret += HPDF_Dict_AddName (smask, "Subtype", "Image"); ret += HPDF_Dict_AddNumber (smask, "Width", (HPDF_UINT)width); ret += HPDF_Dict_AddNumber (smask, "Height", (HPDF_UINT)height); ret += HPDF_Dict_AddName (smask, "ColorSpace", "DeviceGray"); ret += HPDF_Dict_AddNumber (smask, "BitsPerComponent", (HPDF_UINT)bit_depth); if (ret != HPDF_OK) { HPDF_Dict_Free(smask); ret = HPDF_INVALID_PNG_IMAGE; goto Exit; } smask_data = HPDF_GetMem(image->mmgr, width * height); if (!smask_data) { HPDF_Dict_Free(smask); ret = HPDF_FAILD_TO_ALLOC_MEM; goto Exit; } if (ReadTransparentPaletteData(image, png_ptr, info_ptr, smask_data, trans, num_trans) != HPDF_OK) { HPDF_FreeMem(image->mmgr, smask_data); HPDF_Dict_Free(smask); ret = HPDF_INVALID_PNG_IMAGE; goto Exit; } if (HPDF_Stream_Write(smask->stream, smask_data, width * height) != HPDF_OK) { HPDF_FreeMem(image->mmgr, smask_data); HPDF_Dict_Free(smask); ret = HPDF_FILE_IO_ERROR; goto Exit; } HPDF_FreeMem(image->mmgr, smask_data); ret += CreatePallet(image, png_ptr, info_ptr); ret += HPDF_Dict_AddNumber (image, "Width", (HPDF_UINT)width); ret += HPDF_Dict_AddNumber (image, "Height", (HPDF_UINT)height); ret += HPDF_Dict_AddNumber (image, "BitsPerComponent", (HPDF_UINT)bit_depth); ret += HPDF_Dict_Add (image, "SMask", smask); png_destroy_read_struct(&png_ptr, &info_ptr, NULL); return HPDF_OK; } no_transparent_color_in_palette: /* read images with alpha channel right away we have to do this because image transparent mask must be added to the Xref */ if (xref && PNG_COLOR_MASK_ALPHA & color_type) { HPDF_Dict smask; png_bytep smask_data; smask = HPDF_DictStream_New (image->mmgr, xref); if (!smask) { ret = HPDF_FAILD_TO_ALLOC_MEM; goto Exit; } smask->header.obj_class |= HPDF_OSUBCLASS_XOBJECT; ret = HPDF_Dict_AddName (smask, "Type", "XObject"); ret += HPDF_Dict_AddName (smask, "Subtype", "Image"); ret += HPDF_Dict_AddNumber (smask, "Width", (HPDF_UINT)width); ret += HPDF_Dict_AddNumber (smask, "Height", (HPDF_UINT)height); ret += HPDF_Dict_AddName (smask, "ColorSpace", "DeviceGray"); ret += HPDF_Dict_AddNumber (smask, "BitsPerComponent", (HPDF_UINT)bit_depth); if (ret != HPDF_OK) { HPDF_Dict_Free(smask); ret = HPDF_INVALID_PNG_IMAGE; goto Exit; } smask_data = HPDF_GetMem(image->mmgr, width * height); if (!smask_data) { HPDF_Dict_Free(smask); ret = HPDF_FAILD_TO_ALLOC_MEM; goto Exit; } if (ReadTransparentPngData(image, png_ptr, info_ptr, smask_data) != HPDF_OK) { HPDF_FreeMem(image->mmgr, smask_data); HPDF_Dict_Free(smask); ret = HPDF_INVALID_PNG_IMAGE; goto Exit; } if (HPDF_Stream_Write(smask->stream, smask_data, width * height) != HPDF_OK) { HPDF_FreeMem(image->mmgr, smask_data); HPDF_Dict_Free(smask); ret = HPDF_FILE_IO_ERROR; goto Exit; } HPDF_FreeMem(image->mmgr, smask_data); if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { ret += HPDF_Dict_AddName (image, "ColorSpace", "DeviceGray"); } else { ret += HPDF_Dict_AddName (image, "ColorSpace", "DeviceRGB"); } ret += HPDF_Dict_AddNumber (image, "Width", (HPDF_UINT)width); ret += HPDF_Dict_AddNumber (image, "Height", (HPDF_UINT)height); ret += HPDF_Dict_AddNumber (image, "BitsPerComponent", (HPDF_UINT)bit_depth); ret += HPDF_Dict_Add (image, "SMask", smask); png_destroy_read_struct(&png_ptr, &info_ptr, NULL); return HPDF_OK; } /* if the image has color palette, copy the pallet of the image to * create color map. */ if (color_type == PNG_COLOR_TYPE_PALETTE) ret = CreatePallet(image, png_ptr, info_ptr); else if (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)width) != HPDF_OK) goto Exit; if (HPDF_Dict_AddNumber (image, "Height", (HPDF_UINT)height) != HPDF_OK) goto Exit; if (HPDF_Dict_AddNumber (image, "BitsPerComponent", (HPDF_UINT)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); if (ret != HPDF_OK) { return ret; } return image->error->error_no; }
HPDF_Image HPDF_Image_LoadRawImage (HPDF_MMgr mmgr, HPDF_Stream raw_data, HPDF_Xref xref, HPDF_UINT width, HPDF_UINT height, HPDF_ColorSpace color_space) { HPDF_Dict image; HPDF_STATUS ret = HPDF_OK; HPDF_UINT size; HPDF_PTRACE ((" HPDF_Image_LoadRawImage\n")); if (color_space != HPDF_CS_DEVICE_GRAY && color_space != HPDF_CS_DEVICE_RGB && color_space != HPDF_CS_DEVICE_CMYK) { HPDF_SetError (mmgr->error, HPDF_INVALID_COLOR_SPACE, 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 (color_space == HPDF_CS_DEVICE_GRAY) { size = width * height; ret = HPDF_Dict_AddName (image, "ColorSpace", COL_GRAY); } else if (color_space == HPDF_CS_DEVICE_CMYK) { size = width * height * 4; ret = HPDF_Dict_AddName (image, "ColorSpace", COL_CMYK); } else { size = width * height * 3; ret = HPDF_Dict_AddName (image, "ColorSpace", COL_RGB); } if (ret != HPDF_OK) return NULL; if (HPDF_Dict_AddNumber (image, "Width", width) != HPDF_OK) return NULL; if (HPDF_Dict_AddNumber (image, "Height", height) != HPDF_OK) return NULL; if (HPDF_Dict_AddNumber (image, "BitsPerComponent", 8) != HPDF_OK) return NULL; if (HPDF_Stream_WriteToStream (raw_data, image->stream, 0, NULL) != HPDF_OK) return NULL; if (image->stream->size != size) { HPDF_SetError (image->error, HPDF_INVALID_IMAGE, 0); return NULL; } return image; }
static HPDF_Font CIDFontType2_New (HPDF_Font parent, HPDF_Xref xref) { HPDF_STATUS ret = HPDF_OK; HPDF_FontAttr attr = (HPDF_FontAttr)parent->attr; HPDF_FontDef fontdef = attr->fontdef; HPDF_TTFontDefAttr fontdef_attr = (HPDF_TTFontDefAttr)fontdef->attr; HPDF_Encoder encoder = attr->encoder; HPDF_CMapEncoderAttr encoder_attr = (HPDF_CMapEncoderAttr)encoder->attr; HPDF_Font font; HPDF_Array array; HPDF_UINT i; HPDF_UNICODE tmp_map[65536]; HPDF_Dict cid_system_info; HPDF_UINT16 max = 0; HPDF_PTRACE ((" HPDF_CIDFontType2_New\n")); font = HPDF_Dict_New (parent->mmgr); if (!font) return NULL; if (HPDF_Xref_Add (xref, font) != HPDF_OK) return NULL; parent->before_write_fn = CIDFontType2_BeforeWrite_Func; ret += HPDF_Dict_AddName (font, "Type", "Font"); ret += HPDF_Dict_AddName (font, "Subtype", "CIDFontType2"); ret += HPDF_Dict_AddNumber (font, "DW", fontdef->missing_width); if (ret != HPDF_OK) return NULL; /* add 'DW2' element */ array = HPDF_Array_New (font->mmgr); if (!array) return NULL; if (HPDF_Dict_Add (font, "DW2", array) != HPDF_OK) return NULL; ret += HPDF_Array_AddNumber (array, (HPDF_INT32)(fontdef->font_bbox.bottom)); ret += HPDF_Array_AddNumber (array, (HPDF_INT32)(fontdef->font_bbox.bottom - fontdef->font_bbox.top)); HPDF_MemSet (tmp_map, 0, sizeof(HPDF_UNICODE) * 65536); if (ret != HPDF_OK) return NULL; for (i = 0; i < 256; i++) { HPDF_UINT j; for (j = 0; j < 256; j++) { if (encoder->to_unicode_fn == HPDF_CMapEncoder_ToUnicode) { HPDF_UINT16 cid = encoder_attr->cid_map[i][j]; if (cid != 0) { HPDF_UNICODE unicode = encoder_attr->unicode_map[i][j]; HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (fontdef, unicode); tmp_map[cid] = gid; if (max < cid) max = cid; } } else { HPDF_UNICODE unicode = (i << 8) | j; HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (fontdef, unicode); tmp_map[unicode] = gid; if (max < unicode) max = unicode; } } } if (max > 0) { HPDF_INT16 dw = fontdef->missing_width; HPDF_UNICODE *ptmp_map = tmp_map; HPDF_Array tmp_array = NULL; /* add 'W' element */ array = HPDF_Array_New (font->mmgr); if (!array) return NULL; if (HPDF_Dict_Add (font, "W", array) != HPDF_OK) return NULL; for (i = 0; i < max; i++, ptmp_map++) { HPDF_INT w = HPDF_TTFontDef_GetGidWidth (fontdef, *ptmp_map); if (w != dw) { if (!tmp_array) { if (HPDF_Array_AddNumber (array, i) != HPDF_OK) return NULL; tmp_array = HPDF_Array_New (font->mmgr); if (!tmp_array) return NULL; if (HPDF_Array_Add (array, tmp_array) != HPDF_OK) return NULL; } if ((ret = HPDF_Array_AddNumber (tmp_array, w)) != HPDF_OK) return NULL; } else tmp_array = NULL; } /* create "CIDToGIDMap" data */ if (fontdef_attr->embedding) { attr->map_stream = HPDF_DictStream_New (font->mmgr, xref); if (!attr->map_stream) return NULL; if (HPDF_Dict_Add (font, "CIDToGIDMap", attr->map_stream) != HPDF_OK) return NULL; for (i = 0; i < max; i++) { HPDF_BYTE u[2]; HPDF_UINT16 gid = tmp_map[i]; u[0] = (HPDF_BYTE)(gid >> 8); u[1] = (HPDF_BYTE)gid; HPDF_MemCpy ((HPDF_BYTE *)(tmp_map + i), u, 2); } if ((ret = HPDF_Stream_Write (attr->map_stream->stream, (HPDF_BYTE *)tmp_map, max * 2)) != HPDF_OK) return NULL; }
static HPDF_STATUS CIDFontType2_BeforeWrite_Func (HPDF_Dict obj) { HPDF_FontAttr font_attr = (HPDF_FontAttr)obj->attr; HPDF_FontDef def = font_attr->fontdef; HPDF_TTFontDefAttr def_attr = (HPDF_TTFontDefAttr)def->attr; HPDF_STATUS ret = 0; HPDF_Font font; HPDF_Encoder encoder = font_attr->encoder; HPDF_CMapEncoderAttr encoder_attr = (HPDF_CMapEncoderAttr)encoder->attr; HPDF_Array array; HPDF_UINT i; HPDF_UNICODE tmp_map[65536]; HPDF_UINT16 max = 0; HPDF_PTRACE ((" CIDFontType2_BeforeWrite_Func\n")); font = font_attr->descendant_font; HPDF_MemSet (tmp_map, 0, sizeof(HPDF_UNICODE) * 65536); if (ret != HPDF_OK) return ret; for (i = 0; i < 256; i++) { HPDF_UINT j; for (j = 0; j < 256; j++) { if (encoder->to_unicode_fn == HPDF_CMapEncoder_ToUnicode) { HPDF_UINT16 cid = encoder_attr->cid_map[i][j]; if (cid != 0) { HPDF_UNICODE unicode = encoder_attr->unicode_map[i][j]; HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (def, unicode); tmp_map[cid] = gid; if (max < cid) max = cid; } } else { HPDF_UNICODE unicode = (i << 8) | j; HPDF_UINT16 gid = HPDF_TTFontDef_GetGlyphid (def, unicode); tmp_map[unicode] = gid; if (max < unicode) max = unicode; } } } if (def_attr->is_cidfont) { max = def_attr->num_glyphs; } if (max > 0) { HPDF_INT16 dw = def->missing_width; HPDF_UNICODE *ptmp_map = tmp_map; HPDF_Array tmp_array = NULL; /* add 'W' element */ array = HPDF_Array_New (font->mmgr); if (!array) return HPDF_FAILD_TO_ALLOC_MEM; if (HPDF_Dict_Add (font, "W", array) != HPDF_OK) return HPDF_FAILD_TO_ALLOC_MEM; for (i = 0; i < max; i++) { HPDF_INT w; HPDF_UINT16 gid; if (def_attr->is_cidfont) { gid = i; } else { gid = *ptmp_map; ptmp_map++; } w = HPDF_TTFontDef_GetGidWidth (def, gid); if (def_attr->glyph_tbl.flgs[gid] && w != dw) { if (!tmp_array) { if (HPDF_Array_AddNumber (array, i) != HPDF_OK) return HPDF_FAILD_TO_ALLOC_MEM; tmp_array = HPDF_Array_New (font->mmgr); if (!tmp_array) return HPDF_FAILD_TO_ALLOC_MEM; if (HPDF_Array_Add (array, tmp_array) != HPDF_OK) return HPDF_FAILD_TO_ALLOC_MEM; } if ((ret = HPDF_Array_AddNumber (tmp_array, w)) != HPDF_OK) return HPDF_FAILD_TO_ALLOC_MEM; } else tmp_array = NULL; } /* create "CIDToGIDMap" data */ if (def_attr->embedding) { if (def_attr->is_cidfont) { ret += HPDF_Dict_AddName (font, "CIDToGIDMap", "Identity"); } else { font_attr->map_stream = HPDF_DictStream_New (font->mmgr, font_attr->xref); if (!font_attr->map_stream) return HPDF_FAILD_TO_ALLOC_MEM; if (HPDF_Dict_Add (font, "CIDToGIDMap", font_attr->map_stream) != HPDF_OK) return HPDF_FAILD_TO_ALLOC_MEM; for (i = 0; i < max; i++) { HPDF_BYTE u[2]; HPDF_UINT16 gid = tmp_map[i]; u[0] = (HPDF_BYTE)(gid >> 8); u[1] = (HPDF_BYTE)gid; HPDF_MemCpy ((HPDF_BYTE *)(tmp_map + i), u, 2); } if ((ret = HPDF_Stream_Write (font_attr->map_stream->stream, (HPDF_BYTE *)tmp_map, max * 2)) != HPDF_OK) return HPDF_FAILD_TO_ALLOC_MEM; } } } else {