Model::DjVuDocument::DjVuDocument(ddjvu_context_t* context, ddjvu_document_t* document) :
m_mutex(),
m_context(context),
m_document(document),
m_format(0),
m_indexByName()
{
unsigned int mask[] = {0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000};
m_format = ddjvu_format_create(DDJVU_FORMAT_RGBMASK32, 4, mask);
ddjvu_format_set_row_order(m_format, 1);
ddjvu_format_set_y_direction(m_format, 1);
const int fileNum = ddjvu_document_get_filenum(m_document);
for(int index = 0; index < fileNum; ++index)
{
ddjvu_fileinfo_t fileinfo;
if(ddjvu_document_get_fileinfo(m_document, index, &fileinfo) != DDJVU_JOB_OK || fileinfo.type != 'P')
{
continue;
}
m_indexByName[QString::fromUtf8(fileinfo.id)] = m_indexByName[QString::fromUtf8(fileinfo.name)] = m_indexByName[QString::fromUtf8(fileinfo.title)] = fileinfo.pageno;
}
}
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;
}
static int openDocument(lua_State *L) {
const char *filename = luaL_checkstring(L, 1);
int cache_size = luaL_optint(L, 2, 10 << 20);
DjvuDocument *doc = (DjvuDocument*) lua_newuserdata(L, sizeof(DjvuDocument));
luaL_getmetatable(L, "djvudocument");
lua_setmetatable(L, -2);
doc->context = ddjvu_context_create("kindlepdfviewer");
if (! doc->context) {
return luaL_error(L, "cannot create context");
}
//printf("## cache_size = %d\n", cache_size);
ddjvu_cache_set_size(doc->context, (unsigned long)cache_size);
doc->doc_ref = ddjvu_document_create_by_filename_utf8(doc->context, filename, TRUE);
if (! doc->doc_ref)
return luaL_error(L, "cannot open DjVu file <%s>", filename);
while (! ddjvu_document_decoding_done(doc->doc_ref))
handle(L, doc->context, True);
doc->pixelformat = ddjvu_format_create(DDJVU_FORMAT_GREY8, 0, NULL);
if (! doc->pixelformat) {
return luaL_error(L, "cannot create DjVu pixelformat for <%s>", filename);
}
ddjvu_format_set_row_order(doc->pixelformat, 1);
ddjvu_format_set_y_direction(doc->pixelformat, 1);
/* dithering bits <8 are ignored by djvulibre */
/* ddjvu_format_set_ditherbits(doc->pixelformat, 4); */
return 1;
}
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;
}
DjVuDocument::DjVuDocument(QMutex* globalMutex, ddjvu_context_t* context, ddjvu_document_t* document) :
m_mutex(),
m_globalMutex(globalMutex),
m_context(context),
m_document(document),
m_format(0),
m_indexByName()
{
unsigned int mask[] = {0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000};
m_format = ddjvu_format_create(DDJVU_FORMAT_RGBMASK32, 4, mask);
ddjvu_format_set_row_order(m_format, 1);
ddjvu_format_set_y_direction(m_format, 1);
prepareIndexByName();
}
/*
* 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 {
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;
}
