fz_display_list *
fz_new_display_list_from_annot(fz_context *ctx, fz_annot *annot)
{
fz_display_list *list;
fz_rect bounds;
fz_device *dev;
list = fz_new_display_list(ctx, fz_bound_annot(ctx, annot, &bounds));
fz_try(ctx)
{
dev = fz_new_list_device(ctx, list);
fz_run_annot(ctx, annot, dev, &fz_identity, NULL);
fz_close_device(ctx, dev);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_rethrow(ctx);
}
return list;
}
fz_pixmap *
fz_new_pixmap_from_annot(fz_context *ctx, fz_page *page, fz_annot *annot, const fz_matrix *ctm, fz_colorspace *cs)
{
fz_rect rect;
fz_irect irect;
fz_pixmap *pix;
fz_device *dev;
fz_bound_annot(ctx, page, annot, &rect);
fz_transform_rect(&rect, ctm);
fz_round_rect(&irect, &rect);
pix = fz_new_pixmap_with_bbox(ctx, cs, &irect);
fz_clear_pixmap(ctx, pix);
fz_try(ctx)
{
dev = fz_new_draw_device(ctx, pix);
fz_run_annot(ctx, page, annot, dev, ctm, NULL);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_pixmap(ctx, pix);
fz_rethrow(ctx);
}
return pix;
}
fz_pixmap *
fz_new_pixmap_from_annot(fz_context *ctx, fz_annot *annot, const fz_matrix *ctm, fz_colorspace *cs, int alpha)
{
fz_rect rect;
fz_irect irect;
fz_pixmap *pix;
fz_device *dev;
fz_bound_annot(ctx, annot, &rect);
fz_transform_rect(&rect, ctm);
fz_round_rect(&irect, &rect);
pix = fz_new_pixmap_with_bbox(ctx, cs, &irect, alpha);
if (alpha)
fz_clear_pixmap(ctx, pix);
else
fz_clear_pixmap_with_value(ctx, pix, 0xFF);
fz_try(ctx)
{
dev = fz_new_draw_device(ctx, ctm, pix);
fz_run_annot(ctx, annot, dev, &fz_identity, NULL);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_pixmap(ctx, pix);
fz_rethrow(ctx);
}
return pix;
}
JNIEXPORT jboolean JNICALL
Java_com_artifex_mupdf_MuPDFCore_updatePageInternal(JNIEnv *env, jobject thiz, jobject bitmap, int page,
int pageW, int pageH, int patchX, int patchY, int patchW, int patchH)
{
AndroidBitmapInfo info;
void *pixels;
int ret;
fz_device *dev = NULL;
float zoom;
fz_matrix ctm;
fz_bbox bbox;
fz_pixmap *pix = NULL;
float xscale, yscale;
fz_bbox rect;
fz_interactive *idoc;
page_cache *pc = NULL;
int hq = (patchW < pageW || patchH < pageH);
int i;
for (i = 0; i < NUM_CACHE; i++)
{
if (pages[i].page != NULL && pages[i].number == page)
{
pc = &pages[i];
break;
}
}
if (pc == NULL || (hq && pc->hq_page == NULL))
{
Java_com_artifex_mupdf_MuPDFCore_gotoPageInternal(env, thiz, page);
return Java_com_artifex_mupdf_MuPDFCore_drawPage(env, thiz, bitmap, pageW, pageH, patchX, patchY, patchW, patchH);
}
idoc = fz_interact(doc);
fz_var(pix);
fz_var(dev);
LOGI("In native method\n");
if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
return 0;
}
LOGI("Checking format\n");
if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
LOGE("Bitmap format is not RGBA_8888 !");
return 0;
}
LOGI("locking pixels\n");
if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
return 0;
}
/* Call mupdf to render display list to screen */
LOGE("Rendering page(%d)=%dx%d patch=[%d,%d,%d,%d]",
pc->number, pageW, pageH, patchX, patchY, patchW, patchH);
fz_try(ctx)
{
fz_annot *annot;
// Unimportant which page object we use for rendering but we
// must use the correct one for calculating updates
fz_page *page = hq ? pc->hq_page : pc->page;
fz_update_page(idoc, page);
if (pc->page_list == NULL)
{
/* Render to list */
pc->page_list = fz_new_display_list(ctx);
dev = fz_new_list_device(ctx, pc->page_list);
fz_run_page_contents(doc, page, dev, fz_identity, NULL);
}
if (pc->annot_list == NULL) {
if (dev) {
fz_free_device(dev);
dev = NULL;
}
pc->annot_list = fz_new_display_list(ctx);
dev = fz_new_list_device(ctx, pc->annot_list);
for (annot = fz_first_annot(doc, page); annot; annot = fz_next_annot(doc, annot))
fz_run_annot(doc, page, annot, dev, fz_identity, NULL);
}
rect.x0 = patchX;
rect.y0 = patchY;
rect.x1 = patchX + patchW;
rect.y1 = patchY + patchH;
pix = fz_new_pixmap_with_bbox_and_data(ctx, colorspace, rect, pixels);
zoom = resolution / 72;
ctm = fz_scale(zoom, zoom);
bbox = fz_round_rect(fz_transform_rect(ctm, pc->media_box));
/* Now, adjust ctm so that it would give the correct page width
* heights. */
xscale = (float)pageW/(float)(bbox.x1-bbox.x0);
yscale = (float)pageH/(float)(bbox.y1-bbox.y0);
ctm = fz_concat(ctm, fz_scale(xscale, yscale));
bbox = fz_round_rect(fz_transform_rect(ctm, pc->media_box));
LOGI("Start polling for updates");
while ((annot = fz_poll_changed_annot(idoc, page)) != NULL)
{
fz_bbox abox = fz_round_rect(fz_transform_rect(ctm, fz_bound_annot(doc, annot)));
abox = fz_intersect_bbox(abox, rect);
LOGI("Update rectanglefor %s - (%d, %d, %d, %d)", widget_type_string(fz_widget_get_type((fz_widget*)annot)),
abox.x0, abox.y0, abox.x1, abox.y1);
if (!fz_is_empty_bbox(abox))
{
LOGI("And it isn't empty");
fz_clear_pixmap_rect_with_value(ctx, pix, 0xff, abox);
dev = fz_new_draw_device_with_bbox(ctx, pix, abox);
if (pc->page_list)
fz_run_display_list(pc->page_list, dev, ctm, abox, NULL);
if (pc->annot_list)
fz_run_display_list(pc->annot_list, dev, ctm, abox, NULL);
fz_free_device(dev);
dev = NULL;
}
}
LOGI("Done polling for updates");
LOGE("Rendered");
}
fz_catch(ctx)
{
fz_free_device(dev);
LOGE("Render failed");
}
fz_drop_pixmap(ctx, pix);
AndroidBitmap_unlockPixels(env, bitmap);
return 1;
}
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;
}
