static void drawbmp(fz_context *ctx, fz_document *doc, fz_page *page, fz_display_list *list, int pagenum, fz_cookie *cookie)
{
float zoom;
fz_matrix ctm;
fz_irect ibounds;
fz_rect bounds, tbounds;
int w, h;
fz_device *dev;
HDC dc, dc_main;
RECT rc;
HBRUSH bg_brush;
HBITMAP hbmp;
BITMAPINFO bmi = { 0 };
int bmp_data_len;
unsigned char *bmp_data;
int as_tga = !strstr(output, ".bmp");
fz_bound_page(doc, page, &bounds);
zoom = resolution / 72;
fz_pre_scale(fz_rotate(&ctm, rotation), zoom, zoom);
tbounds = bounds;
fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
w = width;
h = height;
if (res_specified)
{
fz_round_rect(&ibounds, &tbounds);
if (w && ibounds.x1 - ibounds.x0 <= w)
w = 0;
if (h && ibounds.y1 - ibounds.y0 <= h)
h = 0;
}
if (w || h)
{
float scalex = w / (tbounds.x1 - tbounds.x0);
float scaley = h / (tbounds.y1 - tbounds.y0);
fz_matrix scale_mat;
if (w == 0)
scalex = fit ? 1.0f : scaley;
if (h == 0)
scaley = fit ? 1.0f : scalex;
if (!fit)
scalex = scaley = min(scalex, scaley);
fz_concat(&ctm, &ctm, fz_scale(&scale_mat, scalex, scaley));
tbounds = bounds;
fz_transform_rect(&tbounds, &ctm);
}
fz_round_rect(&ibounds, &tbounds);
fz_rect_from_irect(&tbounds, &ibounds);
w = ibounds.x1 - ibounds.x0;
h = ibounds.y1 - ibounds.y0;
dc_main = GetDC(NULL);
dc = CreateCompatibleDC(dc_main);
hbmp = CreateCompatibleBitmap(dc_main, w, h);
DeleteObject(SelectObject(dc, hbmp));
SetRect(&rc, 0, 0, w, h);
bg_brush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF));
FillRect(dc, &rc, bg_brush);
DeleteObject(bg_brush);
dev = fz_new_gdiplus_device(ctx, dc, &tbounds);
if (list)
fz_run_display_list(list, dev, &ctm, &tbounds, cookie);
else
fz_run_page(doc, page, dev, &ctm, cookie);
fz_free_device(dev);
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = as_tga ? -h : h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = as_tga ? 32 : 24;
bmi.bmiHeader.biCompression = BI_RGB;
bmp_data_len = as_tga ? w * h * 4 : ((w * 3 + 3) / 4) * 4 * h;
bmp_data = fz_malloc(ctx, bmp_data_len);
if (!GetDIBits(dc, hbmp, 0, h, bmp_data, &bmi, DIB_RGB_COLORS))
fz_throw(ctx, "cannot draw page %d in PDF file '%s'", pagenum, filename);
DeleteDC(dc);
ReleaseDC(NULL, dc_main);
DeleteObject(hbmp);
if (output)
{
char buf[512];
FILE *f;
sprintf(buf, output, pagenum);
f = fopen(buf, "wb");
if (!f)
fz_throw(ctx, "could not create raster file '%s'", buf);
if (as_tga)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr, w, h, bmp_data);
fz_write_tga(ctx, pix, buf, 0);
fz_drop_pixmap(ctx, pix);
}
else
{
BITMAPFILEHEADER bmpfh = { 0 };
static const int one = 1;
if (!*(char *)&one)
fz_throw(ctx, "rendering to BMP is not supported on big-endian architectures");
bmpfh.bfType = MAKEWORD('B', 'M');
bmpfh.bfOffBits = sizeof(bmpfh) + sizeof(bmi);
bmpfh.bfSize = bmpfh.bfOffBits + bmp_data_len;
fwrite(&bmpfh, sizeof(bmpfh), 1, f);
fwrite(&bmi, sizeof(bmi), 1, f);
fwrite(bmp_data, 1, bmp_data_len, f);
}
fclose(f);
}
if (showmd5)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr, bmp_data_len / 4 / h, h, bmp_data);
unsigned char digest[16];
int i;
fz_md5_pixmap(pix, digest);
printf(" ");
for (i = 0; i < 16; i++)
printf("%02x", digest[i]);
fz_drop_pixmap(ctx, pix);
}
fz_free(ctx, bmp_data);
}
static fz_image *
pdf_load_jpx(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int forcemask)
{
fz_buffer *buf = NULL;
fz_colorspace *colorspace = NULL;
fz_pixmap *pix = NULL;
pdf_obj *obj;
fz_image *mask = NULL;
fz_image *img = NULL;
fz_var(pix);
fz_var(buf);
fz_var(colorspace);
fz_var(mask);
buf = pdf_load_stream(ctx, dict);
/* FIXME: We can't handle decode arrays for indexed images currently */
fz_try(ctx)
{
unsigned char *data;
size_t len;
obj = pdf_dict_get(ctx, dict, PDF_NAME(ColorSpace));
if (obj)
colorspace = pdf_load_colorspace(ctx, obj);
len = fz_buffer_storage(ctx, buf, &data);
pix = fz_load_jpx(ctx, data, len, colorspace);
obj = pdf_dict_geta(ctx, dict, PDF_NAME(SMask), PDF_NAME(Mask));
if (pdf_is_dict(ctx, obj))
{
if (forcemask)
fz_warn(ctx, "Ignoring recursive JPX soft mask");
else
mask = pdf_load_image_imp(ctx, doc, NULL, obj, NULL, 1);
}
obj = pdf_dict_geta(ctx, dict, PDF_NAME(Decode), PDF_NAME(D));
if (obj && !fz_colorspace_is_indexed(ctx, colorspace))
{
float decode[FZ_MAX_COLORS * 2];
int i;
for (i = 0; i < pix->n * 2; i++)
decode[i] = pdf_array_get_real(ctx, obj, i);
fz_decode_tile(ctx, pix, decode);
}
img = fz_new_image_from_pixmap(ctx, pix, mask);
}
fz_always(ctx)
{
fz_drop_image(ctx, mask);
fz_drop_pixmap(ctx, pix);
fz_drop_colorspace(ctx, colorspace);
fz_drop_buffer(ctx, buf);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return img;
}
pdf_obj *
pdf_add_image(fz_context *ctx, pdf_document *doc, fz_image *image)
{
fz_pixmap *pixmap = NULL;
pdf_obj *imobj = NULL;
pdf_obj *dp;
fz_buffer *buffer = NULL;
pdf_obj *imref = NULL;
fz_compressed_buffer *cbuffer;
unsigned char digest[16];
int i, n;
/* If we can maintain compression, do so */
cbuffer = fz_compressed_image_buffer(ctx, image);
fz_var(pixmap);
fz_var(buffer);
fz_var(imobj);
fz_var(imref);
/* Check if the same image already exists in this doc. */
imref = pdf_find_image_resource(ctx, doc, image, digest);
if (imref)
return imref;
imobj = pdf_add_new_dict(ctx, doc, 3);
fz_try(ctx)
{
dp = pdf_dict_put_dict(ctx, imobj, PDF_NAME(DecodeParms), 3);
pdf_dict_put(ctx, imobj, PDF_NAME(Type), PDF_NAME(XObject));
pdf_dict_put(ctx, imobj, PDF_NAME(Subtype), PDF_NAME(Image));
if (cbuffer)
{
fz_compression_params *cp = &cbuffer->params;
switch (cp ? cp->type : FZ_IMAGE_UNKNOWN)
{
default:
goto raw_or_unknown_compression;
case FZ_IMAGE_JPEG:
if (cp->u.jpeg.color_transform != -1)
pdf_dict_put_int(ctx, dp, PDF_NAME(ColorTransform), cp->u.jpeg.color_transform);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(DCTDecode));
break;
case FZ_IMAGE_JPX:
if (cp->u.jpx.smask_in_data)
pdf_dict_put_int(ctx, dp, PDF_NAME(SMaskInData), cp->u.jpx.smask_in_data);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(JPXDecode));
break;
case FZ_IMAGE_FAX:
if (cp->u.fax.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.fax.columns);
if (cp->u.fax.rows)
pdf_dict_put_int(ctx, dp, PDF_NAME(Rows), cp->u.fax.rows);
if (cp->u.fax.k)
pdf_dict_put_int(ctx, dp, PDF_NAME(K), cp->u.fax.k);
if (cp->u.fax.end_of_line)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EndOfLine), cp->u.fax.end_of_line);
if (cp->u.fax.encoded_byte_align)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EncodedByteAlign), cp->u.fax.encoded_byte_align);
if (cp->u.fax.end_of_block)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EndOfBlock), cp->u.fax.end_of_block);
if (cp->u.fax.black_is_1)
pdf_dict_put_bool(ctx, dp, PDF_NAME(BlackIs1), cp->u.fax.black_is_1);
if (cp->u.fax.damaged_rows_before_error)
pdf_dict_put_int(ctx, dp, PDF_NAME(DamagedRowsBeforeError), cp->u.fax.damaged_rows_before_error);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(CCITTFaxDecode));
break;
case FZ_IMAGE_FLATE:
if (cp->u.flate.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.flate.columns);
if (cp->u.flate.colors)
pdf_dict_put_int(ctx, dp, PDF_NAME(Colors), cp->u.flate.colors);
if (cp->u.flate.predictor)
pdf_dict_put_int(ctx, dp, PDF_NAME(Predictor), cp->u.flate.predictor);
if (cp->u.flate.bpc)
pdf_dict_put_int(ctx, dp, PDF_NAME(BitsPerComponent), cp->u.flate.bpc);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(FlateDecode));
pdf_dict_put_int(ctx, imobj, PDF_NAME(BitsPerComponent), image->bpc);
break;
case FZ_IMAGE_LZW:
if (cp->u.lzw.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.lzw.columns);
if (cp->u.lzw.colors)
pdf_dict_put_int(ctx, dp, PDF_NAME(Colors), cp->u.lzw.colors);
if (cp->u.lzw.predictor)
pdf_dict_put_int(ctx, dp, PDF_NAME(Predictor), cp->u.lzw.predictor);
if (cp->u.lzw.early_change)
pdf_dict_put_int(ctx, dp, PDF_NAME(EarlyChange), cp->u.lzw.early_change);
if (cp->u.lzw.bpc)
pdf_dict_put_int(ctx, dp, PDF_NAME(BitsPerComponent), cp->u.lzw.bpc);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(LZWDecode));
break;
case FZ_IMAGE_RLD:
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(RunLengthDecode));
break;
}
if (!pdf_dict_len(ctx, dp))
pdf_dict_del(ctx, imobj, PDF_NAME(DecodeParms));
buffer = fz_keep_buffer(ctx, cbuffer->buffer);
if (image->use_decode)
{
pdf_obj *ary = pdf_dict_put_array(ctx, imobj, PDF_NAME(Decode), image->n * 2);
for (i = 0; i < image->n * 2; ++i)
pdf_array_push_real(ctx, ary, image->decode[i]);
}
}
else
{
unsigned int size;
int h;
unsigned char *d, *s;
raw_or_unknown_compression:
/* Currently, set to maintain resolution; should we consider
* subsampling here according to desired output res? */
pixmap = fz_get_pixmap_from_image(ctx, image, NULL, NULL, NULL, NULL);
n = pixmap->n - pixmap->alpha - pixmap->s; /* number of colorants */
if (n == 0)
n = 1; /* treat pixmaps with only alpha or spots as grayscale */
size = image->w * n;
h = image->h;
s = pixmap->samples;
d = fz_malloc(ctx, size * h);
buffer = fz_new_buffer_from_data(ctx, d, size * h);
if (n == pixmap->n)
{
/* If we use all channels, we can copy the data as is. */
while (h--)
{
memcpy(d, s, size);
d += size;
s += pixmap->stride;
}
}
else
{
/* Need to remove the alpha and spot planes. */
/* TODO: extract alpha plane to a soft mask. */
/* TODO: convert spots to colors. */
int line_skip = pixmap->stride - pixmap->w * pixmap->n;
int skip = pixmap->n - n;
while (h--)
{
int w = pixmap->w;
while (w--)
{
int k;
for (k = 0; k < n; ++k)
*d++ = *s++;
s += skip;
}
s += line_skip;
}
}
}
pdf_dict_put_int(ctx, imobj, PDF_NAME(Width), pixmap ? pixmap->w : image->w);
pdf_dict_put_int(ctx, imobj, PDF_NAME(Height), pixmap ? pixmap->h : image->h);
if (image->imagemask)
{
pdf_dict_put_bool(ctx, imobj, PDF_NAME(ImageMask), 1);
}
else
{
fz_colorspace *cs;
pdf_dict_put_int(ctx, imobj, PDF_NAME(BitsPerComponent), image->bpc);
cs = pixmap ? pixmap->colorspace : image->colorspace;
switch (fz_colorspace_type(ctx, cs))
{
case FZ_COLORSPACE_INDEXED:
{
fz_colorspace *basecs;
unsigned char *lookup = NULL;
int high = 0;
int basen;
pdf_obj *arr;
lookup = fz_indexed_colorspace_palette(ctx, cs, &high);
basecs = fz_colorspace_base(ctx, cs);
basen = fz_colorspace_n(ctx, basecs);
arr = pdf_dict_put_array(ctx, imobj, PDF_NAME(ColorSpace), 4);
pdf_array_push(ctx, arr, PDF_NAME(Indexed));
switch (fz_colorspace_type(ctx, basecs))
{
case FZ_COLORSPACE_GRAY:
pdf_array_push(ctx, arr, PDF_NAME(DeviceGray));
break;
case FZ_COLORSPACE_RGB:
pdf_array_push(ctx, arr, PDF_NAME(DeviceRGB));
break;
case FZ_COLORSPACE_CMYK:
pdf_array_push(ctx, arr, PDF_NAME(DeviceCMYK));
break;
default:
// TODO: convert to RGB!
fz_throw(ctx, FZ_ERROR_GENERIC, "only indexed Gray, RGB, and CMYK colorspaces supported");
break;
}
pdf_array_push_int(ctx, arr, high);
pdf_array_push_string(ctx, arr, (char *) lookup, basen * (high + 1));
}
break;
case FZ_COLORSPACE_NONE:
case FZ_COLORSPACE_GRAY:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceGray));
break;
case FZ_COLORSPACE_RGB:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceRGB));
break;
case FZ_COLORSPACE_CMYK:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceCMYK));
break;
default:
// TODO: convert to RGB!
fz_throw(ctx, FZ_ERROR_GENERIC, "only Gray, RGB, and CMYK colorspaces supported");
break;
}
}
if (image->mask)
{
pdf_dict_put_drop(ctx, imobj, PDF_NAME(SMask), pdf_add_image(ctx, doc, image->mask));
}
pdf_update_stream(ctx, doc, imobj, buffer, 1);
/* Add ref to our image resource hash table. */
imref = pdf_insert_image_resource(ctx, doc, digest, imobj);
}
fz_always(ctx)
{
fz_drop_pixmap(ctx, pixmap);
fz_drop_buffer(ctx, buffer);
pdf_drop_obj(ctx, imobj);
}
fz_catch(ctx)
fz_rethrow(ctx);
return imref;
}
int main(int argc, char **argv)
{
char *filename = argc >= 2 ? argv[1] : "";
pthread_t *thread = NULL;
fz_locks_context locks;
pthread_mutex_t mutex[FZ_LOCK_MAX];
fz_context *ctx;
fz_document *doc;
int threads;
int i;
// Initialize FZ_LOCK_MAX number of non-recursive mutexes.
for (i = 0; i < FZ_LOCK_MAX; i++)
{
if (pthread_mutex_init(&mutex[i], NULL) != 0)
fail("pthread_mutex_init()");
}
// Initialize the locking structure with function pointers to
// the locking functions and to the user data. In this case
// the user data is a pointer to the array of mutexes so the
// locking functions can find the relevant lock to change when
// they are called. This way we avoid global variables.
locks.user = mutex;
locks.lock = lock_mutex;
locks.unlock = unlock_mutex;
// This is the main threads context function, so supply the
// locking structure. This context will be used to parse all
// the pages from the document.
ctx = fz_new_context(NULL, &locks, FZ_STORE_UNLIMITED);
// Register default file types.
fz_register_document_handlers(ctx);
// Open the PDF, XPS or CBZ document. Note, this binds doc to ctx.
// You must only ever use doc with ctx - never a clone of it!
doc = fz_open_document(ctx, filename);
// Retrieve the number of pages, which translates to the
// number of threads used for rendering pages.
threads = fz_count_pages(ctx, doc);
fprintf(stderr, "spawning %d threads, one per page...\n", threads);
thread = malloc(threads * sizeof (pthread_t));
for (i = 0; i < threads; i++)
{
fz_page *page;
fz_rect bbox;
fz_irect rbox;
fz_display_list *list;
fz_device *dev;
fz_pixmap *pix;
struct data *data;
// Load the relevant page for each thread. Note, that this
// cannot be done on the worker threads, as each use of doc
// uses ctx, and only one thread can be using ctx at a time.
page = fz_load_page(ctx, doc, i);
// Compute the bounding box for each page.
fz_bound_page(ctx, page, &bbox);
// Create a display list that will hold the drawing
// commands for the page. Once we have the display list
// this can safely be used on any other thread as it is
// not bound to a given context.
list = fz_new_display_list(ctx);
// Run the loaded page through a display list device
// to populate the page's display list.
dev = fz_new_list_device(ctx, list);
fz_run_page(ctx, page, dev, &fz_identity, NULL);
fz_drop_device(ctx, dev);
// The page is no longer needed, all drawing commands
// are now in the display list.
fz_drop_page(ctx, page);
// Create a white pixmap using the correct dimensions.
pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb(ctx), fz_round_rect(&rbox, &bbox));
fz_clear_pixmap_with_value(ctx, pix, 0xff);
// Populate the data structure to be sent to the
// rendering thread for this page.
data = malloc(sizeof (struct data));
data->pagenumber = i + 1;
data->ctx = ctx;
data->list = list;
data->bbox = bbox;
data->pix = pix;
// Create the thread and pass it the data structure.
if (pthread_create(&thread[i], NULL, renderer, data) != 0)
fail("pthread_create()");
}
// Now each thread is rendering pages, so wait for each thread
// to complete its rendering.
fprintf(stderr, "joining %d threads...\n", threads);
for (i = threads - 1; i >= 0; i--)
{
char filename[42];
struct data *data;
if (pthread_join(thread[i], (void **) &data) != 0)
fail("pthread_join");
sprintf(filename, "out%04d.png", i);
fprintf(stderr, "\tSaving %s...\n", filename);
// Write the rendered image to a PNG file
fz_save_pixmap_as_png(ctx, data->pix, filename, 0);
// Free the thread's pixmap and display list since
// they were allocated by the main thread above.
fz_drop_pixmap(ctx, data->pix);
fz_drop_display_list(ctx, data->list);
// Free the data structured passed back and forth
// between the main thread and rendering thread.
free(data);
}
fprintf(stderr, "finally!\n");
fflush(NULL);
free(thread);
// Finally the document is closed and the main thread's
// context is freed.
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return 0;
}
static fz_pixmap *
fz_load_jxr_or_info(fz_context *ctx, unsigned char *data, int size, int *wp, int *hp, int *xresp, int *yresp, fz_colorspace **cspacep)
{
#ifdef _WIN32
int info_only = wp && hp && xresp && yresp && cspacep;
fz_pixmap *pix = NULL;
IStream *stream = NULL;
IWICImagingFactory *factory = NULL;
IWICBitmapDecoder *decoder = NULL;
IWICFormatConverter *converter = NULL;
IWICBitmapFrameDecode *src_frame = NULL;
IWICBitmapSource *src_bitmap = NULL;
int codec_available = 0;
LARGE_INTEGER zero = { 0 };
UINT width, height;
double xres, yres;
ULONG written;
HRESULT hr;
hr = CoInitialize(NULL);
if (FAILED(hr))
fz_throw(ctx, "JPEG-XR codec is not available");
#define Check(hr) if (FAILED(hr)) goto CleanUp
Check(CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_ALL, &IID_IWICImagingFactory, (void **)&factory));
Check(CreateStreamOnHGlobal(NULL, TRUE, &stream));
Check(IStream_Write(stream, data, (ULONG)size, &written));
Check(IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL));
Check(IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, WICDecodeMetadataCacheOnDemand, &decoder));
Check(IWICImagingFactory_CreateFormatConverter(factory, &converter));
Check(IWICBitmapDecoder_GetFrame(decoder, 0, &src_frame));
Check(IUnknown_QueryInterface(src_frame, &IID_IWICBitmapSource, &src_bitmap));
Check(IWICFormatConverter_Initialize(converter, src_bitmap, &GUID_WICPixelFormat32bppBGRA, WICBitmapDitherTypeNone, NULL, 0.f, WICBitmapPaletteTypeCustom));
Check(IWICFormatConverter_GetSize(converter, &width, &height));
Check(IWICFormatConverter_GetResolution(converter, &xres, &yres));
#undef Check
codec_available = 1;
if (info_only)
{
*cspacep = fz_device_bgr;
*wp = width;
*hp = height;
*xresp = (int)(xres + 0.5);
*yresp = (int)(yres + 0.5);
}
else
{
fz_try(ctx)
{
pix = fz_new_pixmap(ctx, fz_device_bgr, width, height);
}
fz_catch(ctx)
{
pix = NULL;
goto CleanUp;
}
hr = IWICFormatConverter_CopyPixels(converter, NULL, pix->w * pix->n, pix->w * pix->h * pix->n, pix->samples);
if (FAILED(hr))
{
fz_drop_pixmap(ctx, pix);
pix = NULL;
goto CleanUp;
}
pix->xres = (int)(xres + 0.5);
pix->yres = (int)(yres + 0.5);
}
CleanUp:
#define Release(unk) if (unk) IUnknown_Release(unk)
Release(src_bitmap);
Release(converter);
Release(src_frame);
Release(decoder);
Release(factory);
Release(stream);
#undef Release
CoUninitialize();
if (codec_available)
{
if (!pix && !info_only)
fz_throw(ctx, "JPEG-XR codec failed to decode the image");
return pix;
}
#endif
fz_throw(ctx, "JPEG-XR codec is not available");
return NULL;
}
HRESULT MuPDFDoc::UpdatePage(int pageNumber, unsigned char *bitmap, int x, int y, int width, int height, bool invert)
{
int index = FindPageInCache(pageNumber);
if (index < 0)
{
//TODO: get rid of this side effect!!!
HRESULT result = GotoPage(pageNumber);
if (FAILED(result))
{
return result;
}
return DrawPage(bitmap, x, y, width, height, invert);
}
fz_device *dev = nullptr;
fz_pixmap *pixmap = nullptr;
fz_var(dev);
fz_var(pixmap);
PageCache *pageCache = &m_pages[m_currentPage];
fz_try(m_context)
{
fz_interactive *idoc = fz_interact(m_document);
// Call fz_update_page now to ensure future calls yield the
// changes from the current state
if (idoc)
fz_update_page(idoc, pageCache->page);
if (!pageCache->pageList)
{
/* Render to list */
pageCache->pageList = fz_new_display_list(m_context);
dev = fz_new_list_device(m_context, pageCache->pageList);
fz_run_page_contents(m_document, pageCache->page, dev, fz_identity, nullptr);
}
if (!pageCache->annotList)
{
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
pageCache->annotList = fz_new_display_list(m_context);
dev = fz_new_list_device(m_context, pageCache->annotList);
for (fz_annot *annot = fz_first_annot(m_document, pageCache->page); annot; annot = fz_next_annot(m_document, annot))
fz_run_annot(m_document, pageCache->page, annot, dev, fz_identity, nullptr);
}
fz_bbox rect;
rect.x0 = x;
rect.y0 = y;
rect.x1 = x + width;
rect.y1 = y + height;
pixmap = fz_new_pixmap_with_bbox_and_data(m_context, fz_device_bgr, rect, bitmap);
//
fz_matrix ctm = CalcConvertMatrix();
fz_bbox bbox = fz_round_rect(fz_transform_rect(ctm, pageCache->mediaBox));
/* Now, adjust ctm so that it would give the correct page width
* heights. */
float xscale = (float)width/(float)(bbox.x1-bbox.x0);
float yscale = (float)height/(float)(bbox.y1-bbox.y0);
ctm = fz_concat(ctm, fz_scale(xscale, yscale));
bbox = fz_round_rect(fz_transform_rect(ctm, pageCache->mediaBox));
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
fz_annot *annot;
while (idoc && (annot = fz_poll_changed_annot(idoc, pageCache->page)))
{
fz_bbox abox = fz_round_rect(fz_transform_rect(ctm, fz_bound_annot(m_document, annot)));
abox = fz_intersect_bbox(abox, rect);
if (!fz_is_empty_bbox(abox))
{
fz_clear_pixmap_rect_with_value(m_context, pixmap, 0xff, abox);
dev = fz_new_draw_device_with_bbox(m_context, pixmap, abox);
if (pageCache->pageList)
fz_run_display_list(pageCache->pageList, dev, ctm, abox, nullptr);
if (pageCache->annotList)
fz_run_display_list(pageCache->annotList, dev, ctm, abox, nullptr);
fz_free_device(dev);
dev = nullptr;
if (invert)
fz_invert_pixmap_rect(pixmap, abox);
}
}
}
fz_always(m_context)
{
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
if (pixmap)
{
fz_drop_pixmap(m_context, pixmap);
}
}
fz_catch(m_context)
{
return E_FAIL;
}
return S_OK;
}
HRESULT MuPDFDoc::DrawPage(unsigned char *bitmap, int x, int y, int width, int height, bool invert)
{
m_cts->abort = 0;
fz_device *dev = nullptr;
fz_pixmap *pixmap = nullptr;
fz_var(dev);
fz_var(pixmap);
PageCache *pageCache = &m_pages[m_currentPage];
fz_try(m_context)
{
fz_interactive *idoc = fz_interact(m_document);
// Call fz_update_page now to ensure future calls yield the
// changes from the current state
if (idoc)
fz_update_page(idoc, pageCache->page);
if (!pageCache->pageList)
{
/* Render to list */
pageCache->pageList = fz_new_display_list(m_context);
dev = fz_new_list_device(m_context, pageCache->pageList);
fz_run_page_contents(m_document, pageCache->page, dev, fz_identity, *&m_cts);
}
if (!pageCache->annotList)
{
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
pageCache->annotList = fz_new_display_list(m_context);
dev = fz_new_list_device(m_context, pageCache->annotList);
for (fz_annot *annot = fz_first_annot(m_document, pageCache->page); annot; annot = fz_next_annot(m_document, annot))
fz_run_annot(m_document, pageCache->page, annot, dev, fz_identity, *&m_cts);
}
fz_bbox rect;
rect.x0 = x;
rect.y0 = y;
rect.x1 = x + width;
rect.y1 = y + height;
pixmap = fz_new_pixmap_with_bbox_and_data(m_context, fz_device_bgr, rect, bitmap);
if (!pageCache->pageList && !pageCache->annotList)
{
fz_clear_pixmap_with_value(m_context, pixmap, 0xd0);
break;
}
fz_clear_pixmap_with_value(m_context, pixmap, 0xff);
//
fz_matrix ctm = CalcConvertMatrix();
fz_bbox bbox = fz_round_rect(fz_transform_rect(ctm, pageCache->mediaBox));
/* Now, adjust ctm so that it would give the correct page width
* heights. */
float xscale = (float)width/(float)(bbox.x1-bbox.x0);
float yscale = (float)height/(float)(bbox.y1-bbox.y0);
ctm = fz_concat(ctm, fz_scale(xscale, yscale));
bbox = fz_round_rect(fz_transform_rect(ctm, pageCache->mediaBox));
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
dev = fz_new_draw_device(m_context, pixmap);
if (pageCache->pageList)
fz_run_display_list(pageCache->pageList, dev, ctm, bbox, *&m_cts);
about = m_cts->abort;
if (pageCache->annotList)
fz_run_display_list(pageCache->annotList, dev, ctm, bbox, *&m_cts);
if (invert)
fz_invert_pixmap(m_context, pixmap);
}
fz_always(m_context)
{
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
if (pixmap)
{
fz_drop_pixmap(m_context, pixmap);
}
}
fz_catch(m_context)
{
return E_FAIL;
}
return S_OK;
}
HRESULT MuPDFDoc::Renderer(Data *data, int part, int numParts)
{
if (m_cts->abort == 1) return S_OK;
int pagenumber = data->pagenumber;
fz_context *ctx = data->ctx;
fz_display_list *list = data->list;
fz_display_list *annotList = data->annotList;
fz_rect rect = data->rect;
fz_pixmap *pix = data->pix;
fz_device *dev = nullptr;
int width = data->width;
int height = data->height / numParts;
// The context pointer is pointing to the main thread's
// context, so here we create a new context based on it for
// use in this thread.
ctx = fz_clone_context(ctx);
fz_try(ctx)
{
if (part == 1 && numParts == 2)
{
rect.y1 = rect.y1/2;
}
if (part == 2 && numParts == 2)
{
rect.y0 = rect.y1/2;
}
fz_matrix ctm = CalcConvertMatrix();
fz_bbox bbox = fz_round_rect(fz_transform_rect(ctm, rect));
/* Now, adjust ctm so that it would give the correct page width
* heights. */
float xscale = (float)width/(float)(bbox.x1-bbox.x0);
float yscale = (float)height/(float)(bbox.y1-bbox.y0);
ctm = fz_concat(ctm, fz_scale(xscale, yscale));
bbox = fz_round_rect(fz_transform_rect(ctm, rect));
dev = fz_new_draw_device(ctx, pix);
if (list)
fz_run_display_list(list, dev, ctm, bbox, *&m_cts);
if (m_cts->abort == 1) break;
if (annotList)
fz_run_display_list(annotList, dev, ctm, bbox, *&m_cts);
}
fz_always(ctx)
{
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
if (pix)
{
fz_drop_pixmap(m_context, pix);
}
}
fz_catch(ctx)
{
return E_FAIL;
}
fz_free_context(ctx);
return S_OK;
}
fz_pixmap *
fz_load_jpx(fz_context *ctx, unsigned char *data, int size, fz_colorspace *defcs, int indexed)
{
fz_pixmap *img;
fz_colorspace *origcs;
opj_dparameters_t params;
opj_codec_t *codec;
opj_image_t *jpx;
opj_stream_t *stream;
fz_colorspace *colorspace;
unsigned char *p;
OPJ_CODEC_FORMAT format;
int a, n, w, h, depth, sgnd;
int x, y, k, v;
stream_block sb;
if (size < 2)
fz_throw(ctx, FZ_ERROR_GENERIC, "not enough data to determine image format");
/* Check for SOC marker -- if found we have a bare J2K stream */
if (data[0] == 0xFF && data[1] == 0x4F)
format = OPJ_CODEC_J2K;
else
format = OPJ_CODEC_JP2;
opj_set_default_decoder_parameters(¶ms);
if (indexed)
params.flags |= OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
codec = opj_create_decompress(format);
opj_set_info_handler(codec, fz_opj_info_callback, ctx);
opj_set_warning_handler(codec, fz_opj_warning_callback, ctx);
opj_set_error_handler(codec, fz_opj_error_callback, ctx);
if (!opj_setup_decoder(codec, ¶ms))
{
fz_throw(ctx, FZ_ERROR_GENERIC, "j2k decode failed");
}
stream = opj_stream_default_create(OPJ_TRUE);
sb.data = data;
sb.pos = 0;
sb.size = size;
opj_stream_set_read_function(stream, fz_opj_stream_read);
opj_stream_set_skip_function(stream, fz_opj_stream_skip);
opj_stream_set_seek_function(stream, fz_opj_stream_seek);
opj_stream_set_user_data(stream, &sb);
/* Set the length to avoid an assert */
opj_stream_set_user_data_length(stream, size);
if (!opj_read_header(stream, codec, &jpx))
{
opj_stream_destroy(stream);
opj_destroy_codec(codec);
fz_throw(ctx, FZ_ERROR_GENERIC, "Failed to read JPX header");
}
if (!opj_decode(codec, stream, jpx))
{
opj_stream_destroy(stream);
opj_destroy_codec(codec);
opj_image_destroy(jpx);
fz_throw(ctx, FZ_ERROR_GENERIC, "Failed to decode JPX image");
}
opj_stream_destroy(stream);
opj_destroy_codec(codec);
/* jpx should never be NULL here, but check anyway */
if (!jpx)
fz_throw(ctx, FZ_ERROR_GENERIC, "opj_decode failed");
for (k = 1; k < (int)jpx->numcomps; k++)
{
if (!jpx->comps[k].data)
{
opj_image_destroy(jpx);
fz_throw(ctx, FZ_ERROR_GENERIC, "image components are missing data");
}
if (jpx->comps[k].w != jpx->comps[0].w)
{
opj_image_destroy(jpx);
fz_throw(ctx, FZ_ERROR_GENERIC, "image components have different width");
}
if (jpx->comps[k].h != jpx->comps[0].h)
{
opj_image_destroy(jpx);
fz_throw(ctx, FZ_ERROR_GENERIC, "image components have different height");
}
if (jpx->comps[k].prec != jpx->comps[0].prec)
{
opj_image_destroy(jpx);
fz_throw(ctx, FZ_ERROR_GENERIC, "image components have different precision");
}
}
n = jpx->numcomps;
w = jpx->comps[0].w;
h = jpx->comps[0].h;
depth = jpx->comps[0].prec;
sgnd = jpx->comps[0].sgnd;
if (jpx->color_space == OPJ_CLRSPC_SRGB && n == 4) { n = 3; a = 1; }
else if (jpx->color_space == OPJ_CLRSPC_SYCC && n == 4) { n = 3; a = 1; }
else if (n == 2) { n = 1; a = 1; }
else if (n > 4) { n = 4; a = 1; }
else { a = 0; }
origcs = defcs;
if (defcs)
{
if (defcs->n == n)
{
colorspace = defcs;
}
else
{
fz_warn(ctx, "jpx file and dict colorspaces do not match");
defcs = NULL;
}
}
if (!defcs)
{
switch (n)
{
case 1: colorspace = fz_device_gray(ctx); break;
case 3: colorspace = fz_device_rgb(ctx); break;
case 4: colorspace = fz_device_cmyk(ctx); break;
}
}
fz_try(ctx)
{
img = fz_new_pixmap(ctx, colorspace, w, h);
}
fz_catch(ctx)
{
opj_image_destroy(jpx);
fz_rethrow_message(ctx, "out of memory loading jpx");
}
p = img->samples;
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
for (k = 0; k < n + a; k++)
{
v = jpx->comps[k].data[y * w + x];
if (sgnd)
v = v + (1 << (depth - 1));
if (depth > 8)
v = v >> (depth - 8);
*p++ = v;
}
if (!a)
*p++ = 255;
}
}
opj_image_destroy(jpx);
if (a)
{
if (n == 4)
{
fz_pixmap *tmp = fz_new_pixmap(ctx, fz_device_rgb(ctx), w, h);
fz_convert_pixmap(ctx, tmp, img);
fz_drop_pixmap(ctx, img);
img = tmp;
}
fz_premultiply_pixmap(ctx, img);
}
if (origcs != defcs)
{
fz_pixmap *tmp = fz_new_pixmap(ctx, origcs, w, h);
fz_convert_pixmap(ctx, tmp, img);
fz_drop_pixmap(ctx, img);
img = tmp;
}
return img;
}
int main(int argc, char **argv)
{
char *input;
float zoom, rotate;
int page_number, page_count;
fz_context *ctx;
fz_document *doc;
fz_pixmap *pix;
fz_matrix ctm;
int x, y;
if (argc < 3)
{
fprintf(stderr, "usage: example input-file page-number [ zoom [ rotate ] ]\n");
fprintf(stderr, "\tinput-file: path of PDF, XPS, CBZ or EPUB document to open\n");
fprintf(stderr, "\tPage numbering starts from one.\n");
fprintf(stderr, "\tZoom level is in percent (100 percent is 72 dpi).\n");
fprintf(stderr, "\tRotation is in degrees clockwise.\n");
return EXIT_FAILURE;
}
input = argv[1];
page_number = atoi(argv[2]) - 1;
zoom = argc > 3 ? atof(argv[3]) : 100;
rotate = argc > 4 ? atof(argv[4]) : 0;
/* Create a context to hold the exception stack and various caches. */
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "cannot create mupdf context\n");
return EXIT_FAILURE;
}
/* Register the default file types to handle. */
fz_try(ctx)
fz_register_document_handlers(ctx);
fz_catch(ctx)
{
fprintf(stderr, "cannot register document handlers: %s\n", fz_caught_message(ctx));
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Open the document. */
fz_try(ctx)
doc = fz_open_document(ctx, input);
fz_catch(ctx)
{
fprintf(stderr, "cannot open document: %s\n", fz_caught_message(ctx));
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Count the number of pages. */
fz_try(ctx)
page_count = fz_count_pages(ctx, doc);
fz_catch(ctx)
{
fprintf(stderr, "cannot count number of pages: %s\n", fz_caught_message(ctx));
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_FAILURE;
}
if (page_number < 0 || page_number >= page_count)
{
fprintf(stderr, "page number out of range: %d (page count %d)\n", page_number + 1, page_count);
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Compute a transformation matrix for the zoom and rotation desired. */
/* The default resolution without scaling is 72 dpi. */
fz_scale(&ctm, zoom / 100, zoom / 100);
fz_pre_rotate(&ctm, rotate);
/* Render page to an RGB pixmap. */
fz_try(ctx)
pix = fz_new_pixmap_from_page_number(ctx, doc, page_number, &ctm, fz_device_rgb(ctx), 0);
fz_catch(ctx)
{
fprintf(stderr, "cannot render page: %s\n", fz_caught_message(ctx));
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Print image data in ascii PPM format. */
printf("P3\n");
printf("%d %d\n", pix->w, pix->h);
printf("255\n");
for (y = 0; y < pix->h; ++y)
{
unsigned char *p = &pix->samples[y * pix->stride];
for (x = 0; x < pix->w; ++x)
{
if (x > 0)
printf(" ");
printf("%3d %3d %3d", p[0], p[1], p[2]);
p += pix->n;
}
printf("\n");
}
/* Clean up. */
fz_drop_pixmap(ctx, pix);
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_SUCCESS;
}
static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
{
fz_page *page;
fz_display_list *list = NULL;
fz_device *dev = NULL;
int start;
fz_cookie cookie = { 0 };
int needshot = 0;
fz_var(list);
fz_var(dev);
if (showtime)
{
start = gettime();
}
fz_try(ctx)
{
page = fz_load_page(doc, pagenum - 1);
}
fz_catch(ctx)
{
fz_throw(ctx, "cannot load page %d in file '%s'", pagenum, filename);
}
if (mujstest_file)
{
fz_interactive *inter = fz_interact(doc);
fz_widget *widget = NULL;
if (inter)
widget = fz_first_widget(inter, page);
if (widget)
{
fprintf(mujstest_file, "GOTO %d\n", pagenum);
needshot = 1;
}
for (;widget; widget = fz_next_widget(inter, widget))
{
fz_rect rect = *fz_widget_bbox(widget);
int w = (rect.x1-rect.x0);
int h = (rect.y1-rect.y0);
int len;
int type = fz_widget_get_type(widget);
++mujstest_count;
switch (type)
{
default:
fprintf(mujstest_file, "%% UNKNOWN %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_PUSHBUTTON:
fprintf(mujstest_file, "%% PUSHBUTTON %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_CHECKBOX:
fprintf(mujstest_file, "%% CHECKBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_RADIOBUTTON:
fprintf(mujstest_file, "%% RADIOBUTTON %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_TEXT:
{
int maxlen = fz_text_widget_max_len(inter, widget);
int texttype = fz_text_widget_content_type(inter, widget);
/* If height is low, assume a single row, and base
* the width off that. */
if (h < 10)
{
w = (w+h-1) / (h ? h : 1);
h = 1;
}
/* Otherwise, if width is low, work off height */
else if (w < 10)
{
h = (w+h-1) / (w ? w : 1);
w = 1;
}
else
{
w = (w+9)/10;
h = (h+9)/10;
}
len = w*h;
if (len < 2)
len = 2;
if (len > maxlen)
len = maxlen;
fprintf(mujstest_file, "%% TEXT %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
switch (texttype)
{
default:
case FZ_WIDGET_CONTENT_UNRESTRAINED:
fprintf(mujstest_file, "TEXT %d ", mujstest_count);
escape_string(mujstest_file, len-3, lorem);
fprintf(mujstest_file, "\n");
break;
case FZ_WIDGET_CONTENT_NUMBER:
fprintf(mujstest_file, "TEXT %d\n", mujstest_count);
break;
case FZ_WIDGET_CONTENT_SPECIAL:
fprintf(mujstest_file, "TEXT %lld\n", 46702919800LL + mujstest_count);
break;
case FZ_WIDGET_CONTENT_DATE:
fprintf(mujstest_file, "TEXT Jun %d 1979\n", 1 + ((13 + mujstest_count) % 30));
break;
case FZ_WIDGET_CONTENT_TIME:
++mujstest_count;
fprintf(mujstest_file, "TEXT %02d:%02d\n", ((mujstest_count/60) % 24), mujstest_count % 60);
break;
}
break;
}
case FZ_WIDGET_TYPE_LISTBOX:
fprintf(mujstest_file, "%% LISTBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_COMBOBOX:
fprintf(mujstest_file, "%% COMBOBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
}
fprintf(mujstest_file, "CLICK %0.2f %0.2f\n", (rect.x0+rect.x1)/2, (rect.y0+rect.y1)/2);
}
}
if (uselist)
{
fz_try(ctx)
{
list = fz_new_display_list(ctx);
dev = fz_new_list_device(ctx, list);
fz_run_page(doc, page, dev, fz_identity, &cookie);
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_throw(ctx, "cannot draw page %d in file '%s'", pagenum, filename);
}
}
if (showxml)
{
fz_try(ctx)
{
dev = fz_new_trace_device(ctx);
printf("<page number=\"%d\">\n", pagenum);
if (list)
fz_run_display_list(list, dev, fz_identity, fz_infinite_bbox, &cookie);
else
fz_run_page(doc, page, dev, fz_identity, &cookie);
printf("</page>\n");
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_rethrow(ctx);
}
}
if (showtext)
{
fz_text_page *text = NULL;
fz_var(text);
fz_try(ctx)
{
text = fz_new_text_page(ctx, fz_bound_page(doc, page));
dev = fz_new_text_device(ctx, sheet, text);
if (list)
fz_run_display_list(list, dev, fz_identity, fz_infinite_bbox, &cookie);
else
fz_run_page(doc, page, dev, fz_identity, &cookie);
fz_free_device(dev);
dev = NULL;
if (showtext == TEXT_XML)
{
fz_print_text_page_xml(ctx, stdout, text);
}
else if (showtext == TEXT_HTML)
{
fz_print_text_page_html(ctx, stdout, text);
}
else if (showtext == TEXT_PLAIN)
{
fz_print_text_page(ctx, stdout, text);
printf("\f\n");
}
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
fz_free_text_page(ctx, text);
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_rethrow(ctx);
}
}
if (showmd5 || showtime)
printf("page %s %d", filename, pagenum);
#ifdef GDI_PLUS_BMP_RENDERER
// hack: use -G0 to "enable GDI+" when saving as TGA
if (output && (strstr(output, ".bmp") || strstr(output, ".tga") && !gamma_value))
drawbmp(ctx, doc, page, list, pagenum);
else
#endif
if (output || showmd5 || showtime)
{
float zoom;
fz_matrix ctm;
fz_rect bounds, bounds2;
fz_bbox bbox;
fz_pixmap *pix = NULL;
int w, h;
fz_var(pix);
bounds = fz_bound_page(doc, page);
zoom = resolution / 72;
ctm = fz_scale(zoom, zoom);
ctm = fz_concat(ctm, fz_rotate(rotation));
bounds2 = fz_transform_rect(ctm, bounds);
bbox = fz_round_rect(bounds2);
/* Make local copies of our width/height */
w = width;
h = height;
/* If a resolution is specified, check to see whether w/h are
* exceeded; if not, unset them. */
if (res_specified)
{
int t;
t = bbox.x1 - bbox.x0;
if (w && t <= w)
w = 0;
t = bbox.y1 - bbox.y0;
if (h && t <= h)
h = 0;
}
/* Now w or h will be 0 unless then need to be enforced. */
if (w || h)
{
float scalex = w/(bounds2.x1-bounds2.x0);
float scaley = h/(bounds2.y1-bounds2.y0);
if (fit)
{
if (w == 0)
scalex = 1.0f;
if (h == 0)
scaley = 1.0f;
}
else
{
if (w == 0)
scalex = scaley;
if (h == 0)
scaley = scalex;
}
if (!fit)
{
if (scalex > scaley)
scalex = scaley;
else
scaley = scalex;
}
ctm = fz_concat(ctm, fz_scale(scalex, scaley));
bounds2 = fz_transform_rect(ctm, bounds);
}
bbox = fz_round_rect(bounds2);
/* TODO: banded rendering and multi-page ppm */
fz_try(ctx)
{
pix = fz_new_pixmap_with_bbox(ctx, colorspace, bbox);
if (savealpha)
fz_clear_pixmap(ctx, pix);
else
fz_clear_pixmap_with_value(ctx, pix, 255);
dev = fz_new_draw_device(ctx, pix);
if (list)
fz_run_display_list(list, dev, ctm, bbox, &cookie);
else
fz_run_page(doc, page, dev, ctm, &cookie);
fz_free_device(dev);
dev = NULL;
if (invert)
fz_invert_pixmap(ctx, pix);
if (gamma_value != 1)
fz_gamma_pixmap(ctx, pix, gamma_value);
if (savealpha)
fz_unmultiply_pixmap(ctx, pix);
if (output)
{
char buf[512];
sprintf(buf, output, pagenum);
if (strstr(output, ".pgm") || strstr(output, ".ppm") || strstr(output, ".pnm"))
fz_write_pnm(ctx, pix, buf);
else if (strstr(output, ".pam"))
fz_write_pam(ctx, pix, buf, savealpha);
else if (strstr(output, ".png"))
fz_write_png(ctx, pix, buf, savealpha);
else if (strstr(output, ".pbm")) {
fz_bitmap *bit = fz_halftone_pixmap(ctx, pix, NULL);
fz_write_pbm(ctx, bit, buf);
fz_drop_bitmap(ctx, bit);
}
/* SumatraPDF: support TGA as output format */
else if (strstr(output, ".tga"))
fz_write_tga(ctx, pix, buf, savealpha);
}
if (showmd5)
{
unsigned char digest[16];
int i;
fz_md5_pixmap(pix, digest);
printf(" ");
for (i = 0; i < 16; i++)
printf("%02x", digest[i]);
}
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
fz_drop_pixmap(ctx, pix);
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_rethrow(ctx);
}
}
static void drawbmp(fz_context *ctx, fz_document *doc, fz_page *page, fz_display_list *list, int pagenum)
{
float zoom;
fz_matrix ctm;
fz_bbox bbox;
fz_rect bounds, bounds2;
int w, h;
fz_device *dev;
HDC dc, dc_main;
RECT rc;
HBRUSH bg_brush;
HBITMAP hbmp;
BITMAPINFO bmi = { 0 };
int bmp_data_len;
char *bmp_data;
bounds = fz_bound_page(doc, page);
zoom = resolution / 72;
ctm = fz_scale(zoom, zoom);
ctm = fz_concat(ctm, fz_rotate(rotation));
bounds2 = fz_transform_rect(ctm, bounds);
w = width;
h = height;
if (res_specified)
{
bbox = fz_round_rect(bounds2);
if (w && bbox.x1 - bbox.x0 <= w)
w = 0;
if (h && bbox.y1 - bbox.y0 <= h)
h = 0;
}
if (w || h)
{
float scalex = w / (bounds2.x1 - bounds2.x0);
float scaley = h / (bounds2.y1 - bounds2.y0);
if (w == 0)
scalex = fit ? 1.0f : scaley;
if (h == 0)
scaley = fit ? 1.0f : scalex;
if (!fit)
scalex = scaley = min(scalex, scaley);
ctm = fz_concat(ctm, fz_scale(scalex, scaley));
bounds2 = fz_transform_rect(ctm, bounds);
}
bbox = fz_round_rect(bounds2);
w = bbox.x1 - bbox.x0;
h = bbox.y1 - bbox.y0;
dc_main = GetDC(NULL);
dc = CreateCompatibleDC(dc_main);
hbmp = CreateCompatibleBitmap(dc_main, w, h);
DeleteObject(SelectObject(dc, hbmp));
SetRect(&rc, 0, 0, w, h);
bg_brush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF));
FillRect(dc, &rc, bg_brush);
DeleteObject(bg_brush);
dev = fz_new_gdiplus_device(ctx, dc, bbox);
if (list)
fz_run_display_list(list, dev, ctm, bbox, NULL);
else
fz_run_page(doc, page, dev, ctm, NULL);
fz_free_device(dev);
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 24;
bmi.bmiHeader.biCompression = BI_RGB;
bmp_data_len = ((w * 3 + 3) / 4) * 4 * h;
bmp_data = fz_malloc(ctx, bmp_data_len + 1);
if (!GetDIBits(dc, hbmp, 0, h, bmp_data, &bmi, DIB_RGB_COLORS))
fz_throw(ctx, "cannot draw page %d in PDF file '%s'", pagenum, filename);
DeleteDC(dc);
ReleaseDC(NULL, dc_main);
DeleteObject(hbmp);
if (output)
{
char buf[512];
FILE *f;
sprintf(buf, output, pagenum);
f = fopen(buf, "wb");
if (!f)
fz_throw(ctx, "could not create raster file '%s'", buf);
if (strstr(output, ".bmp"))
{
BITMAPFILEHEADER bmpfh = { 0 };
static const int one = 1;
if (!*(char *)&one)
fz_throw(ctx, "rendering to BMP is not supported on big-endian architectures");
bmpfh.bfType = MAKEWORD('B', 'M');
bmpfh.bfOffBits = sizeof(bmpfh) + sizeof(bmi);
bmpfh.bfSize = bmpfh.bfOffBits + bmp_data_len;
fwrite(&bmpfh, sizeof(bmpfh), 1, f);
fwrite(&bmi, sizeof(bmi), 1, f);
fwrite(bmp_data, 1, bmp_data_len, f);
}
else
{
unsigned short width = w, height = h, k;
fwrite("\0\0\x0A\0\0\0\0\0\0\0\0\0", 1, 12, f);
putc(width & 0xFF, f); putc((width >> 8) & 0xFF, f);
putc(height & 0xFF, f); putc((height >> 8) & 0xFF, f);
fwrite("\x18\0", 1, 2, f);
for (k = 0; k < height; k++)
{
int i, j;
char *line = bmp_data + bmp_data_len / h * k;
for (i = 0, j = 1; i < width; i += j, j = 1)
{
#define memeq3(a, b) (*(WORD *)(a) == *(WORD *)(b) && (a)[2] == (b)[2])
for (; i + j < width && j < 128 && memeq3(line + i * 3, line + (i + j) * 3); j++);
if (j > 1)
{
putc(j - 1 + 128, f);
fwrite(line + i * 3, 1, 3, f);
}
else
{
for (; i + j < width && j < 128 && !memeq3(line + (i + j - 1) * 3, line + (i + j) * 3) != 0; j++);
putc(j - 1, f);
fwrite(line + i * 3, 1, j * 3, f);
}
#undef memeq3
}
}
fwrite("\0\0\0\0\0\0\0\0TRUEVISION-XFILE.\0", 1, 26, f);
}
fclose(f);
}
if (showmd5)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_rgb, bmp_data_len / 4 / h, h, bmp_data);
unsigned char digest[16];
int i;
fz_md5_pixmap(pix, digest);
printf(" ");
for (i = 0; i < 16; i++)
printf("%02x", digest[i]);
fz_drop_pixmap(ctx, pix);
}
fz_free(ctx, bmp_data);
}
