int main(int argc, char **argv)
{
/* get filename */
char *filename = NULL;
if (argc != 2) {
printf("usage: %s filename.pdf\n", argv[0]);
return 1;
}
if (strcmp(argv[1], "--help") == 0) {
printf("usage: %s filename.pdf\n", argv[0]);
return 0;
}
filename = argv[1];
/* open document */
fz_context *context = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
fz_document *document = fz_open_document(context, filename);
/* print page count */
printf("page count: %d\n", fz_count_pages(document));
fz_close_document(document);
fz_free_context(context);
return 0;
}
Pdf::~Pdf()
{
if (doc)
fz_close_document(doc);
doc = 0;
--references;
if (references == 0) {
fz_free_context(ctx);
ctx = 0;
}
}
void DrPDFExtractor::Initialize()
{
if (m_ctx) {
fz_free_context(m_ctx);
}
m_ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (m_doc) {
fz_close_document(m_doc);
m_doc = NULL;
}
}
bool Pdf::open(const QString& path)
{
char* name = path.toLatin1().data();
fz_try(ctx) {
doc = fz_open_document(ctx, name);
}
fz_catch(ctx) {
fz_close_document(doc);
doc = 0;
return false;
}
return true;
}
static void close_doc(globals *glo)
{
int i;
fz_free(glo->ctx, glo->hit_bbox);
glo->hit_bbox = NULL;
for (i = 0; i < NUM_CACHE; i++)
drop_page_cache(glo, &glo->pages[i]);
fz_close_document(glo->doc);
glo->doc = NULL;
}
/* Destructor */
muctx::~muctx(void)
{
fz_free_outline(mu_ctx, mu_outline);
fz_close_document(mu_doc);
page_cache->Empty(mu_ctx);
fz_free_context(mu_ctx);
mu_ctx = NULL;
mu_doc = NULL;
mu_outline = NULL;
delete page_cache;
page_cache = NULL;
}
void muctx::CleanUp(void)
{
fz_free_outline(mu_ctx, mu_outline);
fz_close_document(mu_doc);
page_cache->Empty(mu_ctx);
fz_free_context(mu_ctx);
delete page_cache;
page_cache = NULL;
this->mu_ctx = NULL;
this->mu_doc = NULL;
this->mu_outline = NULL;
}
JNIEXPORT int JNICALL
Java_com_artifex_mupdf_MuPDFCore_openFile(JNIEnv * env, jobject thiz, jstring jfilename)
{
const char *filename;
int result = 0;
filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
if (filename == NULL)
{
LOGE("Failed to get filename");
return 0;
}
/* 128 MB store for low memory devices. Tweak as necessary. */
ctx = fz_new_context(NULL, NULL, 128 << 20);
if (!ctx)
{
LOGE("Failed to initialise context");
return 0;
}
doc = NULL;
fz_try(ctx)
{
colorspace = fz_device_rgb;
LOGE("Opening document...");
fz_try(ctx)
{
doc = fz_open_document(ctx, (char *)filename);
}
fz_catch(ctx)
{
fz_throw(ctx, "Cannot open document: '%s'\n", filename);
}
LOGE("Done!");
result = 1;
}
fz_catch(ctx)
{
LOGE("Failed: %s", ctx->error->message);
fz_close_document(doc);
doc = NULL;
fz_free_context(ctx);
ctx = NULL;
}
(*env)->ReleaseStringUTFChars(env, jfilename, filename);
return result;
}
JNIEXPORT void JNICALL
Java_com_artifex_mupdf_MuPDFCore_destroying(JNIEnv * env, jobject thiz)
{
int i;
fz_free(ctx, hit_bbox);
hit_bbox = NULL;
for (i = 0; i < NUM_CACHE; i++)
drop_page_cache(&pages[i]);
fz_close_document(doc);
doc = NULL;
}
static void
doc_gc_free( Document *doc ) {
VALUE rb_page;
printf("GC Free Document: %016" PRIxPTR "\n", (uintptr_t)doc );
for ( int pg=0; pg < fz_count_pages(doc->fz_document); pg++ ){
rb_page = doc->pages[pg];
if (rb_page){
page_free(rb_page);
}
}
fz_close_document(doc->fz_document);
free(doc->pages);
free(doc);
}
void ViewerWidget::load(const QByteArray &data)
{
scene->clear();
QList<QGraphicsItem *> items;
QPixmap pixmap;
if (pixmap.loadFromData(data)) {
items << new QGraphicsPixmapItem(pixmap);
}
else if (data.startsWith("%PDF")) {
fz_stream *stream = fz_open_memory(context, (unsigned char *)data.constData(), data.length());
fz_document *doc = fz_open_document_with_stream(context, ".pdf", stream);
fz_close(stream);
int pagecount = fz_count_pages(doc);
for (int i = 0; i < pagecount; i++) {
fz_page *page = fz_load_page(doc, i);
fz_rect bounds;
fz_bound_page(doc, page, &bounds);
fz_display_list *list = fz_new_display_list(context);
fz_device *dev = fz_new_list_device(context, list);
fz_run_page(doc, page, dev, &fz_identity, NULL);
fz_free_device(dev);
fz_free_page(doc, page);
PageItem *item = new PageItem(context, list, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0);
item->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
items << item;
}
fz_close_document(doc);
} else {
scene->setSceneRect(0, 0, 0, 0);
return;
}
int top = 0;
QPen outline(Qt::lightGray, 2, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin);
outline.setCosmetic(true);
foreach (QGraphicsItem *item, items) {
QGraphicsRectItem *rim = new QGraphicsRectItem(item->boundingRect());
item->setPos(0, top);
rim->setPos(0, top);
rim->setPen(outline);
rim->setBrush(Qt::NoBrush);
scene->addItem(rim);
scene->addItem(item);
top += item->boundingRect().height() + SPACING;
}
DrPDFExtractor::~DrPDFExtractor()
{
if (m_doc) {
fz_close_document(m_doc);
m_doc = NULL;
}
if (m_ctx != NULL) {
fz_free_context(m_ctx);
m_ctx = NULL;
}
if (m_filename) {
delete [] m_filename;
}
if (m_fontcache) {
delete m_fontcache;
m_fontcache = NULL;
}
m_isopen = false;
}
void Mpdf::deletePdf()
{
if (!doc)
{
return;
}
fz_close_document(doc);
doc = NULL;
if (!ctx)
{
return;
}
fz_free_context(ctx);
ctx = NULL;
system("ls *.png | egrep '^[0-9]' | xargs rm -rf");
}
MuPDFDoc::~MuPDFDoc()
{
CoTaskMemFree(m_cts);
if (m_outline)
{
fz_free_outline(m_context, m_outline);
m_outline = nullptr;
}
if (m_document)
{
ClearPages();
fz_close_document(m_document);
m_document = nullptr;
}
if (m_context)
{
fz_free_context(m_context);
m_context = nullptr;
}
}
int wmupdf_numpages(char *filename)
{
fz_context *ctx;
fz_document *doc;
int np;
doc=NULL;
ctx = fz_new_context(NULL,NULL,FZ_STORE_DEFAULT);
if (!ctx)
return(-1);
fz_try(ctx) { doc=fz_open_document(ctx,filename); }
fz_catch(ctx)
{
fz_free_context(ctx);
return(-2);
}
np=fz_count_pages(doc);
fz_close_document(doc);
fz_flush_warnings(ctx);
fz_free_context(ctx);
return(np);
}
int main(int argc, char **argv)
{
char *filename = argv[1];
pthread_t *thread = NULL;
fz_locks_context locks;
pthread_mutex_t mutex[FZ_LOCK_MAX];
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.
fz_context *ctx = fz_new_context(NULL, &locks, FZ_STORE_UNLIMITED);
// Open the PDF, XPS or CBZ document.
fz_document *doc = fz_open_document(ctx, filename);
// Retrieve the number of pages, which translates to the
// number of threads used for rendering pages.
int threads = fz_count_pages(doc);
fprintf(stderr, "spawning %d threads, one per page...\n", threads);
thread = malloc(threads * sizeof (pthread_t));
for (i = 0; i < threads; i++)
{
// Load the relevant page for each thread.
fz_page *page = fz_load_page(doc, i);
// Compute the bounding box for each page.
fz_rect rect = fz_bound_page(doc, page);
fz_bbox bbox = fz_round_rect(rect);
// Create a display list that will hold the drawing
// commands for the page.
fz_display_list *list = fz_new_display_list(ctx);
// Run the loaded page through a display list device
// to populate the page's display list.
fz_device *dev = fz_new_list_device(ctx, list);
fz_run_page(doc, page, dev, fz_identity, NULL);
fz_free_device(dev);
// The page is no longer needed, all drawing commands
// are now in the display list.
fz_free_page(doc, page);
// Create a white pixmap using the correct dimensions.
fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx,
fz_device_rgb, bbox);
fz_clear_pixmap_with_value(ctx, pix, 0xff);
// Populate the data structure to be sent to the
// rendering thread for this page.
struct data *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_write_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_free_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_close_document(doc);
fz_free_context(ctx);
return 0;
}
/*
** Returns 0 if got dimensions.
*/
int bmpmupdf_pdffile_width_and_height(char *filename,int pageno,double *width_in,double *height_in)
{
fz_context *ctx;
fz_document *doc;
fz_page *page;
fz_display_list *list;
fz_device *dev;
fz_rect bounds;
int np;
dev=NULL;
list=NULL;
page=NULL;
doc=NULL;
if (pageno<1)
return(-99);
ctx = fz_new_context(NULL,NULL,FZ_STORE_DEFAULT);
if (!ctx)
return(-1);
fz_try(ctx)
{
fz_register_document_handlers(ctx);
fz_set_aa_level(ctx,8);
/* Sumatra version of MuPDF v1.4 -- use locally installed fonts */
pdf_install_load_system_font_funcs(ctx);
fz_try(ctx) { doc=fz_open_document(ctx,filename); }
fz_catch(ctx)
{
fz_free_context(ctx);
return(-1);
}
np=fz_count_pages(doc);
if (pageno>np)
return(-99);
fz_try(ctx) { page = fz_load_page(doc,pageno-1); }
fz_catch(ctx)
{
fz_close_document(doc);
fz_free_context(ctx);
return(-3);
}
fz_try(ctx) { list=fz_new_display_list(ctx);
dev=fz_new_list_device(ctx,list);
fz_run_page(doc,page,dev,&fz_identity,NULL);
}
fz_catch(ctx)
{
fz_free_device(dev);
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
fz_close_document(doc);
fz_free_context(ctx);
return(-4);
}
fz_free_device(dev);
dev=NULL;
fz_bound_page(doc,page,&bounds);
if (width_in!=NULL)
(*width_in)=fabs(bounds.x1-bounds.x0)/72.;
if (height_in!=NULL)
(*height_in)=fabs(bounds.y1-bounds.y0)/72.;
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
fz_close_document(doc);
}
fz_catch(ctx) /* Error registering */
{
fz_free_context(ctx);
return(-20);
}
fz_free_context(ctx);
return(0);
}
void render(char *filename, int pagenumber, int zoom, int rotation)
{
// Create a context to hold the exception stack and various caches.
fz_context *ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
// Open the PDF, XPS or CBZ document.
fz_document *doc = fz_open_document(ctx, filename);
// Retrieve the number of pages (not used in this example).
int pagecount = fz_count_pages(doc);
// Load the page we want. Page numbering starts from zero.
fz_page *page = fz_load_page(doc, pagenumber - 1);
// Calculate a transform to use when rendering. This transform
// contains the scale and rotation. Convert zoom percentage to a
// scaling factor. Without scaling the resolution is 72 dpi.
fz_matrix transform;
fz_rotate(&transform, rotation);
fz_pre_scale(&transform, zoom / 100.0f, zoom / 100.0f);
// Take the page bounds and transform them by the same matrix that
// we will use to render the page.
fz_rect bounds;
fz_bound_page(doc, page, &bounds);
fz_transform_rect(&bounds, &transform);
// Create a blank pixmap to hold the result of rendering. The
// pixmap bounds used here are the same as the transformed page
// bounds, so it will contain the entire page. The page coordinate
// space has the origin at the top left corner and the x axis
// extends to the right and the y axis extends down.
fz_irect bbox;
fz_round_rect(&bbox, &bounds);
fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb(ctx), &bbox);
fz_clear_pixmap_with_value(ctx, pix, 0xff);
// A page consists of a series of objects (text, line art, images,
// gradients). These objects are passed to a device when the
// interpreter runs the page. There are several devices, used for
// different purposes:
//
// draw device -- renders objects to a target pixmap.
//
// text device -- extracts the text in reading order with styling
// information. This text can be used to provide text search.
//
// list device -- records the graphic objects in a list that can
// be played back through another device. This is useful if you
// need to run the same page through multiple devices, without
// the overhead of parsing the page each time.
// Create a draw device with the pixmap as its target.
// Run the page with the transform.
fz_device *dev = fz_new_draw_device(ctx, pix);
fz_run_page(doc, page, dev, &transform, NULL);
fz_free_device(dev);
// Save the pixmap to a file.
fz_write_png(ctx, pix, "out.png", 0);
// Clean up.
fz_drop_pixmap(ctx, pix);
fz_free_page(doc, page);
fz_close_document(doc);
fz_free_context(ctx);
}
int main(int argc, char **argv) {
fz_document *doc = NULL;
int c;
fz_context *ctx;
fz_var(doc);
yctx = yutani_init();
char * _width = getenv("WIDTH");
char * _height = getenv("HEIGHT");
width = _width ? atoi(_width) : 512;
height = _height ? atoi(_height) : 512;
init_decorations();
window = yutani_window_create(yctx, width + decor_width(), height + decor_height());
yutani_window_move(yctx, window, 50, 50);
yutani_window_advertise_icon(yctx, window, "PDF Viewer", "pdfviewer");
gfx_ctx = init_graphics_yutani(window);
draw_fill(gfx_ctx,rgb(0,0,0));
render_decorations(window, gfx_ctx, "PDFViewer - Loading...");
while ((c = fz_getopt(argc, argv, "wf")) != -1) {
switch (c) {
case 'f':
fit = 1;
break;
}
}
ctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT);
if (!ctx) {
fprintf(stderr, "Could not initialize fitz context.\n");
exit(1);
}
fz_set_aa_level(ctx, alphabits);
colorspace = fz_device_rgb;
fz_try(ctx) {
while (fz_optind < argc)
{
fz_try(ctx)
{
filename = argv[fz_optind++];
files++;
fz_try(ctx)
{
doc = fz_open_document(ctx, filename);
}
fz_catch(ctx)
{
fz_throw(ctx, "cannot open document: %s", filename);
}
if (fz_optind == argc || !isrange(argv[fz_optind]))
drawrange(ctx, doc, "1-");
if (fz_optind < argc && isrange(argv[fz_optind]))
drawrange(ctx, doc, argv[fz_optind++]);
fz_close_document(doc);
doc = NULL;
}
fz_catch(ctx)
{
if (!ignore_errors)
fz_rethrow(ctx);
fz_close_document(doc);
doc = NULL;
fz_warn(ctx, "ignoring error in '%s'", filename);
}
}
}
fz_catch(ctx) {
fz_close_document(doc);
fprintf(stderr, "error: cannot draw '%s'\n", filename);
errored = 1;
}
fz_free_context(ctx);
return (errored != 0);
}
int bmpmupdf_pdffile_to_bmp(WILLUSBITMAP *bmp,char *filename,int pageno,double dpi,
int bpp)
{
fz_context *ctx;
fz_colorspace *colorspace;
fz_document *doc;
fz_page *page;
fz_display_list *list;
fz_device *dev;
fz_pixmap *pix;
double dpp;
fz_rect bounds,bounds2;
fz_matrix ctm;
fz_irect bbox;
// fz_glyph_cache *glyphcache;
// fz_error error;
int np,status;
dev=NULL;
list=NULL;
page=NULL;
doc=NULL;
status=0;
if (pageno<1)
return(-99);
ctx = fz_new_context(NULL,NULL,FZ_STORE_DEFAULT);
if (!ctx)
return(-1);
fz_try(ctx)
{
fz_register_document_handlers(ctx);
fz_set_aa_level(ctx,8);
/* Sumatra version of MuPDF v1.4 -- use locally installed fonts */
pdf_install_load_system_font_funcs(ctx);
// fz_accelerate();
// glyphcache=fz_new_glyph_cache();
colorspace=(bpp==8 ? fz_device_gray(ctx) : fz_device_rgb(ctx));
fz_try(ctx) { doc=fz_open_document(ctx,filename); }
fz_catch(ctx)
{
fz_free_context(ctx);
return(-1);
}
/*
if (fz_needs_password(doc) && !fz_authenticate_password(doc,password))
return(-2);
*/
// error=pdf_load_page_tree(xref);
// if (error)
// {
// pdf_free_xref(xref);
// return(-2);
// }
np=fz_count_pages(doc);
if (pageno>np)
return(-99);
fz_try(ctx) { page = fz_load_page(doc,pageno-1); }
fz_catch(ctx)
{
fz_close_document(doc);
fz_free_context(ctx);
return(-3);
}
fz_try(ctx) { list=fz_new_display_list(ctx);
dev=fz_new_list_device(ctx,list);
fz_run_page(doc,page,dev,&fz_identity,NULL);
}
fz_catch(ctx)
{
fz_free_device(dev);
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
fz_close_document(doc);
fz_free_context(ctx);
return(-4);
}
fz_free_device(dev);
dev=NULL;
dpp=dpi/72.;
pix=NULL;
fz_var(pix);
fz_bound_page(doc,page,&bounds);
ctm=fz_identity;
fz_scale(&ctm,dpp,dpp);
// ctm=fz_concat(ctm,fz_rotate(rotation));
bounds2=bounds;
fz_transform_rect(&bounds2,&ctm);
fz_round_rect(&bbox,&bounds2);
// ctm=fz_translate(0,-page->mediabox.y1);
// ctm=fz_concat(ctm,fz_scale(dpp,-dpp));
// ctm=fz_concat(ctm,fz_rotate(page->rotate));
// ctm=fz_concat(ctm,fz_rotate(0));
// bbox=fz_round_rect(fz_transform_rect(ctm,page->mediabox));
// pix=fz_new_pixmap_with_rect(colorspace,bbox);
fz_try(ctx)
{
pix=fz_new_pixmap_with_bbox(ctx,colorspace,&bbox);
fz_clear_pixmap_with_value(ctx,pix,255);
dev=fz_new_draw_device(ctx,pix);
if (list)
fz_run_display_list(list,dev,&ctm,&bounds2,NULL);
else
fz_run_page(doc,page,dev,&ctm,NULL);
fz_free_device(dev);
dev=NULL;
status=bmpmupdf_pixmap_to_bmp(bmp,ctx,pix);
fz_drop_pixmap(ctx,pix);
}
fz_catch(ctx)
{
fz_free_device(dev);
fz_drop_pixmap(ctx,pix);
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
fz_close_document(doc);
fz_free_context(ctx);
return(-5);
}
if (list)
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
// pdf_free_xref(xref);
fz_close_document(doc);
fz_flush_warnings(ctx);
} /* fz_catch before registering handlers */
fz_catch(ctx) /* Error registering */
{
status = -10;
}
fz_free_context(ctx);
// fz_free_glyph_cache(glyphcache);
// fz_flush_warnings();
if (status<0)
return(status-10);
return(0);
}
JNIEXPORT jlong JNICALL
JNI_FN(MuPDF_openFile)(JNIEnv * env, jobject thiz, jstring jfilename)
{
const char *filename;
globals *glo;
fz_context *ctx;
jclass clazz;
#ifdef NDK_PROFILER
monstartup("libmupdf.so");
#endif
clazz = (*env)->GetObjectClass(env, thiz);
global_fid = (*env)->GetFieldID(env, clazz, "globals", "J");
glo = calloc(1, sizeof(*glo));
if (glo == NULL)
return 0;
glo->resolution = 160;
filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
if (filename == NULL)
{
LOGE("Failed to get filename");
free(glo);
return 0;
}
/* 128 MB store for low memory devices. Tweak as necessary. */
glo->ctx = ctx = fz_new_context(NULL, NULL, 128 << 20);
if (!ctx)
{
LOGE("Failed to initialise context");
(*env)->ReleaseStringUTFChars(env, jfilename, filename);
free(glo);
return 0;
}
glo->doc = NULL;
fz_try(ctx)
{
glo->colorspace = fz_device_rgb;
LOGE("Opening document...");
fz_try(ctx)
{
glo->current_path = fz_strdup(ctx, (char *)filename);
glo->doc = fz_open_document(ctx, (char *)filename);
}
fz_catch(ctx)
{
fz_throw(ctx, "Cannot open document: '%s'", filename);
}
LOGE("Done!");
}
fz_catch(ctx)
{
LOGE("Failed: %s", ctx->error->message);
fz_close_document(glo->doc);
glo->doc = NULL;
fz_free_context(ctx);
glo->ctx = NULL;
free(glo);
glo = NULL;
}
(*env)->ReleaseStringUTFChars(env, jfilename, filename);
return (jlong)(void *)glo;
}
int main (int argc, char **argv) {
fz_context *context;
int *pageinfo = NULL;
/* int i; */
/* Initialises mutexes required for Fitz locking */
init_least_context_locks();
context = fz_new_context(NULL, &least_context_locks, FZ_STORE_DEFAULT);
if (!context)
fprintf(stderr, "Failed to create context\n");
if (force_thread_count)
thread_count = force_thread_count;
else
thread_count = sysconf(_SC_NPROCESSORS_ONLN);
if (argc == 2) {
/* Initialize OpenGL window */
setup_sdl();
/* Start render threads */
init_threads(thread_count, context);
/*
* At this point, we should have a properly setup
* double-buffered window for use with OpenGL.
*/
setup_opengl(w, h);
init_busy_texture();
/* Check for non-power-of-two support */
/* printf("Extensions are: %s\n", glGetString(GL_EXTENSIONS)); */
if (strstr((const char *)glGetString(GL_EXTENSIONS),
"GL_ARB_texture_non_power_of_two")) {
puts("Machine supports NPOT textures.");
power_of_two = 0;
} else {
puts("Machine supports POT textures only.");
power_of_two = 1;
}
power_of_two |= force_power_of_two;
/* Load textures from PDF file */
open_pdf(context, argv[1]);
/*
* Now we want to begin our normal app process--
* an event loop with a lot of redrawing.
*/
while (1) {
/* Process incoming events. */
process_events();
/* Update cache state */
update_cache();
if (redraw) {
/*
glDeleteTextures(pagec, pages);
open_pdf(context, argv[1]);
*/
redraw = 0;
draw_screen();
}
/*
pageinfo = NULL;
for(i = 0; i < visible_pages(pageinfo); i++) {
printf("%d, ", i);
}
printf("\n");
*/
free(pageinfo);
}
}
fz_close_document(doc);
fz_free_context(context);
return 0;
}
