extern "C" jboolean Java_org_ebookdroid_droids_djvu_codec_DjvuPage_renderPage(JNIEnv *env, jclass cls, jlong pageHangle,
jint targetWidth, jint targetHeight,
jfloat pageSliceX, jfloat pageSliceY,
jfloat pageSliceWidth,
jfloat pageSliceHeight, jintArray buffer,
jint rendermode)
{
DEBUG_WRITE("Rendering page");
ddjvu_page_t* page = (ddjvu_page_t*) ((pageHangle));
ddjvu_rect_t pageRect;
pageRect.x = 0;
pageRect.y = 0;
pageRect.w = targetWidth / pageSliceWidth;
pageRect.h = targetHeight / pageSliceHeight;
ddjvu_rect_t targetRect;
targetRect.x = pageSliceX * targetWidth / pageSliceWidth;
targetRect.y = pageSliceY * targetHeight / pageSliceHeight;
targetRect.w = targetWidth;
targetRect.h = targetHeight;
unsigned int masks[] = { 0xFF0000, 0x00FF00, 0x0000FF };
ddjvu_format_t* pixelFormat = ddjvu_format_create(DDJVU_FORMAT_RGBMASK32, 3, masks);
ddjvu_format_set_row_order(pixelFormat, TRUE);
ddjvu_format_set_y_direction(pixelFormat, TRUE);
char *pBuffer = (char *) env->GetPrimitiveArrayCritical(buffer, 0);
jboolean result = ddjvu_page_render(page, (ddjvu_render_mode_t) rendermode, &pageRect, &targetRect, pixelFormat,
targetWidth * 4, pBuffer);
env->ReleasePrimitiveArrayCritical(buffer, pBuffer, 0);
ddjvu_format_release(pixelFormat);
return result;
}
zathura_error_t
djvu_page_render_cairo(zathura_page_t* page, void* UNUSED(data), cairo_t* cairo,
bool GIRARA_UNUSED(printing))
{
if (page == NULL || cairo == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
zathura_document_t* document = zathura_page_get_document(page);
if (document == NULL) {
return ZATHURA_ERROR_UNKNOWN;
}
/* init ddjvu render data */
djvu_document_t* djvu_document = zathura_document_get_data(document);
ddjvu_page_t* djvu_page = ddjvu_page_create_by_pageno(djvu_document->document, zathura_page_get_index(page));
if (djvu_page == NULL) {
return ZATHURA_ERROR_UNKNOWN;
}
while (!ddjvu_page_decoding_done(djvu_page)) {
handle_messages(djvu_document, true);
}
cairo_surface_t* surface = cairo_get_target(cairo);
if (surface == NULL ||
cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS ||
cairo_surface_get_type(surface) != CAIRO_SURFACE_TYPE_IMAGE) {
ddjvu_page_release(djvu_page);
return ZATHURA_ERROR_UNKNOWN;
}
unsigned int page_width = cairo_image_surface_get_width(surface);
unsigned int page_height = cairo_image_surface_get_height(surface);;
ddjvu_rect_t rrect = { 0, 0, page_width, page_height };
ddjvu_rect_t prect = { 0, 0, page_width, page_height };
char* surface_data = (char*) cairo_image_surface_get_data(surface);
if (surface_data == NULL) {
ddjvu_page_release(djvu_page);
return ZATHURA_ERROR_UNKNOWN;
}
/* render page */
ddjvu_page_render(djvu_page, DDJVU_RENDER_COLOR, &prect, &rrect,
djvu_document->format, cairo_image_surface_get_stride(surface), surface_data);
ddjvu_page_release(djvu_page);
return ZATHURA_ERROR_OK;
}
extern "C" jboolean Java_org_ebookdroid_droids_djvu_codec_DjvuPage_renderPageDirect(JNIEnv *env, jclass cls,
jlong pageHangle, jlong contextHandle, jint targetWidth,
jint targetHeight, jfloat pageSliceX,
jfloat pageSliceY,
jfloat pageSliceWidth,
jfloat pageSliceHeight,
jobject byteBuffer, jint rendermode)
{
DEBUG("Rendering page bitmap");
void *pixels;
int ret;
pixels = env->GetDirectBufferAddress(byteBuffer);
if (!pixels) {
ERROR("GetDirectBufferAddress failed!");
return JNI_FALSE;
}
ddjvu_page_t* page = (ddjvu_page_t*) ((pageHangle));
ddjvu_rect_t pageRect;
pageRect.x = 0;
pageRect.y = 0;
pageRect.w = targetWidth / pageSliceWidth;
pageRect.h = targetHeight / pageSliceHeight;
ddjvu_rect_t targetRect;
targetRect.x = pageSliceX * targetWidth / pageSliceWidth;
targetRect.y = pageSliceY * targetHeight / pageSliceHeight;
targetRect.w = targetWidth;
targetRect.h = targetHeight;
unsigned int masks[] = {0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000};
ddjvu_format_t* pixelFormat = ddjvu_format_create(DDJVU_FORMAT_RGBMASK32, 4, masks);
ddjvu_format_set_row_order(pixelFormat, TRUE);
ddjvu_format_set_y_direction(pixelFormat, TRUE);
while (!ddjvu_page_decoding_done(page))
{
waitAndHandleMessages(env, contextHandle);
}
jboolean result = ddjvu_page_render(page, (ddjvu_render_mode_t) rendermode, &pageRect, &targetRect, pixelFormat,
targetWidth * 4, (char*) pixels);
ddjvu_format_release(pixelFormat);
return result;
}
static int getPagePix(lua_State *L) {
DjvuPage *page = (DjvuPage*) luaL_checkudata(L, 1, "djvupage");
KOPTContext *kctx = (KOPTContext*) lua_topointer(L, 2);
ddjvu_rect_t prect;
ddjvu_rect_t rrect;
int px, py, pw, ph, rx, ry, rw, rh, status;
px = 0;
py = 0;
pw = ddjvu_page_get_width(page->page_ref);
ph = ddjvu_page_get_height(page->page_ref);
prect.x = px;
prect.y = py;
rx = (int)kctx->bbox.x0;
ry = (int)kctx->bbox.y0;
rw = (int)(kctx->bbox.x1 - kctx->bbox.x0);
rh = (int)(kctx->bbox.y1 - kctx->bbox.y0);
float scale = kctx->zoom;
prect.w = pw * scale;
prect.h = ph * scale;
rrect.x = rx * scale;
rrect.y = ry * scale;
rrect.w = rw * scale;
rrect.h = rh * scale;
printf("rendering page:%d,%d,%d,%d\n",rrect.x,rrect.y,rrect.w,rrect.h);
WILLUSBITMAP *dst = &kctx->src;
bmp_init(dst);
dst->width = rrect.w;
dst->height = rrect.h;
dst->bpp = 8;
bmp_alloc(dst);
if (dst->bpp == 8) {
int ii;
for (ii = 0; ii < 256; ii++)
dst->red[ii] = dst->blue[ii] = dst->green[ii] = ii;
}
ddjvu_format_set_row_order(page->doc->pixelformat, 1);
ddjvu_page_render(page->page_ref, 0, &prect, &rrect, page->doc->pixelformat,
bmp_bytewidth(dst), (char *) dst->data);
return 0;
}
QImage Model::DjVuPage::render(qreal horizontalResolution, qreal verticalResolution, Rotation rotation, const QRect& boundingRect) const
{
QMutexLocker mutexLocker(&m_parent->m_mutex);
ddjvu_status_t status;
ddjvu_page_t* page = ddjvu_page_create_by_pageno(m_parent->m_document, m_index);
if(page == 0)
{
return QImage();
}
while(true)
{
status = ddjvu_page_decoding_status(page);
if(status < DDJVU_JOB_OK)
{
clearMessageQueue(m_parent->m_context, true);
}
else
{
break;
}
}
if(status >= DDJVU_JOB_FAILED)
{
ddjvu_page_release(page);
return QImage();
}
switch(rotation)
{
default:
case RotateBy0:
ddjvu_page_set_rotation(page, DDJVU_ROTATE_0);
break;
case RotateBy90:
ddjvu_page_set_rotation(page, DDJVU_ROTATE_270);
break;
case RotateBy180:
ddjvu_page_set_rotation(page, DDJVU_ROTATE_180);
break;
case RotateBy270:
ddjvu_page_set_rotation(page, DDJVU_ROTATE_90);
break;
}
ddjvu_rect_t pagerect;
pagerect.x = 0;
pagerect.y = 0;
switch(rotation)
{
default:
case RotateBy0:
case RotateBy180:
pagerect.w = qRound(horizontalResolution / m_resolution * m_size.width());
pagerect.h = qRound(verticalResolution / m_resolution * m_size.height());
break;
case RotateBy90:
case RotateBy270:
pagerect.w = qRound(horizontalResolution / m_resolution * m_size.height());
pagerect.h = qRound(verticalResolution / m_resolution * m_size.width());
break;
}
ddjvu_rect_t renderrect;
if(boundingRect.isNull())
{
renderrect.x = pagerect.x;
renderrect.y = pagerect.y;
renderrect.w = pagerect.w;
renderrect.h = pagerect.h;
}
else
{
renderrect.x = boundingRect.x();
renderrect.y = boundingRect.y();
renderrect.w = boundingRect.width();
renderrect.h = boundingRect.height();
}
QImage image(renderrect.w, renderrect.h, QImage::Format_RGB32);
if(!ddjvu_page_render(page, DDJVU_RENDER_COLOR, &pagerect, &renderrect, m_parent->m_format, image.bytesPerLine(), reinterpret_cast< char* >(image.bits())))
{
image = QImage();
}
clearMessageQueue(m_parent->m_context, false);
ddjvu_page_release(page);
return image;
}
/*
* DjVu advertised readiness to provide bitmap: So get it!
* we use the RGB format!
*/
static void
get_page_image(LoadContext *lc, ddjvu_page_t *page, int x, int y, int w, int h, const ImageInfo *image_info ) {
ddjvu_format_t
*format;
ddjvu_page_type_t
type;
Image
*image;
int
ret,
stride;
unsigned char
*q;
ddjvu_rect_t rect;
rect.x = x;
rect.y = y;
rect.w = (unsigned int) w; /* /10 */
rect.h = (unsigned int) h; /* /10 */
image = lc->image;
type = ddjvu_page_get_type(lc->page);
/* stride of this temporary buffer: */
stride = (type == DDJVU_PAGETYPE_BITONAL)?
(image->columns + 7)/8 : image->columns *3;
q = (unsigned char *) AcquireQuantumMemory(image->rows,stride);
if (q == (unsigned char *) NULL)
return;
format = ddjvu_format_create(
(type == DDJVU_PAGETYPE_BITONAL)?DDJVU_FORMAT_LSBTOMSB : DDJVU_FORMAT_RGB24,
/* DDJVU_FORMAT_RGB24
* DDJVU_FORMAT_RGBMASK32*/
/* DDJVU_FORMAT_RGBMASK32 */
0, NULL);
#if 0
/* fixme: ThrowReaderException is a macro, which uses `exception' variable */
if (format == NULL)
{
abort();
/* ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); */
}
#endif
ddjvu_format_set_row_order(format, 1);
ddjvu_format_set_y_direction(format, 1);
ret = ddjvu_page_render(page,
DDJVU_RENDER_COLOR, /* ddjvu_render_mode_t */
&rect,
&rect, /* mmc: ?? */
format,
stride, /* ?? */
(char*)q);
(void) ret;
ddjvu_format_release(format);
if (type == DDJVU_PAGETYPE_BITONAL) {
/* */
#if DEBUG
printf("%s: expanding BITONAL page/image\n", __FUNCTION__);
#endif
register IndexPacket *indexes;
size_t bit, byte;
for (y=0; y < (ssize_t) image->rows; y++)
{
PixelPacket * o = QueueAuthenticPixels(image,0,y,image->columns,1,&image->exception);
if (o == (PixelPacket *) NULL)
break;
indexes=GetAuthenticIndexQueue(image);
bit=0;
byte=0;
/* fixme: the non-aligned, last =<7 bits ! that's ok!!!*/
for (x= 0; x < (ssize_t) image->columns; x++)
{
if (bit == 0) byte= (size_t) q[(y * stride) + (x / 8)];
if (indexes != (IndexPacket *) NULL)
SetPixelIndex(indexes+x,(IndexPacket) (((byte & 0x01) != 0) ? 0x00 : 0x01));
bit++;
if (bit == 8)
bit=0;
byte>>=1;
}
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
break;
}
if (!image->ping)
SyncImage(image);
} else {
gint32
load_djvu (const gchar * filename,
GimpRunMode runmode,
gboolean preview)
{
GimpPixelRgn rgn_in;
GimpDrawable *drawable;
gint32 volatile image_ID;
gint32 layer_ID;
int x1, y1, x2, y2, width, height;
unsigned char *src = NULL;
int file_length;
ctx = ddjvu_context_create("gimp");
//
doc = ddjvu_document_create_by_filename(ctx,filename, TRUE);
while (! ddjvu_document_decoding_done(doc))
handle(TRUE);
i = ddjvu_document_get_pagenum(doc);
dialog( &pageno ,i);
//processing the page
page = ddjvu_page_create_by_pageno(doc, pageno-1);
while (! ddjvu_page_decoding_done(page))
handle(TRUE);
if (ddjvu_page_decoding_error(page))
{
fprintf(stderr,"unexpected error ");
exit(10);
}
// ddjvu variables
ddjvu_rect_t prect;
ddjvu_rect_t rrect;
ddjvu_format_style_t style;
ddjvu_render_mode_t mode;
ddjvu_format_t *fmt;
int iw = ddjvu_page_get_width(page);
int ih = ddjvu_page_get_height(page);
int dpi = ddjvu_page_get_resolution(page);
ddjvu_page_type_t type = ddjvu_page_get_type(page);
char *image = 0;
int rowsize;
//end of ddjvu variables
style= DDJVU_FORMAT_RGB24;
mode=DDJVU_RENDER_COLOR;
fmt = ddjvu_format_create(style, 0, 0);
ddjvu_format_set_row_order(fmt, 1);
prect.w = iw;
prect.h = ih;
prect.x = 0;
prect.y = 0;
flag_scale=150;
prect.w = (unsigned int) (iw * flag_scale) / dpi;
prect.h = (unsigned int) (ih * flag_scale) / dpi;
rrect = prect;
rowsize = (rrect.w *3);
image = (char*)malloc(rowsize * rrect.h);
//generating page
ddjvu_page_render(page, mode, &prect, &rrect, fmt, rowsize, image);
ddjvu_page_release(page);
char *s =image;
/* create output image */
width = prect.w;
height = prect.h;
x1 = 0;
y1 = 0;
x2 = prect.w;
y2 = prect.h;
image_ID = gimp_image_new (width, height, GIMP_RGB);
layer_ID = gimp_layer_new (image_ID, _("Background"),
width, height, GIMP_RGB, 100, GIMP_NORMAL_MODE);
gimp_image_add_layer (image_ID, layer_ID, 0);
drawable = gimp_drawable_get (layer_ID); // initializes the drawable
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_pixel_rgn_init (&rgn_in, drawable, x1, y1,
x2 - x1, y2 - y1, TRUE, TRUE);
gimp_pixel_rgn_set_rect (&rgn_in, image, 0, 0, width, height);
//g_free (buf);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1);
gimp_image_set_filename (image_ID, filename);
return image_ID;
image =NULL;
//not handling any error
if (doc)
ddjvu_document_release(doc);
if (ctx)
ddjvu_context_release(ctx);
}
extern "C" jboolean Java_org_ebookdroid_droids_djvu_codec_DjvuPage_renderPageBitmap(JNIEnv *env, jclass cls,
jlong pageHangle, jint targetWidth,
jint targetHeight, jfloat pageSliceX,
jfloat pageSliceY,
jfloat pageSliceWidth,
jfloat pageSliceHeight,
jobject bitmap, jint rendermode)
{
//#ifdef USE_JNI_BITMAP_API
DEBUG_WRITE("Rendering page bitmap");
AndroidBitmapInfo info;
void *pixels;
int ret;
if ((ret = NativeBitmap_getInfo(env, bitmap, &info)) < 0)
{
DEBUG_PRINT("AndroidBitmap_getInfo() failed ! error=%d", ret);
return 0;
}
DEBUG_WRITE("Checking format");
// if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
// DEBUG_WRITE("Bitmap format is not RGBA_8888 !");
// return 0;
// }
if (info.format != ANDROID_BITMAP_FORMAT_RGB_565)
{
DEBUG_WRITE("Bitmap format is not RGB_565 !");
return 0;
}
DEBUG_WRITE("locking pixels");
if ((ret = NativeBitmap_lockPixels(env, bitmap, &pixels)) < 0)
{
DEBUG_PRINT("AndroidBitmap_lockPixels() failed ! error=%d", ret);
return 0;
}
ddjvu_page_t* page = (ddjvu_page_t*) ((pageHangle));
ddjvu_rect_t pageRect;
pageRect.x = 0;
pageRect.y = 0;
pageRect.w = targetWidth / pageSliceWidth;
pageRect.h = targetHeight / pageSliceHeight;
ddjvu_rect_t targetRect;
targetRect.x = pageSliceX * targetWidth / pageSliceWidth;
targetRect.y = pageSliceY * targetHeight / pageSliceHeight;
targetRect.w = targetWidth;
targetRect.h = targetHeight;
unsigned int masks[] = { 0xF800, 0x07E0, 0x001F };
ddjvu_format_t* pixelFormat = ddjvu_format_create(DDJVU_FORMAT_RGBMASK16, 3, masks);
// unsigned int masks[] = {0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000};
// ddjvu_format_t* pixelFormat = ddjvu_format_create(DDJVU_FORMAT_RGBMASK32, 4, masks);
ddjvu_format_set_row_order(pixelFormat, TRUE);
ddjvu_format_set_y_direction(pixelFormat, TRUE);
// jboolean result = ddjvu_page_render(page, DDJVU_RENDER_COLOR, &pageRect, &targetRect, pixelFormat, targetWidth * 4, (char*)pixels);
jboolean result = ddjvu_page_render(page, (ddjvu_render_mode_t) rendermode, &pageRect, &targetRect, pixelFormat,
targetWidth * 2, (char*) pixels);
ddjvu_format_release(pixelFormat);
NativeBitmap_unlockPixels(env, bitmap);
return result;
//#else
// DEBUG_WRITE("Rendering page bitmap not implemented");
// return 0;
//#endif
}
JNIEXPORT jboolean JNICALL
Java_universe_constellation_orion_viewer_djvu_DjvuDocument_drawPage(JNIEnv *env, jobject thiz, jobject bitmap,
float zoom,
int pageW, int pageH, int patchX, int patchY, int patchW, int patchH)
{
LOGI("==================Start Rendering==============");
int ret;
AndroidBitmapInfo info;
void *pixels;
int num_pixels = pageW * pageH;
LOGI("Rendering page=%dx%d patch=[%d,%d,%d,%d]",
pageW, pageH, patchX, patchY, patchW, patchH);
LOGI("page: %x", page);
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;
}
//float zoom = 0.0001f * zoom10000;
int pageWidth = ddjvu_page_get_width(page);
int pageHeight = ddjvu_page_get_height(page);
ddjvu_rect_t pageRect;
pageRect.x = 0;
pageRect.y = 0;
pageRect.w = round(zoom * pageWidth);
pageRect.h = round(zoom * pageHeight);
LOGI("Original page=%dx%d patch=[%d,%d,%d,%d]",
pageWidth, pageHeight, pageRect.x, pageRect.y, pageRect.w, pageRect.h);
ddjvu_rect_t targetRect;
targetRect.x = patchX;
targetRect.y = patchY;
targetRect.w = patchW;
targetRect.h = patchH;
int shift = 0;
if (targetRect.x < 0) {
shift = -targetRect.x;
targetRect.w += targetRect.x;
targetRect.x = 0;
}
if (targetRect.y < 0) {
shift += -targetRect.y * pageW;
targetRect.h += targetRect.y;
targetRect.y = 0;
}
if (pageRect.w < targetRect.x + targetRect.w) {
targetRect.w = targetRect.w - (targetRect.x + targetRect.w - pageRect.w);
}
if (pageRect.h < targetRect.y + targetRect.h) {
targetRect.h = targetRect.h - (targetRect.y + targetRect.h - pageRect.h);
}
memset(pixels, 255, num_pixels * 4);
LOGI("Rendering page=%dx%d patch=[%d,%d,%d,%d]",
patchW, patchH, targetRect.x, targetRect.y, targetRect.w, targetRect.h);
unsigned int masks[4] = { 0xff, 0xff00, 0xff0000, 0xff000000 };
ddjvu_format_t* pixelFormat = ddjvu_format_create(DDJVU_FORMAT_RGBMASK32, 4, masks);
LOGI("zoom=%f ", zoom);
ddjvu_format_set_row_order(pixelFormat, TRUE);
ddjvu_format_set_y_direction(pixelFormat, TRUE);
char * buffer = &(((unsigned char *)pixels)[shift*4]);
jboolean result = ddjvu_page_render(page, DDJVU_RENDER_COLOR, &pageRect, &targetRect, pixelFormat, pageW * 4, buffer);
ddjvu_format_release(pixelFormat);
orion_updateContrast((unsigned char *) pixels, num_pixels*4);
AndroidBitmap_unlockPixels(env, bitmap);
LOGI("...Rendered");
return 1;
}
/*
** Returns 0 for success, negative number for error code.
** bpp can be 24 or 8.
**
*/
int bmpdjvu_djvufile_to_bmp(WILLUSBITMAP *bmp,char *infile,int pageno,
int dpi,int bpp,FILE *out)
{
ddjvu_context_t *ctx;
ddjvu_document_t *doc;
ddjvu_page_t *page;
/* ddjvu_page_type_t type; */
ddjvu_rect_t prect;
ddjvu_rect_t rrect;
ddjvu_format_style_t style;
ddjvu_render_mode_t mode;
ddjvu_format_t *fmt;
int i,iw,ih,idpi,status;
ctx=ddjvu_context_create("bmpdjvu_djvufile_to_bmp");
if (ctx==NULL)
{
nprintf(out,"Cannot create djvu context.\n");
return(-1);
}
doc=ddjvu_document_create_by_filename(ctx,infile,1);
if (doc==NULL)
{
ddjvu_context_release(ctx);
nprintf(out,"Cannot create djvu document context from djvu file %s.\n",
infile);
return(-2);
}
i=ddjvu_document_get_pagenum(doc);
if (pageno<0 || pageno>i)
{
ddjvu_document_release(doc);
ddjvu_context_release(ctx);
nprintf(out,"Page number %d is out of range for djvu file %s.\n",pageno,infile);
return(-3);
}
page=ddjvu_page_create_by_pageno(doc,pageno-1);
if (page==NULL)
{
ddjvu_document_release(doc);
ddjvu_context_release(ctx);
nprintf(out,"Cannot parse page %d of djvu file %s.\n",pageno,infile);
return(-4);
}
while (!ddjvu_page_decoding_done(page))
handle(1,ctx);
if (ddjvu_page_decoding_error(page))
{
ddjvu_page_release(page);
ddjvu_document_release(doc);
ddjvu_context_release(ctx);
nprintf(out,"Error decoding page %d of djvu file %s.\n",pageno,infile);
return(-5);
}
/* type= */ ddjvu_page_get_type(page);
/*
printf("type=%d\n",type);
description=ddjvu_page_get_long_description(page);
printf("Description='%s'\n",description);
*/
iw = ddjvu_page_get_width(page);
ih = ddjvu_page_get_height(page);
idpi = ddjvu_page_get_resolution(page);
prect.x=prect.y=0;
bmp->width=prect.w=iw*dpi/idpi;
bmp->height=prect.h=ih*dpi/idpi;
bmp->bpp=(bpp==8) ? 8 : 24;
rrect=prect;
bmp_alloc(bmp);
if (bmp->bpp==8)
{
int ii;
for (ii=0;ii<256;ii++)
bmp->red[ii]=bmp->blue[ii]=bmp->green[ii]=ii;
}
mode=DDJVU_RENDER_COLOR;
style=bpp==8 ? DDJVU_FORMAT_GREY8 : DDJVU_FORMAT_RGB24;
fmt=ddjvu_format_create(style,0,0);
if (fmt==NULL)
{
ddjvu_page_release(page);
ddjvu_document_release(doc);
ddjvu_context_release(ctx);
nprintf(out,"Error setting DJVU format for djvu file %s (page %d).\n",infile,pageno);
return(-6);
}
ddjvu_format_set_row_order(fmt,1);
status=ddjvu_page_render(page,mode,&prect,&rrect,fmt,bmp_bytewidth(bmp),(char *)bmp->data);
ddjvu_format_release(fmt);
ddjvu_page_release(page);
ddjvu_document_release(doc);
ddjvu_context_release(ctx);
if (!status)
{
nprintf(out,"Error rendering page %d of djvu file %s.\n",pageno,infile);
return(-7);
}
return(0);
}
static int drawPage(lua_State *L) {
DjvuPage *page = (DjvuPage*) luaL_checkudata(L, 1, "djvupage");
DrawContext *dc = (DrawContext*) lua_topointer(L, 2);
BlitBuffer *bb = (BlitBuffer*) lua_topointer(L, 3);
ddjvu_render_mode_t djvu_render_mode = (int) luaL_checkint(L, 6);
unsigned char adjusted_low[16], adjusted_high[16];
int i, adjust_pixels = 0;
ddjvu_rect_t pagerect, renderrect;
int bbsize = (bb->w)*(bb->h)+1;
uint8_t *imagebuffer = malloc(bbsize);
/*printf("@page %d, @@zoom:%f, offset: (%d, %d)\n", page->num, dc->zoom, dc->offset_x, dc->offset_y);*/
/* render full page into rectangle specified by pagerect */
pagerect.x = 0;
pagerect.y = 0;
pagerect.w = page->info.width * dc->zoom;
pagerect.h = page->info.height * dc->zoom;
/*printf("--pagerect--- (x: %d, y: %d), w: %d, h: %d.\n", 0, 0, pagerect.w, pagerect.h);*/
/* copy pixels area from pagerect specified by renderrect.
*
* ddjvulibre library does not support negative offset, positive offset
* means moving towards right and down.
*
* However, djvureader.lua handles offset differently. It uses negative
* offset to move right and down while positive offset to move left
* and up. So we need to handle positive offset manually when copying
* imagebuffer to blitbuffer (framebuffer).
*/
renderrect.x = MAX(-dc->offset_x, 0);
renderrect.y = MAX(-dc->offset_y, 0);
renderrect.w = MIN(pagerect.w - renderrect.x, bb->w);
renderrect.h = MIN(pagerect.h - renderrect.y, bb->h);
/*printf("--renderrect--- (%d, %d), w:%d, h:%d\n", renderrect.x, renderrect.y, renderrect.w, renderrect.h);*/
/* ddjvulibre library only supports rotation of 0, 90, 180 and 270 degrees.
* These four kinds of rotations can already be achieved by native system.
* So we don't set rotation here.
*/
if (!ddjvu_page_render(page->page_ref, djvu_render_mode, &pagerect, &renderrect, page->doc->pixelformat, bb->w, imagebuffer))
memset(imagebuffer, 0xFF, bbsize);
uint8_t *bbptr = bb->data;
uint8_t *pmptr = imagebuffer;
int x, y;
/* if offset is positive, we are moving towards up and left. */
int x_offset = MAX(0, dc->offset_x);
int y_offset = MAX(0, dc->offset_y);
/* prepare the tables for adjusting the intensity of pixels */
if (dc->gamma != -1.0) {
for (i=0; i<16; i++) {
adjusted_low[i] = MIN(15, (unsigned char)floorf(dc->gamma * (float)i));
adjusted_high[i] = adjusted_low[i] << 4;
}
adjust_pixels = 1;
}
bbptr += bb->pitch * y_offset;
for(y = y_offset; y < bb->h; y++) {
/* bbptr's line width is half of pmptr's */
for(x = x_offset/2; x < (bb->w / 2); x++) {
int p = x*2 - x_offset;
unsigned char low = 15 - (pmptr[p + 1] >> 4);
unsigned char high = 15 - (pmptr[p] >> 4);
if (adjust_pixels)
bbptr[x] = adjusted_high[high] | adjusted_low[low];
else
bbptr[x] = (high << 4) | low;
}
if (bb->w & 1) {
bbptr[x] = 255 - (pmptr[x*2] & 0xF0);
}
/* go to next line */
bbptr += bb->pitch;
pmptr += bb->w;
}
free(imagebuffer);
return 0;
}
static int reflowPage(lua_State *L) {
DjvuPage *page = (DjvuPage*) luaL_checkudata(L, 1, "djvupage");
KOPTContext *kctx = (KOPTContext*) lua_topointer(L, 2);
ddjvu_render_mode_t mode = (int) luaL_checkint(L, 3);
ddjvu_rect_t prect;
ddjvu_rect_t rrect;
int px, py, pw, ph, rx, ry, rw, rh, status;
px = 0;
py = 0;
pw = ddjvu_page_get_width(page->page_ref);
ph = ddjvu_page_get_height(page->page_ref);
prect.x = px;
prect.y = py;
rx = (int)kctx->bbox.x0;
ry = (int)kctx->bbox.y0;
rw = (int)(kctx->bbox.x1 - kctx->bbox.x0);
rh = (int)(kctx->bbox.y1 - kctx->bbox.y0);
double zoom = kctx->zoom*kctx->quality;
float scale = ((2*zoom*kctx->dev_width) / (double)pw + \
(2*zoom*kctx->dev_height) / (double)ph) / 2;
prect.w = pw * scale;
prect.h = ph * scale;
rrect.x = rx * scale;
rrect.y = ry * scale;
rrect.w = rw * scale;
rrect.h = rh * scale;
printf("rendering page:%d,%d,%d,%d\n",rrect.x,rrect.y,rrect.w,rrect.h);
kctx->zoom = scale;
WILLUSBITMAP *src = &kctx->src;
bmp_init(src);
src->width = rrect.w;
src->height = rrect.h;
src->bpp = 8;
bmp_alloc(src);
if (src->bpp == 8) {
int ii;
for (ii = 0; ii < 256; ii++)
src->red[ii] = src->blue[ii] = src->green[ii] = ii;
}
ddjvu_format_set_row_order(page->doc->pixelformat, 1);
status = ddjvu_page_render(page->page_ref, mode, &prect, &rrect, page->doc->pixelformat,
bmp_bytewidth(src), (char *) src->data);
if (kctx->precache) {
pthread_t rf_thread;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&rf_thread, &attr, k2pdfopt_reflow_bmp, (void*) kctx);
pthread_attr_destroy(&attr);
} else {
k2pdfopt_reflow_bmp(kctx);
}
return 0;
}
zathura_image_buffer_t*
djvu_page_render(zathura_page_t* page, void* UNUSED(data), zathura_error_t* error)
{
if (page == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_INVALID_ARGUMENTS;
}
return NULL;
}
zathura_document_t* document = zathura_page_get_document(page);
if (document == NULL) {
return NULL;
}
/* calculate sizes */
unsigned int page_width = zathura_document_get_scale(document) * zathura_page_get_width(page);
unsigned int page_height = zathura_document_get_scale(document) * zathura_page_get_height(page);
if (page_width == 0 || page_height == 0) {
if (error != NULL) {
*error = ZATHURA_ERROR_UNKNOWN;
}
goto error_out;
}
/* init ddjvu render data */
djvu_document_t* djvu_document = zathura_document_get_data(document);
ddjvu_page_t* djvu_page = ddjvu_page_create_by_pageno(
djvu_document->document, zathura_page_get_index(page));
if (djvu_page == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_UNKNOWN;
}
goto error_out;
}
while (!ddjvu_page_decoding_done(djvu_page)) {
handle_messages(djvu_document, true);
}
ddjvu_rect_t rrect = { 0, 0, page_width, page_height };
ddjvu_rect_t prect = { 0, 0, page_width, page_height };
zathura_image_buffer_t* image_buffer =
zathura_image_buffer_create(page_width, page_height);
if (image_buffer == NULL) {
if (error != NULL) {
*error = ZATHURA_ERROR_OUT_OF_MEMORY;
}
goto error_free;
}
/* set rotation */
ddjvu_page_set_rotation(djvu_page, DDJVU_ROTATE_0);
/* render page */
ddjvu_page_render(djvu_page, DDJVU_RENDER_COLOR, &prect, &rrect,
djvu_document->format, 3 * page_width, (char*) image_buffer->data);
return image_buffer;
error_free:
ddjvu_page_release(djvu_page);
zathura_image_buffer_free(image_buffer);
error_out:
return NULL;
}
