int
jp2_get_bbox (FILE *fp, long *width, long *height,
double *xdensity, double *ydensity)
{
int r;
ximage_info info;
pdf_ximage_init_image_info(&info);
rewind(fp);
r = scan_file(&info, fp);
*width = info.width;
*height = info.height;
*xdensity = info.xdensity;
*ydensity = info.ydensity;
return r;
}
int
jp2_include_image (pdf_ximage *ximage, FILE *fp)
{
int smask = 0;
pdf_obj *stream, *stream_dict;
ximage_info info;
if (pdf_check_version(1, 5) < 0) {
WARN("JPEG 2000 support requires PDF version >= 1.5.\n");
return -1;
}
pdf_ximage_init_image_info(&info);
stream = stream_dict = NULL;
rewind(fp);
if (scan_file(&info, &smask, fp) < 0) {
WARN("JPEG2000: Reading JPEG 2000 file failed.");
return -1;
}
stream = pdf_new_stream(0);
stream_dict = pdf_stream_dict(stream);
pdf_add_dict(stream_dict,
pdf_new_name("Filter"), pdf_new_name("JPXDecode"));
if (smask)
pdf_add_dict(stream_dict,
pdf_new_name("SMaskInData"), pdf_new_number(1));
/* Read whole file */
{
int nb_read;
rewind(fp);
while ((nb_read =
fread(work_buffer, sizeof(char), WORK_BUFFER_SIZE, fp)) > 0)
pdf_add_stream(stream, work_buffer, nb_read);
}
pdf_ximage_set_image(ximage, &info, stream);
return 0;
}
int
jp2_include_image (pdf_ximage *ximage, FILE *fp)
{
unsigned pdf_version;
pdf_obj *stream, *stream_dict;
ximage_info info;
pdf_version = pdf_get_version();
if (pdf_version < 5) {
WARN("JPEG 2000 support requires PDF version >= 1.5 (Current setting 1.%d)\n", pdf_version);
return -1;
}
pdf_ximage_init_image_info(&info);
stream = stream_dict = NULL;
rewind(fp);
if (scan_file(&info, fp) < 0) {
WARN("Reading JPEG 2000 file failed.");
return -1;
}
stream = pdf_new_stream(0);
stream_dict = pdf_stream_dict(stream);
pdf_add_dict(stream_dict,
pdf_new_name("Filter"), pdf_new_name("JPXDecode"));
/* Read whole file */
{
long nb_read;
rewind(fp);
while ((nb_read =
fread(work_buffer, sizeof(char), WORK_BUFFER_SIZE, fp)) > 0)
pdf_add_stream(stream, work_buffer, nb_read);
}
pdf_ximage_set_image(ximage, &info, stream);
return 0;
}
int
png_include_image (pdf_ximage *ximage, FILE *png_file)
{
pdf_obj *stream;
pdf_obj *stream_dict;
pdf_obj *colorspace, *mask, *intent;
png_bytep stream_data_ptr;
int trans_type;
ximage_info info;
/* Libpng stuff */
png_structp png_ptr;
png_infop png_info_ptr;
png_byte bpc, color_type;
png_uint_32 width, height, rowbytes;
pdf_ximage_init_image_info(&info);
stream = NULL;
stream_dict = NULL;
colorspace = mask = intent = NULL;
rewind (png_file);
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, warn);
if (png_ptr == NULL ||
(png_info_ptr = png_create_info_struct (png_ptr)) == NULL) {
WARN("%s: Creating Libpng read/info struct failed.", PNG_DEBUG_STR);
if (png_ptr)
png_destroy_read_struct(&png_ptr, NULL, NULL);
return -1;
}
#if PNG_LIBPNG_VER >= 10603
/* ignore possibly incorrect CMF bytes */
png_set_option(png_ptr, PNG_MAXIMUM_INFLATE_WINDOW, PNG_OPTION_ON);
#endif
/* Inititializing file IO. */
png_init_io (png_ptr, png_file);
/* Read PNG info-header and get some info. */
png_read_info(png_ptr, png_info_ptr);
color_type = png_get_color_type (png_ptr, png_info_ptr);
width = png_get_image_width (png_ptr, png_info_ptr);
height = png_get_image_height(png_ptr, png_info_ptr);
bpc = png_get_bit_depth (png_ptr, png_info_ptr);
/* Ask libpng to convert down to 8-bpc. */
if (bpc > 8) {
if (pdf_get_version() < 5) {
WARN("%s: 16-bpc PNG requires PDF version 1.5.", PNG_DEBUG_STR);
png_set_strip_16(png_ptr);
bpc = 8;
}
}
/* Ask libpng to gamma-correct.
* It is wrong to assume screen gamma value 2.2 but...
* We do gamma correction here only when uncalibrated color space is used.
*/
if (!png_get_valid(png_ptr, png_info_ptr, PNG_INFO_iCCP) &&
!png_get_valid(png_ptr, png_info_ptr, PNG_INFO_sRGB) &&
!png_get_valid(png_ptr, png_info_ptr, PNG_INFO_cHRM) &&
png_get_valid(png_ptr, png_info_ptr, PNG_INFO_gAMA)) {
double G = 1.0;
png_get_gAMA (png_ptr, png_info_ptr, &G);
png_set_gamma(png_ptr, 2.2, G);
}
trans_type = check_transparency(png_ptr, png_info_ptr);
/* check_transparency() does not do updata_info() */
png_read_update_info(png_ptr, png_info_ptr);
rowbytes = png_get_rowbytes(png_ptr, png_info_ptr);
/* Values listed below will not be modified in the remaining process. */
info.width = width;
info.height = height;
info.bits_per_component = bpc;
if (compat_mode)
info.xdensity = info.ydensity = 72.0 / 100.0;
else
{
png_uint_32 xppm = png_get_x_pixels_per_meter(png_ptr, png_info_ptr);
png_uint_32 yppm = png_get_y_pixels_per_meter(png_ptr, png_info_ptr);
if (xppm > 0)
info.xdensity = 72.0 / 0.0254 / xppm;
if (yppm > 0)
info.ydensity = 72.0 / 0.0254 / yppm;
}
stream = pdf_new_stream (STREAM_COMPRESS);
stream_dict = pdf_stream_dict(stream);
stream_data_ptr = (png_bytep) NEW(rowbytes*height, png_byte);
read_image_data(png_ptr, stream_data_ptr, height, rowbytes);
/* Non-NULL intent means there is valid sRGB chunk. */
intent = get_rendering_intent(png_ptr, png_info_ptr);
if (intent)
pdf_add_dict(stream_dict, pdf_new_name("Intent"), intent);
switch (color_type) {
case PNG_COLOR_TYPE_PALETTE:
colorspace = create_cspace_Indexed(png_ptr, png_info_ptr);
switch (trans_type) {
case PDF_TRANS_TYPE_BINARY:
/* Color-key masking */
mask = create_ckey_mask(png_ptr, png_info_ptr);
break;
case PDF_TRANS_TYPE_ALPHA:
/* Soft mask */
mask = create_soft_mask(png_ptr, png_info_ptr, stream_data_ptr, width, height);
break;
default:
/* Nothing to be done here.
* No tRNS chunk or image already composited with background color.
*/
break;
}
info.num_components = 1;
break;
case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_RGB_ALPHA:
if (png_get_valid(png_ptr, png_info_ptr, PNG_INFO_iCCP))
colorspace = create_cspace_ICCBased(png_ptr, png_info_ptr);
else if (intent) {
colorspace = create_cspace_sRGB(png_ptr, png_info_ptr);
} else {
colorspace = create_cspace_CalRGB(png_ptr, png_info_ptr);
}
if (!colorspace)
colorspace = pdf_new_name("DeviceRGB");
switch (trans_type) {
case PDF_TRANS_TYPE_BINARY:
mask = create_ckey_mask(png_ptr, png_info_ptr);
break;
/* rowbytes changes 4 to 3 at here */
case PDF_TRANS_TYPE_ALPHA:
mask = strip_soft_mask(png_ptr, png_info_ptr,
stream_data_ptr, &rowbytes, width, height);
break;
default:
mask = NULL;
}
info.num_components = 3;
break;
case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_GRAY_ALPHA:
if (png_get_valid(png_ptr, png_info_ptr, PNG_INFO_iCCP))
colorspace = create_cspace_ICCBased(png_ptr, png_info_ptr);
else if (intent) {
colorspace = create_cspace_sRGB(png_ptr, png_info_ptr);
} else {
colorspace = create_cspace_CalGray(png_ptr, png_info_ptr);
}
if (!colorspace)
colorspace = pdf_new_name("DeviceGray");
switch (trans_type) {
case PDF_TRANS_TYPE_BINARY:
mask = create_ckey_mask(png_ptr, png_info_ptr);
break;
case PDF_TRANS_TYPE_ALPHA:
mask = strip_soft_mask(png_ptr, png_info_ptr,
stream_data_ptr, &rowbytes, width, height);
break;
default:
mask = NULL;
}
info.num_components = 1;
break;
default:
WARN("%s: Unknown PNG colortype %d.", PNG_DEBUG_STR, color_type);
}
pdf_add_dict(stream_dict, pdf_new_name("ColorSpace"), colorspace);
pdf_add_stream(stream, stream_data_ptr, rowbytes*height);
RELEASE(stream_data_ptr);
if (mask) {
if (trans_type == PDF_TRANS_TYPE_BINARY)
pdf_add_dict(stream_dict, pdf_new_name("Mask"), mask);
else if (trans_type == PDF_TRANS_TYPE_ALPHA) {
if (info.bits_per_component >= 8 && info.width > 64) {
pdf_stream_set_predictor(mask, 2, info.width,
info.bits_per_component, 1);
}
pdf_add_dict(stream_dict, pdf_new_name("SMask"), pdf_ref_obj(mask));
pdf_release_obj(mask);
} else {
WARN("%s: Unknown transparency type...???", PNG_DEBUG_STR);
pdf_release_obj(mask);
}
}
/* Finally read XMP Metadata
* See, XMP Specification Part 3, Storage in Files
* http://www.adobe.com/jp/devnet/xmp.html
*
* We require libpng version >= 1.6.14 since prior versions
* of libpng had a bug that incorrectly treat the compression
* flag of iTxt chunks.
*/
#if PNG_LIBPNG_VER >= 10614
if (pdf_get_version() >= 4) {
png_textp text_ptr;
pdf_obj *XMP_stream, *XMP_stream_dict;
int i, num_text;
int have_XMP = 0;
num_text = png_get_text(png_ptr, png_info_ptr, &text_ptr, NULL);
for (i = 0; i < num_text; i++) {
if (!memcmp(text_ptr[i].key, "XML:com.adobe.xmp", 17)) {
/* XMP found */
if (text_ptr[i].compression != PNG_ITXT_COMPRESSION_NONE ||
text_ptr[i].itxt_length == 0)
WARN("%s: Invalid value(s) in iTXt chunk for XMP Metadata.", PNG_DEBUG_STR);
else if (have_XMP)
WARN("%s: Multiple XMP Metadata. Don't know how to treat it.", PNG_DEBUG_STR);
else {
/* We compress XMP metadata for included images here.
* It is not recommended to compress XMP metadata for PDF documents but
* we compress XMP metadata for included images here to avoid confusing
* application programs that only want PDF document global XMP metadata
* and scan for that.
*/
XMP_stream = pdf_new_stream(STREAM_COMPRESS);
XMP_stream_dict = pdf_stream_dict(XMP_stream);
pdf_add_dict(XMP_stream_dict,
pdf_new_name("Type"), pdf_new_name("Metadata"));
pdf_add_dict(XMP_stream_dict,
pdf_new_name("Subtype"), pdf_new_name("XML"));
pdf_add_stream(XMP_stream, text_ptr[i].text, text_ptr[i].itxt_length);
pdf_add_dict(stream_dict,
pdf_new_name("Metadata"), pdf_ref_obj(XMP_stream));
pdf_release_obj(XMP_stream);
have_XMP = 1;
}
}
}
}
#endif /* PNG_LIBPNG_VER */
png_read_end(png_ptr, NULL);
/* Cleanup */
if (png_info_ptr)
png_destroy_info_struct(png_ptr, &png_info_ptr);
if (png_ptr)
png_destroy_read_struct(&png_ptr, NULL, NULL);
if (color_type != PNG_COLOR_TYPE_PALETTE &&
info.bits_per_component >= 8 &&
info.height > 64) {
pdf_stream_set_predictor(stream, 15, info.width,
info.bits_per_component, info.num_components);
}
pdf_ximage_set_image(ximage, &info, stream);
return 0;
}
int
jpeg_include_image (pdf_ximage *ximage, FILE *fp)
{
pdf_obj *stream;
pdf_obj *stream_dict;
pdf_obj *colorspace;
int colortype;
ximage_info info;
struct JPEG_info j_info;
if (!check_for_jpeg(fp)) {
WARN("%s: Not a JPEG file?", JPEG_DEBUG_STR);
rewind(fp);
return -1;
}
/* File position is 2 here... */
pdf_ximage_init_image_info(&info);
JPEG_info_init(&j_info);
if (JPEG_scan_file(&j_info, fp) < 0) {
WARN("%s: Not a JPEG file?", JPEG_DEBUG_STR);
JPEG_info_clear(&j_info);
return -1;
}
switch (j_info.num_components) {
case 1:
colortype = PDF_COLORSPACE_TYPE_GRAY;
break;
case 3:
colortype = PDF_COLORSPACE_TYPE_RGB;
break;
case 4:
colortype = PDF_COLORSPACE_TYPE_CMYK;
break;
default:
WARN("%s: Unknown color space (num components: %d)",
JPEG_DEBUG_STR, info.num_components);
JPEG_info_clear(&j_info);
return -1;
}
/* JPEG image use DCTDecode. */
stream = pdf_new_stream (0);
stream_dict = pdf_stream_dict(stream);
pdf_add_dict(stream_dict,
pdf_new_name("Filter"), pdf_new_name("DCTDecode"));
colorspace = NULL;
if (j_info.flags & HAVE_APPn_ICC) {
pdf_obj *icc_stream, *intent;
icc_stream = JPEG_get_iccp(&j_info);
if (!icc_stream)
colorspace = NULL;
else {
int cspc_id;
if (iccp_check_colorspace(colortype,
pdf_stream_dataptr(icc_stream),
pdf_stream_length (icc_stream)) < 0)
colorspace = NULL;
else {
cspc_id = iccp_load_profile(NULL, /* noname */
pdf_stream_dataptr(icc_stream),
pdf_stream_length (icc_stream));
if (cspc_id < 0)
colorspace = NULL;
else {
colorspace = pdf_get_colorspace_reference(cspc_id);
intent = iccp_get_rendering_intent(pdf_stream_dataptr(icc_stream),
pdf_stream_length (icc_stream));
if (intent)
pdf_add_dict(stream_dict, pdf_new_name("Intent"), intent);
}
}
pdf_release_obj(icc_stream);
}
}
/* No ICC or invalid ICC profile. */
if (!colorspace) {
switch (colortype) {
case PDF_COLORSPACE_TYPE_GRAY:
colorspace = pdf_new_name("DeviceGray");
break;
case PDF_COLORSPACE_TYPE_RGB:
colorspace = pdf_new_name("DeviceRGB");
break;
case PDF_COLORSPACE_TYPE_CMYK:
colorspace = pdf_new_name("DeviceCMYK");
break;
}
}
pdf_add_dict(stream_dict, pdf_new_name("ColorSpace"), colorspace);
#define IS_ADOBE_CMYK(j) (((j).flags & HAVE_APPn_ADOBE) && (j).num_components == 4)
if (IS_ADOBE_CMYK(j_info)) {
pdf_obj *decode;
int i;
WARN("Adobe CMYK JPEG: Inverted color assumed.");
decode = pdf_new_array();
for (i = 0; i < j_info.num_components; i++) {
pdf_add_array(decode, pdf_new_number(1.0));
pdf_add_array(decode, pdf_new_number(0.0));
}
pdf_add_dict(stream_dict, pdf_new_name("Decode"), decode);
}
/* Copy file */
JPEG_copy_stream(&j_info, stream, fp);
info.width = j_info.width;
info.height = j_info.height;
info.bits_per_component = j_info.bits_per_component;
info.num_components = j_info.num_components;
jpeg_get_density(&j_info, &info.xdensity, &info.ydensity);
pdf_ximage_set_image(ximage, &info, stream);
JPEG_info_clear(&j_info);
return 0;
}
int
bmp_include_image (pdf_ximage *ximage, FILE *fp)
{
pdf_obj *stream, *stream_dict, *colorspace;
ximage_info info;
struct hdr_info hdr;
int num_palette, flip;
int i;
pdf_ximage_init_image_info(&info);
stream = stream_dict = colorspace = NULL;
rewind(fp);
if (read_header(fp, &hdr) < 0)
return -1;
get_density(&info.xdensity, &info.ydensity, &hdr);
info.width = hdr.width;
info.height = hdr.height;
if (info.height < 0) {
info.height = -info.height;
flip = 0;
} else {
flip = 1;
}
if (hdr.bit_count < 24) {
if (hdr.bit_count != 1 &&
hdr.bit_count != 4 && hdr.bit_count != 8) {
WARN("Unsupported palette size: %ld", hdr.bit_count);
return -1;
}
num_palette = (hdr.offset - hdr.hsize - DIB_FILE_HEADER_SIZE) / hdr.psize;
info.bits_per_component = hdr.bit_count;
info.num_components = 1;
} else if (hdr.bit_count == 24) { /* full color */
num_palette = 1; /* dummy */
info.bits_per_component = 8;
info.num_components = 3;
} else {
WARN("Unkown/Unsupported BMP bitCount value: %ld", hdr.bit_count);
return -1;
}
if (info.width == 0 || info.height == 0 || num_palette < 1) {
WARN("Invalid BMP file: width=%ld, height=%ld, #palette=%d",
info.width, info.height, num_palette);
return -1;
}
/* Start reading raster data */
stream = pdf_new_stream(STREAM_COMPRESS);
stream_dict = pdf_stream_dict(stream);
/* Color space: Indexed or DeviceRGB */
if (hdr.bit_count < 24) {
pdf_obj *lookup;
unsigned char *palette, bgrq[4];
palette = NEW(num_palette*3+1, unsigned char);
for (i = 0; i < num_palette; i++) {
if (fread(bgrq, 1, hdr.psize, fp) != hdr.psize) {
WARN("Reading file failed...");
RELEASE(palette);
return -1;
}
/* BGR data */
palette[3*i ] = bgrq[2];
palette[3*i+1] = bgrq[1];
palette[3*i+2] = bgrq[0];
}
lookup = pdf_new_string(palette, num_palette*3);
RELEASE(palette);
colorspace = pdf_new_array();
pdf_add_array(colorspace, pdf_new_name("Indexed"));
pdf_add_array(colorspace, pdf_new_name("DeviceRGB"));
pdf_add_array(colorspace, pdf_new_number(num_palette-1));
pdf_add_array(colorspace, lookup);
} else {