HPDF_LoadU3DFromFile (HPDF_Doc pdf,
const char *filename)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadU3DFromFile\n"));
if (!HPDF_HasDoc (pdf)) {
return NULL;
}
/* create file stream */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata)) {
image = HPDF_U3D_LoadU3D (pdf->mmgr, imagedata, pdf->xref);
} else {
image = NULL;
}
/* destroy file stream */
HPDF_Stream_Free (imagedata);
if (!image) {
HPDF_CheckError (&pdf->error);
}
return image;
}
HPDF_ReadFromStream (HPDF_Doc pdf,
HPDF_BYTE *buf,
HPDF_UINT32 *size)
{
HPDF_UINT isize = *size;
HPDF_STATUS ret;
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!HPDF_Stream_Validate (pdf->stream))
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_OPERATION, 0);
if (*size == 0)
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_PARAMETER, 0);
ret = HPDF_Stream_Read (pdf->stream, buf, &isize);
*size = isize;
if (ret != HPDF_OK)
HPDF_CheckError (&pdf->error);
return ret;
}
HPDF_Image
HPDF_Image_LoadJpegImageFromMem (HPDF_MMgr mmgr,
const HPDF_BYTE *buf,
HPDF_UINT size,
HPDF_Xref xref)
{
HPDF_Stream jpeg_data;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_Image_LoadJpegImageFromMem\n"));
jpeg_data = HPDF_MemStream_New(mmgr,size);
if (!HPDF_Stream_Validate (jpeg_data)) {
HPDF_RaiseError (mmgr->error, HPDF_INVALID_STREAM, 0);
return NULL;
}
if (HPDF_Stream_Write (jpeg_data, buf, size) != HPDF_OK) {
HPDF_Stream_Free (jpeg_data);
return NULL;
}
image = HPDF_Image_LoadJpegImage(mmgr,jpeg_data,xref);
/* destroy file stream */
HPDF_Stream_Free (jpeg_data);
return image;
}
HPDF_LoadTTFontFromFile2 (HPDF_Doc pdf,
const char *file_name,
HPDF_UINT index,
HPDF_BOOL embedding)
{
HPDF_Stream font_data;
const char *ret;
HPDF_PTRACE ((" HPDF_LoadTTFontFromFile2\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
font_data = HPDF_FileReader_New (pdf->mmgr, file_name);
if (HPDF_Stream_Validate (font_data)) {
ret = LoadTTFontFromStream2 (pdf, font_data, index, embedding, file_name);
} else
ret = NULL;
if (!ret)
HPDF_CheckError (&pdf->error);
return ret;
}
HPDF_LoadRawImageFromFile (HPDF_Doc pdf,
const char *filename,
HPDF_UINT width,
HPDF_UINT height,
HPDF_ColorSpace color_space)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadRawImageFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata))
image = HPDF_Image_LoadRawImage (pdf->mmgr, imagedata, pdf->xref, width,
height, color_space);
else
image = NULL;
/* destroy file stream */
HPDF_Stream_Free (imagedata);
if (!image)
HPDF_CheckError (&pdf->error);
if (image && pdf->compression_mode & HPDF_COMP_IMAGE)
image->filter = HPDF_STREAM_FILTER_FLATE_DECODE;
return image;
}
HPDF_LoadPngImageFromFile (HPDF_Doc pdf,
const HPDF_CHAR *filename)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadPngImageFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata))
image = LoadPngImageFromStream (pdf, imagedata, HPDF_FALSE);
else
image = NULL;
/* destroy file stream */
if (imagedata)
HPDF_Stream_Free (imagedata);
if (!image)
HPDF_CheckError (&pdf->error);
return image;
}
HPDF_ResetStream (HPDF_Doc pdf)
{
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!HPDF_Stream_Validate (pdf->stream))
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_OPERATION, 0);
return HPDF_Stream_Seek (pdf->stream, 0, HPDF_SEEK_SET);
}
HPDF_GetStreamSize (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_GetStreamSize\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!HPDF_Stream_Validate (pdf->stream))
return 0;
return HPDF_Stream_Size(pdf->stream);
}
HPDF_LoadU3DFromMem (HPDF_Doc pdf,
const HPDF_BYTE *buffer,
HPDF_UINT size)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_PTRACE ((" HPDF_LoadU3DFromMem\n"));
if (!HPDF_HasDoc (pdf)) {
return NULL;
}
/* create file stream */
imagedata = HPDF_MemStream_New (pdf->mmgr, size);
if (!HPDF_Stream_Validate (imagedata)) {
HPDF_RaiseError (&pdf->error, HPDF_INVALID_STREAM, 0);
return NULL;
}
if (HPDF_Stream_Write (imagedata, buffer, size) != HPDF_OK) {
HPDF_Stream_Free (imagedata);
return NULL;
}
if (HPDF_Stream_Validate (imagedata)) {
image = HPDF_U3D_LoadU3D (pdf->mmgr, imagedata, pdf->xref);
} else {
image = NULL;
}
/* destroy file stream */
HPDF_Stream_Free (imagedata);
if (!image) {
HPDF_CheckError (&pdf->error);
}
return image;
}
HPDF_LoadType1FontFromFile (HPDF_Doc pdf,
const char *afm_file_name,
const char *data_file_name)
{
HPDF_Stream afm;
HPDF_Stream pfm = NULL;
const char *ret;
HPDF_PTRACE ((" HPDF_LoadType1FontFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* create file stream */
afm = HPDF_FileReader_New (pdf->mmgr, afm_file_name);
if (data_file_name)
pfm = HPDF_FileReader_New (pdf->mmgr, data_file_name);
if (HPDF_Stream_Validate (afm) &&
(!data_file_name || HPDF_Stream_Validate (pfm))) {
ret = LoadType1FontFromStream (pdf, afm, pfm);
} else
ret = NULL;
/* destroy file stream */
if (afm)
HPDF_Stream_Free (afm);
if (pfm)
HPDF_Stream_Free (pfm);
if (!ret)
HPDF_CheckError (&pdf->error);
return ret;
}
HPDF_LoadPngImageFromFile2 (HPDF_Doc pdf,
const char *filename)
{
HPDF_Stream imagedata;
HPDF_Image image;
HPDF_String fname;
HPDF_PTRACE ((" HPDF_LoadPngImageFromFile\n"));
if (!HPDF_HasDoc (pdf))
return NULL;
/* check whether file name is valid or not. */
imagedata = HPDF_FileReader_New (pdf->mmgr, filename);
if (HPDF_Stream_Validate (imagedata))
image = LoadPngImageFromStream (pdf, imagedata, HPDF_TRUE);
else
image = NULL;
/* destroy file stream */
if (imagedata)
HPDF_Stream_Free (imagedata);
if (!image) {
HPDF_CheckError (&pdf->error);
return NULL;
}
/* add file-name to image dictionary as a hidden entry.
* it is used when the image data is needed.
*/
fname = HPDF_String_New (pdf->mmgr, filename, NULL);
if (!fname) {
HPDF_CheckError (&pdf->error);
return NULL;
}
fname->header.obj_id |= HPDF_OTYPE_HIDDEN;
if ((HPDF_Dict_Add (image, "_FILE_NAME", fname)) != HPDF_OK) {
HPDF_CheckError (&pdf->error);
return NULL;
}
return image;
}
HPDF_SaveToStream (HPDF_Doc pdf)
{
HPDF_PTRACE ((" HPDF_SaveToStream\n"));
if (!HPDF_HasDoc (pdf))
return HPDF_INVALID_DOCUMENT;
if (!pdf->stream)
pdf->stream = HPDF_MemStream_New (pdf->mmgr, HPDF_STREAM_BUF_SIZ);
if (!HPDF_Stream_Validate (pdf->stream))
return HPDF_RaiseError (&pdf->error, HPDF_INVALID_STREAM, 0);
HPDF_MemStream_FreeData (pdf->stream);
if (InternalSaveToStream (pdf, pdf->stream) != HPDF_OK)
return HPDF_CheckError (&pdf->error);
return HPDF_OK;
}
HPDF_GetTTFontDefFromFile (HPDF_Doc pdf,
const char *file_name,
HPDF_BOOL embedding)
{
HPDF_Stream font_data;
HPDF_FontDef def;
HPDF_PTRACE ((" HPDF_GetTTFontDefFromFile\n"));
/* create file stream */
font_data = HPDF_FileReader_New (pdf->mmgr, file_name);
if (HPDF_Stream_Validate (font_data)) {
def = HPDF_TTFontDef_Load (pdf->mmgr, font_data, embedding);
} else {
HPDF_CheckError (&pdf->error);
return NULL;
}
return def;
}
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, (const char *)(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, NULL, png_data, HPDF_FALSE)) != HPDF_OK) {
HPDF_Stream_Free(png_data);
return ret;
}
HPDF_Stream_Free(png_data);
return HPDF_OK;
}
