code:
// FPDFEMB.H - Header file for FPDFEMB SDK
// Copyright (c) 2007-2008 Foxit Software Company, All Right Reserved.

// Date: 2008-04-07

// Embedded platforms have many different aspects from desktop platforms,
// among them, the followings are most important for PDF processing:
//
// 1.	Embedded platforms have only limited memory, and there is no virtual memory.
//		PDF is a very complicated format, processing PDF may consumes quite
//		large amount of memory, even for some smaller PDFs. And, in order to
//		increase the performance of PDF parsing and rendering, cache memory
//		is often used. For some big PDFs with many pages, the cache may grow
//		while user browing through pages, eventually, for some PDFs, the memory
//		on the device may run out.
//
//		FPDFEMB SDK allows graceful out-of-memory (OOM) handling by returning
//		OOM error code for all functions that may involve memory allocation.
//		When an application detects OOM situation, it can do one of the followings:
//
//			a) Give user some prompt and quit the application or close the document;
//			b) Or better, try to recover from the error. Sometimes OOM can be caused
//				by ever-growing cache. For example, when user browses a 1000-page
//				document, let's say OOM happen at page #300. In this case, the
//				application might close the whole document (cache will be gone with
//				it), reopen the document, then go directly to page #300. It's likely
//				the process will go through this time. This is called "OOM recovery".
//				If OOM happens again during a recovery, then, it's not possible to finish
//				the process, the application must quit of close the document.
//
// 2.	Embedded platforms has only limited computing power. Since some PDFs
//		can be very complicated and require a lot of processing to be displayed,
//		it may take a lot of time for the process to finish. This may cause
//		some problem with user experience, especially for devices like mobile
//		phones, when an application may need to be put on hold any time. Therefore,
//		it's important to break lengthy process into small steps which can be
//		stopped or resumed at any time. We call this kind of process as
//		"progressive process".
//
//		FPDFEMB SDK allows progressive page parsing and rendering, the most time-
//		consuming part of PDF processing.
//
// IMPORTANT:
//		FPDFEMB module is not intended to run in multi-threaded environment.

// Components inside FPDFEMB:
//		* Library Memory Management
//		* Document Operations
//		* Page Basic Operations
//		* Page Parsing
//		* Page Rendering
//		* Coordination Conversion
//		* Text Search
//		* Text Information
//		* Device Independant Bitmap
//		* Custom Font Handler and CJK Support
//		* Bookmark Information
//		* Hyperlink Information
//		* Graphic Output

#ifndef _FPDFEMB_H_
#define _FPDFEMB_H_

#ifdef __cplusplus
extern "C" {
#endif

// Standard return type for many FPDFEMB functions: FPDFERR_SUCCESS for success, otherwise error code
typedef int FPDFEMB_RESULT;

// Standard boolean type: 0 for false, non-zero for true
typedef int FPDFEMB_BOOL;

// Unicode character. FPDFEMB uses UTF16LE format for unicode string.
typedef unsigned short FPDFEMB_WCHAR;

// Error codes
#define FPDFERR_SUCCESS		0
#define FPDFERR_MEMORY		1		// Out of memory
#define FPDFERR_ERROR		2		// Error of any kind, without specific reason
#define FPDFERR_PASSWORD	3		// Incorrect password
#define FPDFERR_FORMAT		4		// Not PDF format
#define FPDFERR_FILE		5		// File access error
#define FPDFERR_PARAM		6		// Parameter error
#define FPDFERR_STATUS		7		// Not in correct status
#define FPDFERR_TOBECONTINUED	8	// To be continued
#define FPDFERR_NOTFOUND	9		// Search result not found

/********************************************************************************************
****
****		Library Memory Management
****
********************************************************************************************/

// Structure: FPDFEMB_MEMMGR
//			Including interfaces implemented by host application, providing memory allocation
//			facilities. All members are required.
//			A memory manager structure is required to be valid during the entire period
//			when an application using FPDFEMB module.
//
//			IMPORTANT NOTE: using of this interface is strongly not recommended, because
//			FPDFEMB now internally use FPDFEMB_MEMMGR_EX interface, which allows more
//			advanced memory management. This interface is retained for backward compatibility
//			only, and maybe discontinued in the future.
//
struct FPDFEMB_MEMMGR {
	// Interface: Alloc
	//		Allocate a memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		size		-	Number of bytes for the memory block.
	// Return Value:
	//		The pointer to allocated memory block. NULL if no memory available.
	// Comments:
	//		In order to handle OOM situation, application can use longjmp() inside
	//		implementation of this function. If underlying memory manager fails to
	//		allocate enough memory, then application can use longjmp() to jump to
	//		OOM handling codes.
	//
	void*	(*Alloc)(struct FPDFEMB_MEMMGR* pMgr, unsigned int size);

	// Interface: AllocNL
	//		Allocate a memory block, without leaving
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		size		-	Number of bytes for the memory block.
	// Return Value:
	//		The pointer to allocated memory block. NULL if no memory available.
	// Comments:
	//		Implementation MUST return NULL if no memory available, no exception
	//		or longjmp() can be used.
	//
	void*	(*AllocNL)(struct FPDFEMB_MEMMGR* pMgr, unsigned int size);

	// Interfce: Realloc
	//		Reallocate a memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		pointer		-	An existing memory block, or NULL.
	//		new_size	-	New size (number of bytes) of the memory block. Can be zero.
	// Return value:
	//		The pointer of reallocated memory block, it could be a new block, or just
	//		the previous block with size modified.
	// Comments:
	//		If an existing memory block specified, the data in the memory block will
	//		be copied to the new block, if reallocated.
	//
	//		In order to handle OOM situation, application can use longjmp() inside
	//		implementation of this function. If underlying memory manager fails to
	//		allocate enough memory, then application can use longjmp() to jump to
	//		OOM handling codes.
	//
	void*	(*Realloc)(struct FPDFEMB_MEMMGR* pMgr, void* pointer, unsigned int new_size);

	// Interface: Free
	//		Free a memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		pointer		-	An existing memory block.
	// Return Value:
	//		None.
	//
	void	(*Free)(struct FPDFEMB_MEMMGR* pMgr, void* pointer);
};

// Function: FPDFEMB_Init
//			Initialize the FPDFEMB module
// Parameters:
//			mem_mgr		-	Pointer to memory manager structure
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			This function will allocate necessary internal data structure for
//			the whole module to operate.
FPDFEMB_RESULT FPDFEMB_Init(FPDFEMB_MEMMGR* mem_mgr);

typedef void (*FPDFEMB_FIXED_OOM_HANDLER)(void* memory, int size);

// Function: FPDFEMB_InitFixedMemory
//			Initialize the FPDFEMB module, providing a fixed memory heap
// Parameters:
//			memory		-	Pointer to a pre-allocated memory block
//			size		-	Number of bytes in the memory block
//			oom_handler	-	Pointer to a function which will be called when OOM happens. Can be
//							NULL if application doesn't want to be notified om OOM.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			In many embedded system, memory usage are predetermined. The application
//			is assigned with fixed size of available memory, then it can pre-allocate
//			a memory block with maximum size and pass to this function to initialize
//			FPDFEMB module. In this case, FPDFEMB won't need any additional memory
//			allocation.
//
//			In case the pre-allocated memory has run out, the "oom_proc" callback
//			function will be called to notify the application that an OOM recovery
//			procedure needs to be performed.
//
FPDFEMB_RESULT FPDFEMB_InitFixedMemory(void* memory, int size, FPDFEMB_FIXED_OOM_HANDLER oom_handler);

// Memory Management Flags
#define FPDFEMB_NONLEAVE		1
#define FPDFEMB_MOVABLE			2
#define FPDFEMB_DISCARDABLE		4

// Structure: FPDFEMB_MEMMGR_EX
//			This is an extended version of memory manager interface, allowing advanced
//			memory management, including movable and discardable memory blocks.
//
//			Use this interface with FPDFEMB_InitExt function.
//
struct FPDFEMB_MEMMGR_EX {
	// Interface: Alloc
	//		Allocate a memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		size		-	Number of bytes for the memory block.
	//		flags		-	A combination of flags defined above.
	// Return Value:
	//		The pointer to allocated memory block. NULL if no memory available.
	//		If FPDFEMB_MOVABLE flag is used, implementation should return a handle
	//		to the memory block, if it supports movable block allocation.
	// Comments:
	//		The implementation should not do any action if no memory available,
	//		just return NULL. OOM handling can be done in OOM_Handler interface.
	//
	void*	(*Alloc)(struct FPDFEMB_MEMMGR_EX* pMgr, unsigned int size, int flags);

	// Interface: OOM_Handler
	//		OOM (out-of-memory) situation handler
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	// Return Value:
	//		None.
	// Comments:
	//		In order to handle OOM situation, application can use longjmp() inside
	//		implementation of this function.
	//
	void	(*OOM_Handler)(struct FPDFEMB_MEMMGR_EX* pMgr);

	// Interfce: Realloc
	//		Reallocate a memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		pointer		-	Pointer to an existing memory block, or handle to a movable
	//						block. Can not be NULL.
	//		new_size	-	New size (number of bytes) of the memory block. Can not be zero.
	// Return value:
	//		The pointer of reallocated memory block, it could be a new block, or just
	//		the previous block with size modified.
	//		If FPDFEMB_MOVABLE flag is used, implementation should return a handle
	//		to the memory block, if it supports movable block allocation.
	// Comments:
	//		If an existing memory block specified, the data in the memory block should
	//		be copied to the new block, if reallocated.
	//
	//		The implementation should not do any action if no memory available,
	//		just return NULL. OOM handling can be done in OOM_Handler interface.
	//
	void*	(*Realloc)(struct FPDFEMB_MEMMGR_EX* pMgr, void* pointer, unsigned int new_size, int flags);

	// Interface: Lock
	//		Lock a movable memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		handle		-	Handle to movable memory block, returned by Alloc or Realloc.
	// Return Value:
	//		The pointer of the memory block. NULL if the block was discarded.
	// Comments:
	//		This interface is optional, if implementation doesn't support movable memory
	//		block, then this interface can be set to NULL.
	//
	void*	(*Lock)(struct FPDFEMB_MEMMGR_EX* pMgr, void* handle);

	// Interface: Unlock
	//		Unlock a locked movable memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		handle		-	Handle to movable memory block, returned by Alloc or Realloc.
	// Return Value:
	//		None.
	// Comments:
	//		This interface is optional, if implementation doesn't support movable memory
	//		block, then this interface can be set to NULL.
	//
	void	(*Unlock)(struct FPDFEMB_MEMMGR_EX* pMgr, void* handle);

	// Interface: Free
	//		Free a memory block
	// Parameters:
	//		pMgr		-	Pointer to the memory manager.
	//		pointer		-	Pointer to an existing memory block, or handle to a movable block.
	// Return Value:
	//		None.
	//
	void	(*Free)(struct FPDFEMB_MEMMGR_EX* pMgr, void* pointer, int flags);

	void*	user;		// A user pointer, used by the application
};

// Function: FPDFEMB_LoadJbig2Decoder
// Function: FPDFEMB_LoadJpeg2000Decoder
//			Enable JBIG2 or JPEG2000 image decoder
// Parameters:
//			None.
// Return Value:
//			None.
// Comments:
//			If you want to display JBIG2 or JPEG2000 encoded images, you need to call
//			these functions after FPDFEMB initialized.
//
//			Calling these functions will increase code size by about 200K-400K bytes.
//			Also JPEG2000 decoder may not be available on some platforms.
//
void FPDFEMB_LoadJbig2Decoder();
void FPDFEMB_LoadJpeg2000Decoder();

// Function: FPDFEMB_InitEx
//			Initialize the FPDFEMB module with the extended memory manager
// Parameters:
//			mem_mgr		-	Pointer to memory manager structure
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			This function will allocate necessary internal data structure for
//			the whole module to operate.
FPDFEMB_RESULT FPDFEMB_InitEx(FPDFEMB_MEMMGR_EX* mem_mgr);

// Function: FPDFEMB_Exit
//			Stop using FPDFEMB module and release all resources
// Parameters:
//			None.
// Return Value:
//			None.
// Comments:
//			All loaded documents and pages will become invalid after this call.
//
//			This function is useful for OOM recovery: when your application hits
//			an OOM situation, calling this function will clear all memory allocated
//			by FPDFEMB module, then you can call one of the initialization functions,
//			reopen the document and recovery from OOM.
//
void FPDFEMB_Exit();

// Function: FPDFEMB_AllocMemory
//			Allocate memory
// Parameters:
//			size		-	Number of bytes
// Return Value:
//			The allocated buffer pointer. NULL for out of memory.
//
void* FPDFEMB_AllocMemory(unsigned int size);

// Function: FPDFEMB_FreeMemory
//			Free allocated memory
// Parameters:
//			pointer		-	Pointer returned by FPDFEMB_AllocMemory
// Return Value:
//			None.
//
void FPDFEMB_FreeMemory(void* pointer);

// Function: FPDFEMB_FreeCaches
//			Free all expendable caches used by FPDFEMB in order to save memory
// Parameters:
//			None.
// Return Value:
//			None.
// Comments:
//			When an application memory manager runs out of memory, before an OOM situation
//			is raised, the application can try this
//
void FPDFEMB_FreeCaches();

/********************************************************************************************
****
****		Document Operations
****
********************************************************************************************/

// Structure: FPDFEMB_FILE_ACCESS
//		Describe the way to access a file (readonly).
struct FPDFEMB_FILE_ACCESS {
	// Inteface: GetSize
	//		Get total size of the file
	// Parameters:
	//		file		-	Pointer to this file access structure
	// Return Value:
	//		File size, in bytes. Implementation can return 0 for any error.
	//
	unsigned int	(*GetSize)(struct FPDFEMB_FILE_ACCESS* file);

	// Interface: ReadBlock
	//		Read a data block from the file
	// Parameters:
	//		file		-	Pointer to this file access structure
	//		buffer		-	Pointer to a buffer receiving read data
	//		offset		-	Byte offset for the block, from beginning of the file
	//		size		-	Number of bytes for the block.
	// Return Value:
	//		Error code, or FPDFERR_SUCCESS for success.
	//
	FPDFEMB_RESULT	(*ReadBlock)(struct FPDFEMB_FILE_ACCESS* file, void* buffer,
									unsigned int offset, unsigned int size);

	void*		user;		// A user pointer, used by the application
};

// Structure: FPDFEMB_PAUSE
//			An interface for pausing a progressive process.
struct FPDFEMB_PAUSE {
	// Interface: NeedPauseNow
	//		Check if we need to pause a progressive proccess now
	// Parameters:
	//		pause		-	Pointer to the pause structure
	// Return Value:
	//		Non-zero for pause now, 0 for continue.
	// Comments:
	//		Typically implementation of this interface compares the current system tick
	//		with the previous one, if the time elapsed exceeds certain threshold, then
	//		the implementation returns TRUE, indicating a pause is needed.
	//
	FPDFEMB_BOOL (*NeedPauseNow)(struct FPDFEMB_PAUSE* pause);

	void*		user;		// A user pointer, used by the application
};

typedef void* FPDFEMB_DOCUMENT;

// Function: FPDFEMB_StartLoadDocument
//			Start loading a PDF document
// Parameters:
//			file		-	Pointer to file access structure.
//							This structure must be kept valid as long as the document is open.
//			password	-	Pointer to a zero-terminated byte string, for the password.
//							Or NULL for no password.
//			document	-	Receiving the document handle
//			pause		-	A callback mechanism allowing the document loading process
//							to be paused before it's finished. This can be NULL if you
//							don't want to pause.
// Return Value:
//			FPDFERR_SUCCESS: document successfully loaded.
//			FPDFERR_TOBECONTINUED: The document loading can't be finished now.
//					See comments below.
//			FPDFERR_PASSWORD: incorrect password.
//			FPDFERR_FORMAT: not a PDF or corrupted PDF.
//			FPDFERR_FILE: file access error.
//			FPDFERR_MEMORY: out of memory.
// Comments:
//			Document loading is a progressive process. It might take a long time to
//			load a document, especiall when a file is corrupted, FPDFEMB will try to
//			recover the document contents by scanning the whole file. If "pause" parameter
//			is provided, this function may return FPDFERR_TOBECONTINUED any time during
//			the document loading.
//
//			When FPDFERR_TOBECONTINUED is returned, the "document" parameter will
//			still receive a valid document handle, however, no further operations can
//			be performed on the document, except the "FPDFEMB_ContineLoadDocument" function
//			call, which resume the document loading.
//
FPDFEMB_RESULT FPDFEMB_StartLoadDocument(FPDFEMB_FILE_ACCESS* file, const char* password,
									FPDFEMB_DOCUMENT* document, FPDFEMB_PAUSE* pause);

// Function: FPDFEMB_ContinueLoadDocument
//			Continue loading a PDF document
// Parameters:
//			document	-	Document handle returned by FPDFEMB_StartLoadDocument function
//			pause		-	A callback mechanism allowing the document loading process
//							to be paused before it's finished. This can be NULL if you
//							don't want to pause.
// Return Value:
//			FPDFERR_SUCCESS: document successfully loaded.
//			FPDFERR_TOBECONTINUED: The document loading can't be finished now.
//					Further call to this function is needed.
//			FPDFERR_PASSWORD: incorrect password.
//			FPDFERR_FORMAT: not a PDF or corrupted PDF.
//			FPDFERR_FILE: file access error.
//			FPDFERR_MEMORY: out of memory.
//			FPDFERR_STATUS: document already loaded.
//			FPDFERR_PARAM: invalid parameter (like NULL document handle)
//
FPDFEMB_RESULT FPDFEMB_ContinueLoadDocument(FPDFEMB_DOCUMENT document, FPDFEMB_PAUSE* pause);

// Function: FPDFEMB_CloseDocument
//			Close a PDF document and free all associated resources
// Parameters:
//			document	-	Document handle
// Return Value:
//			Error code. FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_CloseDocument(FPDFEMB_DOCUMENT document);

// Function: Get page count
//			Get number of pages in the document
// Parameters:
//			document	-	Document handle
// Return Value:
//			Number of pages.
//
int FPDFEMB_GetPageCount(FPDFEMB_DOCUMENT document);

// Function: FPDFEMB_SetFileBufferSize
//			Set size of internal buffer used to read from source file.
// Parameters:
//			size		-	Number of bytes
// Return Value:
//			None.
// Comments:
//			Currently FPDFEMB uses 512 bytes as default buffer size. The new buffer size
//			takes effect next time you call FPDFEMB_StartLoadDocument.
//
void FPDFEMB_SetFileBufferSize(int size);

/********************************************************************************************
****
****		Page Basic Operations
****
********************************************************************************************/

typedef void* FPDFEMB_PAGE;

// Function: FPDFEMB_LoadPage
//			Load a page
// Parameters:
//			document	-	Document handle
//			index		-	Page index, starting from zero
//			page		-	Receiving the loaded page handler
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_LoadPage(FPDFEMB_DOCUMENT document, int index, FPDFEMB_PAGE* page);

// Function: FPDFEMB_ClosePage
//			Close a page and release all related resources
// Parameters:
//			page		-	Page handle
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_ClosePage(FPDFEMB_PAGE page);

// Function: FPDFEMB_GetPageSize
//			Get size of a page
// Parameters:
//			page		-	Page handle
//			width		-	Receiving page width, in hundredth of points
//			height		-	Receiving page height, in hundredth of points
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
//
FPDFEMB_RESULT FPDFEMB_GetPageSize(FPDFEMB_PAGE page, int* width, int* height);

// Structure: FPDFEMB_RECT
//			Rectangle area in device or page coordination system
//
struct FPDFEMB_RECT
{
	// For device system, coordinations are measured in pixels;
	// For page system, coordinations are measured in hundredth of points.
	int		left;
	int		top;
	int		right;
	int		bottom;
};

// Function: FPDFEMB_GetPageBBox
//			Get displayable area (bounding box) of a page
// Parameters:
//			page		-	Page handle
//			rect		-	Pointer to a structure receiving the rectangle
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
//
FPDFEMB_RESULT FPDFEMB_GetPageBBox(FPDFEMB_PAGE page, FPDFEMB_RECT* rect);

/********************************************************************************************
****
****		Page Parsing
****
********************************************************************************************/

// Function: FPDFEMB_StartParse
//			Start parsing a page, so it can get rendered or searched
// Parameters:
//			page		-	Page handle
//			text_only	-	flag for parsing texts only (used for searching)
//			pause		-	A structure that can pause the parsing process.
//							Or NULL if you don't want to pause the process.
// Return Value:
//			FPDFERR_SUCCESS: parsing successfully finished;
//			FPDFERR_TOBECONTINUED: parsing started successfully, but not finished;
//			FPDFERR_STATUS: page already parsed, or parsing already started.
//			Other return value: error code.
// Comments:
//			Parsing is a progressive process. This function starts the parsing process,
//			and may return before parsing is finished, if a pause structure is provided.
//
//			Application should call FPDFEMB_ContinueParse repeatedly to finish the parsing
//			when return value is FPDFERR_TOBECONTINUED.
//
//			There can be only one parsing procedure active for a page, and if a page
//			has already been parsed, you can't start a parsing again.
//
FPDFEMB_RESULT FPDFEMB_StartParse(FPDFEMB_PAGE page, FPDFEMB_BOOL text_only,
												FPDFEMB_PAUSE* pause);

// Function: FPDFEMB_ContinueParse
//			Continue the page parsing
// Parameters:
//			page		-	Page handle
//			pause		-	A structure that can pause the parsing process.
//							Or NULL if you don't want to pause the process.
// Return Value:
//			FPDFERR_SUCCESS: parsing successfully finished;
//			FPDFERR_TOBECONTINUED: parsing performed successfully, but not finished;
//			FPDFERR_STATUS: page already parsed (or parsing not started).
//			Other return value: error code.
// Comments:
//			FPDFEMB_StartParse should be called before on the page.
//
//			Application should call FPDFEMB_ContinueParse repeatedly to finish the parsing
//			when return value is FPDFERR_TOBECONTINUED.
//
FPDFEMB_RESULT FPDFEMB_ContinueParse(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);

// Function: FPDFEMB_GetParseProgress
//			Get an estimated parsing progress in percentage
// Parameters:
//			page		-	Page handle
// Return Value:
//			An integer between 0 and 100 (inclusive) indicating the parsing progress.
//			The result is just a rough estimation.
//
int FPDFEMB_GetParseProgress(FPDFEMB_PAGE page);

/********************************************************************************************
****
****		Page Rendering
****
********************************************************************************************/

typedef void* FPDFEMB_BITMAP;

// Function: FPDFEMB_StartQuickDraw
//			Start drawing a quick preview of a page
// Parameters:
//			dib			-	DIB handle, as the rendering device
//			page		-	Page handle. The page has to be parsed first.
//			start_x		-	Left pixel position of the display area in the device coordination
//			start_y		-	Top pixel position of the display area in the device coordination
//			size_x		-	Horizontal size (in pixels) for displaying the page
//			size_y		-	Vertical size (in pixels) for displaying the page
//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
//			flags		-	Reserved, must be zero.
//			pause		-	Pointer to a structure that can pause the rendering process.
//							Can be NULL if no pausing is needed.
// Return Value:
//			FPDFERR_SUCCESS: quickdraw successly finished;
//			FPDFERR_TOBECONTINUED: quickdraw started successfully, but not finished.
//							FPDFEMB_ContinueQuickDraw needs to be called to finish the quickdraw;
//			FPDFERR_STATUS: quickdraw already in progress, or page not parsed;
//			Other return value: error code.
// Comments:
//			It's often useful to present user a quick preview of a page, right after the
//			page is parsed. This preview renders only a limited set of easy features in the
//			page, so it'll be rather quick to finish this process.
//
FPDFEMB_RESULT FPDFEMB_StartQuickDraw(FPDFEMB_BITMAP dib, FPDFEMB_PAGE page,
							int start_x, int start_y, int size_x, int size_y, int rotate,
							int flags, FPDFEMB_PAUSE* pause);

// Function: FPDFEMB_ContinueQuickDraw
//			Continue a quick draw processing
// Parameters:
//			page		-	Page handle. The page has to be parsed first.
//			pause		-	Pointer to a structure that can pause the rendering process.
//							Can be NULL if no pausing is needed.
// Return Value:
//			FPDFERR_SUCCESS: quickdraw successly finished;
//			FPDFERR_TOBECONTINUED: quickdraw started successfully, but not finished.
//							more calls to this function needed to finish the quickdraw;
//			FPDFERR_STATUS: quickdraw not started yet;
//			Other return value: error code.
//
FPDFEMB_RESULT FPDFEMB_ContinueQuickDraw(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);

#define FPDFEMB_ANNOT			0x01		// Set if annotations are to be rendered
#define FPDFEMB_LCD_TEXT		0x02		// Set if using text rendering optimized for LCD display
#define FPDFEMB_BGR_STRIPE		0x04		// Set if the device is using BGR LCD stripe

// Function: FPDFEMB_StartRender
//			Start rendering of a page.
// Parameter:
//			dib			-	DIB handle, as the rendering device
//			page		-	Page handle. The page has to be parsed first.
//			start_x		-	Left pixel position of the display area in the device coordination
//			start_y		-	Top pixel position of the display area in the device coordination
//			size_x		-	Horizontal size (in pixels) for displaying the page
//			size_y		-	Vertical size (in pixels) for displaying the page
//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
//			flags		-	0 for normal display, or combination of flags defined above
//			clip		-	Pointer to clip rectangle (in DIB device coordinations),
//							or NULL if no clipping needed.
//			pause		-	Pointer to a structure that can pause the rendering process.
//							Can be NULL if no pausing is needed.
// Return Value:
//			FPDFERR_SUCCESS: rendering successfully finished;
//			FPDFERR_TOBECONTINUED: rendering started successfully, but not finished;
//			Other return value: error code.
// Comments:
//			Rendering is a progressive process. This function starts the rendering process,
//			and may return before rendering is finished, if a pause structure is provided.
//
//			Application should call FPDFEMB_ContinueRender repeatedly to finish the rendering
//			when return value is FPDFERR_TOBECONTINUED.
//
//			There can be only one rendering procedure for a page at any time. And rendering
//			can be started over and over again for the same page. If a page rendering is already
//			active, starting another one will cancel the previous rendering.
//
//			Rendering of a page doesn't draw the page background, therefore, you usually need
//			to draw the background in the DIB yourself.
//
FPDFEMB_RESULT FPDFEMB_StartRender(FPDFEMB_BITMAP dib, FPDFEMB_PAGE page,
						int start_x, int start_y, int size_x, int size_y, int rotate, int flags,
						FPDFEMB_RECT* clip, FPDFEMB_PAUSE* pause);

// Function: FPDFEMB_ContinueRender
//			Continue the page rendering
// Parameters:
//			page		-	Page handle
//			pause		-	Pointer to a structure that can pause the rendering process.
//							Can be NULL if no pausing is needed.
// Return Value:
//			FPDFERR_SUCCESS: rendering successfully finished.
//			FPDFERR_TOBECONTINUED: rendering needs to be continued;
//			Other return value: error code.
// Comments:
//			This function may return any time when the pause interface indicates
//			a pause is needed. Application can call FPDFEMB_ContinueRender any number
//			of times, until FPDFERR_TOBECONTINUED is not returned.
//
FPDFEMB_RESULT FPDFEMB_ContinueRender(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);

// Function: FPDFEMB_GetRenderProgress
//			Get an estimated rendering progress in percentage
// Parameters:
//			page		-	Page handle
// Return Value:
//			An integer between 0 and 100 (inclusive) indicating the rendering progress.
//			The result is just a rough estimation.
//			If the rendering just finished, this function will return 0.
//
int FPDFEMB_GetRenderProgress(FPDFEMB_PAGE page);

// Function: FPDFEMB_SetHalftoneLimit
//			Set pixel count limit for using halftone when display image
// Parameter:
//			limit		-	Number of pixels for the limit
// Return Value:
//			None.
// Comments:
//			By default, FPDFEMB displays all bitmaps using downsamping, which means
//			if the image is shrinked onto screen, only part of pixels will be picked
//			and displayed. This saves a lot of calculation, especially for big images
//			with millions of pixels. However the display quality can be bad. In order to
//			reach a balance between performance and quality, application can use this
//			function to set a limit, if number of pixels in an image is more than this
//			limit, then FPDFEMB will use downsampling for quick drawing, otherwise, if
//			the image has less pixels, FPDFEMB will use halftoning for better quality.
//
void FPDFEMB_SetHalftoneLimit(int limit);

/********************************************************************************************
****
****		Coordination Conversion
****
********************************************************************************************/

// Structure: FPDFEMB_POINT
//			A point in device or page coordination system
//
struct FPDFEMB_POINT
{
	// For device system, coordinations are measured in pixels;
	// For page system, coordinations are measured hundredth of points.
	int		x;
	int		y;
};

// Function: FPDFEMB_DeviceToPagePoint, FPDFEMB_DeviceToPageRect
//			Convert the device coordinations of a point or a rectangle to page coordinations.
// Parameters:
//			page		-	Handle to the page. Returned by FPDFEMB_LoadPage function.
//			start_x		-	Left pixel position of the display area in the device coordination
//			start_y		-	Top pixel position of the display area in the device coordination
//			size_x		-	Horizontal size (in pixels) for displaying the page
//			size_y		-	Vertical size (in pixels) for displaying the page
//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
//			point		-	A point structure with device coordinations upon the call,
//							also receiving the result page coordinations.
//			rect		-	A rectangle structure with device coordinations upon the call,
//							also receiving the result page coordinations.
// Return value:
//			None.
// Comments:
//			The page coordination system has its origin at left-bottom corner of the page,
//			with X axis goes along the bottom side to the right, and Y axis goes along the
//			left side upward. No matter how you zoom, scroll, or rotate a page, a particular
//			element (like text or image) on the page should always have the same coordination
//			values in the page coordination system.
//
//			The device coordination system is device dependant. For bitmap device, its origin
//			is at left-top corner of the window. You must make sure the start_x, start_y, size_x,
//			size_y and rotate parameters have exactly same values as you used in
//			FPDFEMB_StartRender() function call.
//
//			For rectangle conversion, the result rectangle is always "normalized", meaning for
//			page coordinations, left is always smaller than right, bottom is smaller than top.
//
void FPDFEMB_DeviceToPagePoint(FPDFEMB_PAGE page,
						int start_x, int start_y, int size_x, int size_y, int rotate,
						FPDFEMB_POINT* point);

void FPDFEMB_DeviceToPageRect(FPDFEMB_PAGE page,
						int start_x, int start_y, int size_x, int size_y, int rotate,
						FPDFEMB_RECT* rect);

// Function: FPDFEMB_PageToDevicePoint, FPDFEMB_PageToDeviceRect
//			Convert the page coordinations of a point or a rectangle to device coordinations.
// Parameters:
//			page		-	Handle to the page. Returned by FPDFEMB_LoadPage function.
//			start_x		-	Left pixel position of the display area in the device coordination
//			start_y		-	Top pixel position of the display area in the device coordination
//			size_x		-	Horizontal size (in pixels) for displaying the page
//			size_y		-	Vertical size (in pixels) for displaying the page
//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
//			point		-	A point structure with page coordinations upon the call,
//							also receiving the result device coordinations.
//			rect		-	A rectangle structure with page coordinations upon the call,
//							also receiving the result device coordinations.
// Return value:
//			None
// Comments:
//			For rectangle conversion, the result rectangle is always "normalized", meaning for
//			device coordinations, left is always smaller than right, top is smaller than bottom.
//
void FPDFEMB_PageToDevicePoint(FPDFEMB_PAGE page,
						int start_x, int start_y, int size_x, int size_y, int rotate,
						FPDFEMB_POINT* point);

void FPDFEMB_PageToDeviceRect(FPDFEMB_PAGE page,
						int start_x, int start_y, int size_x, int size_y, int rotate,
						FPDFEMB_RECT* rect);

/********************************************************************************************
****
****		Text Search
****
********************************************************************************************/

// Search flags for FPDFEMB_FindFirst function
#define FPDFEMB_MATCHCASE		1		// whether matching case
#define FPDFEMB_MATCHWHOLEWORD	2		// whether matching whole word
#define FPDFEMB_CONSECUTIVE		4		// whether matching consecutively (for example, "CC" will
										// match twice in "CCC").

// Function: FPDFEMB_FindFirst
//			Find first occurance of a pattern string in a page
// Parameters:
//			page		-	Page handle.
//			pattern		-	A zero-terminated unicode string to be found.
//			from_last	-	Whether we start from the end of page
//			flags		-	Search flags, see above defined constants
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//			Is not found, FPDFERR_NOTFOUND is returned.
// Comments:
//			A page must be parsed first before it can be searched.
//			There can be only one search in progress for a page. A new search will
//			cancel the previous one.
//
//			IMPORTANT: this function is now obsolete and kept for back compatibility
//			only, please use FPDFEMB_FindFrom function below.
//
FPDFEMB_RESULT FPDFEMB_FindFirst(FPDFEMB_PAGE page, const FPDFEMB_WCHAR* pattern,
								 FPDFEMB_BOOL from_last, unsigned int flags);

// Function: FPDFEMB_FindFrom
//			Find first occurance of a pattern string in a page, from a particular position
// Parameters:
//			page		-	Page handle.
//			pattern		-	A zero-terminated unicode string to be found.
//			pos			-	The position, returned from FPDFEMB_GetSearchPos.
//							Or 0 from the beginning of page, -1 from the end of page.
//			flags		-	Search flags, see above defined constants
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//			Is not found, FPDFERR_NOTFOUND is returned.
// Comments:
//			A page must be parsed first before it can be searched.
//			There can be only one search in progress for a page. A new search will
//			cancel the previous one.
//
FPDFEMB_RESULT FPDFEMB_FindFrom(FPDFEMB_PAGE page, const FPDFEMB_WCHAR* pattern,
								 int pos, unsigned int flags);

// Function: FPDFEMB_FindNext
//			Find next occurance of a search
// Parameters:
//			page		-	Page handle.
//							FPDFEMB_FindFirst must be called for this page first.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//			Is not found, FPDFERR_NOTFOUND is returned.
//
FPDFEMB_RESULT FPDFEMB_FindNext(FPDFEMB_PAGE page);

// Function: FPDFEMB_FindPrev
//			Find previous occurance of a search
// Parameters:
//			page		-	Page handle.
//							FPDFEMB_FindFirst must be called for this page first.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//			Is not found, FPDFERR_NOTFOUND is returned.
//
FPDFEMB_RESULT FPDFEMB_FindPrev(FPDFEMB_PAGE page);

// Function: FPDFEMB_CountFoundRects
//			Get number of rectangles for last found result
// Parameters:
//			page		-	Page handle.
// Return Value:
//			Number of rectangles for last found result. 0 for not found or failure.
//
int FPDFEMB_CountFoundRects(FPDFEMB_PAGE page);

// Function: FPDFEMB_GetFoundRect
//			Get a particular found rectangle
// Parameters:
//			page		-	Page handle.
//			index		-	Zero-based index for the rectangle.
//			rect		-	Receiving the result rectangle, in hundredth of points
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			Application should always call FPDFEMB_CountFoundRects first to get
//			number of rectangles, then use this function to get each rectangle.
//
//			The returned rectangle uses page coordination system.
//
FPDFEMB_RESULT FPDFEMB_GetFoundRect(FPDFEMB_PAGE page, int index, FPDFEMB_RECT* rect);

// Function: FPDFEMB_GetSearchPos
//			Return position of current search result
// Parameters:
//			page		-	Page handle.
// Return Value:
//			Zero based character index for the current search result. -1 if not found.
//
int FPDFEMB_GetSearchPos(FPDFEMB_PAGE page);

// Function: FPDFEMB_QuickSearch
//			Search a pattern in a page quickly, without the page to be parsed
// Parameters:
//			document	-	Document handle returned by FPDFEMB_StartLoadDocument function
//			page_index	-	Zero-based index of the page
//			pattern		-	A zero-terminated unicode string to be found.
//			case_sensitive	-	Non-zero for case-sensitive searching, zero for case-insensitive
// Return Value:
//			FPDFERR_SUCCESS if pattern found, FPDFERR_NOTFOUND if pattern not found.
//			Otherwise error code is returned.
// Comments:
//			This function does a rough and quick search in a page, before the page is loaded.
//			The quick search will not generate an exact result saying where the pattern is
//			found, and, it might be possible if a quick search result is "pattern found", and
//			a real search for the same pattern, in the same page, will result in "not found".
//
//			However, if quick search doesn't find a pattern in a page, then we can be sure the
//			pattern won't be found in this page when we do a real search. So, this function is
//			very useful when we search in a multiple-page document, and we want to quickly skip
//			those pages in which the pattern can't possibly be found.
//
FPDFEMB_RESULT FPDFEMB_QuickSearch(FPDFEMB_DOCUMENT document, int page_index,
								   const FPDFEMB_WCHAR* pattern, int case_sensitive);

/********************************************************************************************
****
****		Text Information
****
********************************************************************************************/

// Function: FPDFEMB_GetCharCount
//			Get number of characters in the page
// Parameters:
//			page		-	Page handle
//			count		-	Receiving number of characters
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_GetCharCount(FPDFEMB_PAGE page, int* count);

// Structure: FPDFEMB_CHAR_INFO
//			Character information.
struct FPDFEMB_CHAR_INFO {
	int		unicode;		// Unicode for the character. 0 if not available.
							// Space and new line charcters (U+0020 and U+000A) may be generated
							// according to the text formatting.
	FPDFEMB_POINT	origin;	// X/Y position for the character origin, in hundredth of points
	FPDFEMB_RECT	bbox;	// Bounding box of the character, in hundredth of points
							// Maybe an empty box (left == right or top == bottom).
};

// Function: FPDFEMB_GetCharInfo
//			Get character information
// Parameters:
//			page		-	Page handle
//			index		-	Character index, starting from zero
//			char_info	-	Receiving the character info
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			Application must call FPDFEMB_GetCharCount first before it can call this function
//			for any particular characters.
//
FPDFEMB_RESULT FPDFEMB_GetCharInfo(FPDFEMB_PAGE page, int index, FPDFEMB_CHAR_INFO* char_info);

// Function: FPDFEMB_GetCharIndexAtPos()
//			Get index of character nearest to a certain position on the page
// Parameters:
//			page		-	Page handle
//			x			-	X position in PDF page coordination system
//			y			-	Y position in PDF page coordination system
//			index		-	Pointer to an integer receiving zero-based character index.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			This function finds the character that's nearest to the particular page position.
//			If there is no character, the output index will be -1.
//
FPDFEMB_RESULT FPDFEMB_GetCharIndexAtPos(FPDFEMB_PAGE page, double x, double y, int* index);

/********************************************************************************************
****
****		Device Independant Bitmap
****
********************************************************************************************/

#define FPDFDIB_BGR		1	// 3 bytes per pixel, byte order: Blue, Green, Red
#define FPDFDIB_BGRx	2	// 4 bytes per pixel, byte order: Blue, Green, Red, not used
#define FPDFDIB_BGRA	3	// 4 bytes per pixel, byte order: Blue, Green, Red, Alpha
#define FPDFDIB_GRAY	4	// 1 byte per pixel (grayscale)

// Function: FPDFEMB_CreateDIB
//			Create a DIB (Device Independant Bitmap)
// Parameters:
//			width		-	Width pixels;
//			height		-	Height pixels;
//			format		-	Format type. See FPDFDIB_xxx constants
//			buffer		-	External buffer provided for the DIB,
//							or NULL if new buffer is to be allocated.
//			stride		-	Number of bytes for each scan line, for external buffer only.
//							If not specified, 4-byte alignment assumed.
//			dib			-	Receiving the created DIB handle
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			If "buffer" parameter is not NULL, then the provided buffer must conform
//			to standard DIB format (see comments of FPDFEMB_GetDIBData function below).
//
//			This function doesn't initialize the pixels inside the DIB buffer. So if you
//			want to use the DIB to display a PDF page, you usually need to initialize
//			the DIB to white background by youself.
//
FPDFEMB_RESULT FPDFEMB_CreateDIB(int width, int height, int format,
									   void* buffer, int stride, FPDFEMB_BITMAP* dib);

// Function: FPDFEMB_DestroyDIB
//			Destroy a DIB
// Parameters:
//			dib			-	DIB handle
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			If external buffer is used (specified in "buffer" parameter when calling
//			FPDFEMB_CreateDIB), the buffer will not be destroyed.
//
FPDFEMB_RESULT FPDFEMB_DestroyDIB(FPDFEMB_BITMAP dib);

// Function: FPDFEMB_GetDIBWidth
//			Get width (in pixels) of a DIB
// Parameters:
//			dib			-	DIB handle
// Return Value:
//			DIB width in pixels.
//
int FPDFEMB_GetDIBWidth(FPDFEMB_BITMAP dib);

// Function: FPDFEMB_GetDIBHeight
//			Get height (in pixels) of a DIB
// Parameters:
//			dib			-	DIB handle
// Return Value:
//			DIB height in pixels.
//
int FPDFEMB_GetDIBHeight(FPDFEMB_BITMAP dib);

// Function: FPDFEMB_GetDIBData
//			Get data pointer to a DIB
// Parameters:
//			dib			-	DIB handle
// Return Value:
//			Pointer to the DIB data.
// Comments:
//			DIB data are organized in scanlines, from top down.
//
void* FPDFEMB_GetDIBData(FPDFEMB_BITMAP dib);

// Function: FPDFEMB_GetDIBStride
//			Get scan line stride of a DIB
// Parameters:
//			dib			-	DIB handle
// Return Value:
//			Number of bytes occupied by a scanline
//
int FPDFEMB_GetDIBStride(FPDFEMB_BITMAP dib);

// Function: FPDFEMB_GetRotatedDIB
//			Swap X/Y dimensions of a DIB to generate a rotated new DIB
// Parameters:
//			dib			-	DIB handle
//			flip_x		-	Whether flip pixels on the destination X dimension (left/right)
//			flip_y		-	Whether flip pixels on the destination Y dimension (up/down)
//			result_dib	-	Receiving the result DIB handle
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
//
FPDFEMB_RESULT FPDFEMB_GetRotatedDIB(FPDFEMB_BITMAP dib,
									 FPDFEMB_BOOL bFlipX, FPDFEMB_BOOL bFlipY,
									 FPDFEMB_BITMAP* result_dib);

// Function: FPDFEMB_StretchDIB
//			Stretch a source DIB into another destination DIB
// Parameters:
//			dest_dib	-	The destination DIB handle
//			dest_left	-	Left position in the destination DIB
//			dest_top	-	Top position in the destination DIB
//			dest_width	-	Destination width, in pixels. Can be negative for horizontal flipping
//			dest_height	-	Destination height, in pixels. Can be negative for vertical flipping
//			clip		-	Destination clipping rectangle, or NULL for no clipping.
//							The coordinations are measured in destination bitmap.
//			src_dib		-	Source DIB handle.
//			interpol	-	Whether we use interpolation to improve the result quality
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
//
FPDFEMB_RESULT FPDFEMB_StretchDIB(FPDFEMB_BITMAP dest_dib, int dest_left, int dest_top,
								  int dest_width, int dest_height, FPDFEMB_RECT* clip_rect,
								  FPDFEMB_BITMAP src_dib, FPDFEMB_BOOL interpol);

// Function: FPDFEMB_TransformDIB
//			Transform a source DIB into another destination DIB
// Parameters:
//			dest_dib	-	The destination DIB handle
//			clip		-	Destination clipping rectangle, or NULL for no clipping.
//							The coordinations are measured in destination bitmap.
//			src_dib		-	Source DIB handle.
//			x			-	X coordination of the dest origin
//			y			-	Y coordination of the dest origin
//			xx			-	X distance of the dest X vector
//			yx			-	Y distance of the dest X vector
//			xy			-	X distance of the dest Y vector
//			yy			-	Y distance of the dest Y vector
//			interpol	-	Whether we use interpolation to improve the result quality
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			All coordinations and distances are measured in destination bitmap system.
//
//			This function places the bottom-left pixel of the image at the destination
//			origin, then the bottom sideline along the destination X vector, and left
//			sideline along the destination Y vector.
//
FPDFEMB_RESULT FPDFEMB_TransformDIB(FPDFEMB_BITMAP dest_dib, FPDFEMB_RECT* clip_rect,
								  FPDFEMB_BITMAP src_dib, int x, int y, int xx, int yx,
								  int xy, int yy, FPDFEMB_BOOL interpol);

/********************************************************************************************
****
****		Custom Font Handler and CJK Support
****
********************************************************************************************/

// FPDFEMB comes with standard fonts for Latin characters. If your device is targeted to
// Eastern Asian markets, then system fonts must be provided and registered with FPDFEMB.
// Depending on your device configuration, those system fonts might be in TrueType or Type1
// format, or some other non-standard compact format. For the first case, you should register
// a font mapper so FPDFEMB can pick the right font file, and for the second case, you
// should register a glyph provider so FPDFEMB can get glyph bitmap for each character.

#define FPDFEMB_CHARSET_DEFAULT		0
#define FPDFEMB_CHARSET_GB			936
#define FPDFEMB_CHARSET_BIG5		950
#define FPDFEMB_CHARSET_JIS			932
#define FPDFEMB_CHARSET_KOREA		949
#define FPDFEMB_CHARSET_UNICODE		1200

#define FPDFEMB_FONT_FIXEDPITCH		1
#define FPDFEMB_FONT_SERIF			2
#define FPDFEMB_FONT_SYMBOLIC		4
#define FPDFEMB_FONT_SCRIPT			8
#define FPDFEMB_FONT_NONSYMBOLIC	32
#define FPDFEMB_FONT_ITALIC			64
#define FPDFEMB_FONT_ALLCAP			0x10000
#define FPDFEMB_FONT_SMALLCAP		0x20000
#define FPDFEMB_FONT_FORCEBOLD		0x40000

// Structure: FPDFEMB_FONT_MAPPER
//			Defines interface for system font mapper.
//
struct FPDFEMB_FONT_MAPPER
{
	// Interface: MapFont
	//		Find font file path for a particular PDF font
	// Parameters:
	//		mapper		-	Pointer to the FPDFEMB_FONT_MAPPER structure
	//		name		-	Font name
	//		charset		-	Charset ID (see above FPDFEMB_CHARSET_xxx constants)
	//		flags		-	Font flags (see above FPDFEMB_FONT_xxx constants)
	//		weight		-	Weight of the font. Range from 100 to 900. 400 is normal,
	//						700 is bold.
	//		path		-	Receiving the full file path. The buffer size is 512 bytes.
	//		face_index	-	Receiving an zero-based index value for the font face, if the
	//						mapped font file is a "collection" (meaning a number of faces
	//						are stored in the same file). If the font file is not a
	//						collection, the index value should be zero.
	// Return Value:
	//		Non-zero for success, 0 for failure.
	//
	FPDFEMB_BOOL	(*MapFont)(struct FPDFEMB_FONT_MAPPER* mapper, const char* name, int charset,
									unsigned int flags,	int weight,
									char* path, int* face_index);

	void*		user;		// A user pointer, used by the application
};

// Function: FPDFEMB_SetFontMapper
//			Use a system font mapper (typically for Chinese/Japanese/Korean charsets)
// Parameters:
//			mapper		-	Pointer to FPDFEMB_FONT_MAPPER structure.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			This function is used with devices that come with one or more system fonts,
//			and those fonts are in standard TT or T1 format.
//
FPDFEMB_RESULT FPDFEMB_SetFontMapper(FPDFEMB_FONT_MAPPER* mapper);

// Structure: FPDFEMB_GLYPH_PROVIDER
//			Interface for providing glyph bitmap of non-latin characters.
//			This is usually used for embedded devices with Chinese/Japanese/Korean
//			fonts installed, but those fonts are not in TrueType or Type1 format.
//
struct FPDFEMB_GLYPH_PROVIDER
{
	// Interface: MapFont
	//		Return an internal handle for a font
	// Parameters:
	//		provider	-	Pointer to this structure
	//		name		-	Font name
	//		charset		-	Charset ID (see above FPDFEMB_CHARSET_xxx constants)
	//		flags		-	Font flags (see above FPDFEMB_FONT_xxx constants)
	//		weight		-	Weight of the font. Range from 100 to 900. 400 is normal,
	//						700 is bold.
	// Return Value:
	//		An internal handle to the mapped font. If the embedded device supports
	//		multiple fonts, then this value can serve as an identifier to differentiate
	//		among them. If the device supports only one font, then implementation of
	//		this function can simply return NULL.
	//
	void*	(*MapFont)(struct FPDFEMB_GLYPH_PROVIDER* provider, const char* name, int charset,
									unsigned int flags,	int weight);
	// Interface: GetGlyphBBox
	//		Get glyph bounding box
	// Parameters:
	//		provider	-	Pointer to this structure
	//		font		-	Internal handle to the font. Returned by MapFont interface.
	//		unicode		-	Unicode of the character
	//		CID			-	Adobe CID for this character. Or zero if not available.
	//		bbox		-	Receiving the result bounding box. See comments below.
	// Return Value:
	//		None.
	// Comments:
	//		The bounding box is measure in a glyph coordination system, in which the
	//		origin is set to character origin, and unit is set to one-thousandth of
	//		"em size" (representing the font size).
	//
	//		In most CJK fonts, all CJK characters (except some symbols or western
	//		characters) have same glyph bounding box:
	//		left = 0, right = 1000, bottom = -220, top = 780.
	//
	//		It's OK to return a box that's larger than the actual glyph box.
	//
	void	(*GetGlyphBBox)(struct FPDFEMB_GLYPH_PROVIDER* provider, void* font,
									FPDFEMB_WCHAR unicode, unsigned short CID,
									FPDFEMB_RECT* bbox);

	// Interface: GetGlyphBitmap
	//		Get bitmap of a glyph
	// Parameters:
	//		provider	-	Pointer to this structure
	//		font		-	Internal handle to the font. Returned by MapFont interface.
	//		unicode		-	Unicode of the character
	//		CID			-	Adobe CID for this character. Or zero if not available.
	//		font_width	-	Width of the font em square, measured in device units.
	//		font_height	-	Height of the font em square, measured in device units.
	//		left		-	Receiving the left offset, from the character origin, of the
	//						result glyph bitmap. Positive value will move the bitmap to
	//						the right side, negative to the left.
	//		top			-	Receiving the top offset, from the character origin, of the
	//						result glyph bitmap. Positive value will move the bitmap upward,
	//						negative downward.
	//		bitmap_width -	Receiving number of width pixels in the result bitmap
	//		bitmap_height -	Receiving number of height pixels in the result bitmap
	//		buffer		-	Receiving a data buffer pointer, allocated by the implementation.
	//						See comments below.
	//		stride		-	Receiving number of bytes per scanline, in the data buffer.
	//		pdf_width	-	Width of the character specified in PDF. It is measured in one-
	//						thousandth of the font width. It can be 0 if width not specified
	//						in PDF. See comments below.
	// Return Value:
	//		Non-zero for success. 0 for failure. In this case the glyph can not be displayed.
	// Comments:
	//		The buffer should be allocated by implemenation. And it must be allocated
	//		using FPDFEMB_AllocMemory function. The result buffer will be destroyed by
	//		FPDFEMB SDK, so implementation should not destroy it.
	//
	//		The implementation should write "coverage" data into allocated buffer, one byte
	//		for each pixel, from top scanline to bottom scanline, within each scan line,
	//		from left pixel to right. Coverage 0 means the pixel is outside the glyph,
	//		coverage 255 means the pixel is inside the glyph.
	//
	//		The "pdf_width" parameter can be used to scale the character in system font
	//		horizontally to match the font width specified in PDF. For example, if we have
	//		a PDF file which requires a character in half-width (pdf_width is 500), but
	//		in the system font the character has full-width (1000), then the glyph provider
	//		implementation should scale the font horizontally to half of its original width.
	//
	FPDFEMB_BOOL (*GetGlyphBitmap)(struct FPDFEMB_GLYPH_PROVIDER* provider, void* font,
									FPDFEMB_WCHAR unicode, unsigned short CID,
									double font_width, double font_height, int* left, int* top,
									int* bitmap_width, int* bitmap_height,
									void** buffer, int* stride, int pdf_width);

	void*		user;		// A user pointer, used by the application
};

// Function: FPDFEMB_SetGlyphProvider
//			Make use of a glyph provider: generating glyph bitmap for non-Latin characters
// Parameters:
//			provider	-	Pointer to the glyph provider structure.
//							This structure must stay valid throughout usage of FPDFEMB module.
// Return Value:
//			None.
// Comments:
//			FPDFEMB embeds some standard fonts for Latin characters and symbols, like
//			Times, Courier and Helvetica (Arial). For non-Latin characters, however,
//			FPDFEMB has to ask glyph provide for help.
//
//			If an embedded device carries fonts for non-Latin character sets, especially
//			those for CJK markets, then the application can implement a glyph provider,
//			allowing PDFs using non-embedded CJK fonts to be properly displayed.
//
void FPDFEMB_SetGlyphProvider(FPDFEMB_GLYPH_PROVIDER* provider);

// Function: FPDFEMB_LoadCMap_GB
// Function: FPDFEMB_LoadCMap_GB_Ext
// Function: FPDFEMB_LoadCMap_CNS
// Function: FPDFEMB_LoadCMap_Korean
// Function: FPDFEMB_LoadCMap_Japan
// Function: FPDFEMB_LoadCMap_Japan_Ext
//			Make use of character encoding maps embedded with FPDFEMB
// Parameters:
//			None.
// Return Value:
//			None.
// Comments:
//			These functions add character encoding data to your application. Each call
//			will increase the code size of your application. Total data size for all
//			character sets is 151K bytes.
void FPDFEMB_LoadCMap_GB();
void FPDFEMB_LoadCMap_GB_Ext();		// Load full code table for GB
void FPDFEMB_LoadCMap_CNS();
void FPDFEMB_LoadCMap_Korea();
void FPDFEMB_LoadCMap_Japan();
void FPDFEMB_LoadCMap_Japan_Ext();	// Load full code table for Japan

/********************************************************************************************
****
****		Document Information
****
********************************************************************************************/

// Function: PDFEMB_GetDocInfoString
//			Get information string about the document, like creator, modifcation date, etc.
// Parameters:
//			document	-	Handle to the document
//			key			-	A byte string for the information key. Currently can be one of the followings:
//							"Title", "Author", "Subject", "Keywords", "Creator", "Producer", "CreationDate",
//							"ModDate", or some custom information key, if supported by the PDF file.
//			buffer		-	A buffer allocated by the application, or NULL.
//			bufsize		-	[IN/OUT] A pointer to a number indicating the buffer size (number of bytes),
//							before this function call. After return, this place will store
//							number of bytes used by the output (including terminator).
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			The string is output in Unicode, using UTF-16LE format. It's terminated by
//			two consecutive zero bytes.
//
//			If the "buffer" parameter is NULL, then the "bufsize" parameter will receive
//			number of bytes required to store the string (including the two-byte terminator).
//
FPDFEMB_RESULT FPDFEMB_GetDocInfoString(FPDFEMB_DOCUMENT document, const char* key, void* buffer, unsigned int* bufsize);

/********************************************************************************************
****
****		Action (Destination) Information
****
********************************************************************************************/

typedef void* FPDFEMB_ACTION;

// Action types supported by FPDFEMB
#define FPDFEMB_DEST_NONE			0		// No or unsupported destination
#define FPDFEMB_DEST_PAGE			1		// A page inside the same document
#define FPDFEMB_DEST_DOC			2		// An external PDF document
#define FPDFEMB_DEST_URL			3		// An external URL
#define FPDFEMB_ACTION_LAUNCH		4		// Launch an external file or command

// Zoom mode for destination
#define FPDFEMB_ZOOM_NONE			0		// Zoom mode not specified
#define FPDFEMB_ZOOM_FACTOR			1		// Specific zoom factor is used
#define FPDFEMB_ZOOM_FITPAGE		2		// Fit the whole page on screen
#define FPDFEMB_ZOOM_FITWIDTH		3		// Fit width of the page on screen
#define FPDFEMB_ZOOM_FITHEIGHT		4		// Fit height of the page on screen
#define FPDFEMB_ZOOM_FITRECT		5		// Fit a particular rectangle on screen
#define FPDFEMB_ZOOM_FITCONTENT		6		// Fit whole content of page on screen
#define FPDFEMB_ZOOM_FITCONTENTW	7		// Fit content width of page on screen
#define FPDFEMB_ZOOM_FITCONTENTH	8		// Fit content height of page on screen

// Data structure for page destination
struct FPDFEMB_PAGEDEST
{
	int				page_index;		// Zero based index for the page
	int				zoom_mode;		// See FPDFEMB_ZOOM_xxx definition above
	int				zoom_factor;	// For FPDFEMB_ZOOM_FACTOR only: the zoom factor (in percentage)
	FPDFEMB_RECT	position;		// Specify position inside the page. Depends on the zoom mode,
									// different members of the rectangle are used:
									// FPDFEMB_ZOOM_NONE:			left, top
									// FPDFEMB_ZOOM_FACTOR:			left, top
									// FPDFEMB_ZOOM_FITPAGE:		none
									// FPDFEMB_ZOOM_FITWIDTH:		top
									// FPDFEMB_ZOOM_FITHEIGHT:		left
									// FPDFEMB_ZOOM_FITRECT:		left, top, bottom, right
									// FPDFEMB_ZOOM_FITCONTENT:		none
									// FPDFEMB_ZOOM_FITCONTENTW:	top
									// FPDFEMB_ZOOM_FITCONTENTH:	left
};

// Data structure for document destination
struct FPDFEMB_DOCDEST
{
	FPDFEMB_PAGEDEST	page_data;	// page data
	char*				file_name;	// The file name, encoded in original charset (maybe MBCS)
};

// Data structure for URL destination
struct FPDFEMB_URLDEST
{
	char*				url;		// URL encoded in 7-bit ASCII
};

// Data structure for Launch action
struct FPDFEMB_LAUNCHACTION
{
	int					new_window;	// Whether a new window should be opened
	char*				file_name;	// The file name, encoded in original charset (maybe MBCS)
};

// Function: FPDFEMB_Action_GetType
//			Get type of an action
// Parameters:
//			document	-	Handle to the document
//			action		-	Handle to the action
//			dest_type	-	Pointer to an integer receiving type of the destination. See the above
//							FPDFEMB_DEST_xxx definitions
//			data_size	-	Pointer to an integer receiving data block size for the destination.
//							If this parameter is NULL, then data size won't be retrieved.
// Comments:
//			Each different type of destination has different data structure. The "data_size" result
//			indicates how many bytes is required to hold the destination data structure. The application
//			can then allocate sufficient buffer and then call FPDFEMB_Bookmark_GetDest function to
//			get the real data.
//
FPDFEMB_RESULT FPDFEMB_Action_GetType(FPDFEMB_DOCUMENT document, FPDFEMB_ACTION action, int* dest_type, int* data_size);

// Function: FPDFEMB_Action_GetData
//			Get detailed data of a particular action
// Parameters:
//			document	-	Handle to the document
//			action		-	Handle to the action
//			buffer		-	Application allocated buffer receiving the destination data
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			See data structure definition for different action type above. Please note
//			the actual action data might use more space than the structure definition
//			shows, to store things like file name or URL. So you should always call
//			FPDFEMB_Action_GetType first to get data size then allocate enough buffer
//			for this call.
//
FPDFEMB_RESULT FPDFEMB_Action_GetData(FPDFEMB_DOCUMENT document, FPDFEMB_ACTION action, void* buffer);

// Function: FPDFEMB_Action_GetNext
//			Get next action in an action chain
// Parameters:
//			document	-	Handle to the document
//			action		-	Handle to current action
//			next		-	Receiving handle to next action.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			If there is no next action, the "next" parameter will be set to NULL after the function returns.
//
FPDFEMB_RESULT FPDFEMB_Action_GetNext(FPDFEMB_ACTION action, FPDFEMB_ACTION* next);

/********************************************************************************************
****
****		Bookmark Information
****
********************************************************************************************/

typedef void* FPDFEMB_BOOKMARK;

// Function: FPDFEMB_Bookmark_GetFirstChild
//			Get first child of a bookmark item, or first top level bookmark item
// Parameters:
//			document	-	Handle to the document
//			parent		-	Handle to the parent bookmark.
//							Can be NULL if you want to get the first top level item.
//			bookmark	-	Receiving handle to the first child or top level bookmark item.
//							If result is NULL, then bookmark not found.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
//
FPDFEMB_RESULT FPDFEMB_Bookmark_GetFirstChild(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK parent,
											  FPDFEMB_BOOKMARK* bookmark);

// Function: FPDFEMB_Bookmark_GetFirstChild
//			Get next sibling of a bookmark item
// Parameters:
//			document	-	Handle to the document
//			bookmark	-	Handle to the bookmark
//			sibling		-	Receiving the handle of next sibling.
//							If result is NULL, then this is the last bookmark in this level.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
//
FPDFEMB_RESULT FPDFEMB_Bookmark_GetNextSibling(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark,
											  FPDFEMB_BOOKMARK* sibling);

// Function: FPDFEMB_Bookmark_GetTitle
//			Get title of a bookmark
// Parameters:
//			bookmark	-	Handle to the bookmark
//			buffer		-	A buffer allocated by the application, or NULL.
//			bufsize		-	[IN/OUT] A pointer to a number indicating the buffer size,
//							before this function call. After return, this place will store
//							number of bytes used by the output (including terminator).
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			The title is output in Unicode, using UTF-16LE format. It's terminated by
//			two consecutive zero bytes.
//
//			If the "buffer" parameter is NULL, then the "bufsize" parameter will receive
//			number of bytes required to store the bookmark title (including the two-
//			byte terminator).
//
//			If the buffer provided is smaller than the required size, then this function
//			will not copy any data, return FPDFEMB_PARAM, and the required buffer size will
//			also be put in "bufsize" parameter.
//
FPDFEMB_RESULT FPDFEMB_Bookmark_GetTitle(FPDFEMB_BOOKMARK bookmark, void* buffer, unsigned int* bufsize);

// Function: FPDFEMB_Bookmark_GetPage
//			Get page number of a bookmark pointing to
// Parameters:
//			document	-	Handle to the document
//			bookmark	-	Handle to the bookmark
//			page		-	Receiving the page number. -1 if this bookmark doesn't actually
//							point to a page inside the document.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success
// Comments:
//			Some bookmark might not point to a page, some bookmark might have more than one destination
//			(action), for detailed information about a bookmark, you should call FPDFEMB_Bookmark_GetAction.
//
FPDFEMB_RESULT FPDFEMB_Bookmark_GetPage(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark, int* page);

// Function: FPDFEMB_Bookmark_GetAction
//			Get action(s) associated with a particular bookmark
// Parameters:
//			document	-	Handle to the document
//			bookmark	-	Handle to the bookmark
//			action		-	Receiving handle of first action
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_Bookmark_GetAction(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark, FPDFEMB_ACTION* action);

/********************************************************************************************
****
****		Hyperlink Information
****
********************************************************************************************/

// Function: FPDFEMB_Link_GetCount
//			Get number of hyperlinks inside a page
// Parameters:
//			page		-	Page handle.
//			link_count	-	Pointer to an integer receiving the number of links
//			reserved	-	Must be zero now.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			This function must be called before any other link related function can
//			be called for the page.
//
FPDFEMB_RESULT FPDFEMB_Link_GetCount(FPDFEMB_PAGE page, int* link_count, int reserved);

// Function: FPDFEMB_Link_GetAction
//			Get action(s) associated with a particular hyperlink
// Parameters:
//			page		-	Page handle
//			link_index	-	Zero-based index for the link
//			action		-	Receiving handle of first action
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_Link_GetAction(FPDFEMB_PAGE page, int link_index, FPDFEMB_ACTION* action);

// Function: FPDFEMB_Link_GetAreaCount
//			Get number of area (quadrilaterals) for a link
// Parameters:
//			page		-	Page handle
//			link_index	-	Zero-based index for the link
//			count		-	Pointer to an integer receiving number of quadrilaterals
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_Link_GetAreaCount(FPDFEMB_PAGE page, int link_index, int* count);

// Function: FPDFEMB_Link_GetArea
//			Get a particular quadrilateral for a link
// Parameters:
//			page		-	Page handle
//			link_index	-	Zero-based index for the link
//			area_index	-	Zero-based index for the quadrilateral
//			points		-	Pointer to an array consists 4 points, receiving coordinations
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			The result in "points" array are the X/Y coordinations for the four vertices
//			of the quadrilateral. Vertices are in the following order: lower left, lower
//			right, upper right, upper left.
//
FPDFEMB_RESULT FPDFEMB_Link_GetArea(FPDFEMB_PAGE page, int link_index, int area_index,
									FPDFEMB_POINT* points);

/********************************************************************************************
****
****		Graphic Output (onto DIB)
****
********************************************************************************************/

typedef void* FPDFEMB_FONT;

// Function: FPDFEMB_OpenStandardFont
//			Get ready to use a standard PDF font
// Parameters:
//			font_name	-	Name of the font. See a list of supported fonts below.
//			font_handle	-	Receiving the font handle.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			Currently supported standard fonts:
//			Courier, Courier-Bold, Courier-BoldOblique, Courier-Oblique,
//			Helvetica, Helvetica-Bold, Helvetica-BoldOblique, Helvetica-Oblique,
//			Times-Roman, Times-Bold, Times-Italic, Times-BoldItalic,
//			Symbol, ZapfDingbats.
//
FPDFEMB_RESULT FPDFEMB_OpenStandardFont(const char* font_name, FPDFEMB_FONT* font_handle);

// Function: FPDFEMB_OpenSystemFont
//			Get ready to use a system font
// Parameters:
//			font_name	-	Font name
//			charset		-	Charset ID (see above FPDFEMB_CHARSET_xxx constants)
//			flags		-	Font flags (see above FPDFEMB_FONT_xxx constants)
//			weight		-	Weight of the font. Range from 100 to 900. 400 is normal,
//							700 is bold.
//			font_handle	-	Receiving the font handle.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
// Comments:
//			System font is supported only if either FPDFEMB_SetFontMapper or
//			FPDFEMB_SetGlyphProvider is called.
//			Font attributes (name, charset, flags and weight) can be all optional, if the
//			font mapper or glyph provider doesn't make use of them.
//
FPDFEMB_RESULT FPDFEMB_OpenSystemFont(const char* font_name, int charset, unsigned int flags, int weight,
									  FPDFEMB_FONT* font_handle);

// Function: FPDFEMB_CloseFont
//			Close a font handle.
// Parameters:
//			font_handle	-	Handle to the font.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_CloseFont(FPDFEMB_FONT font_handle);

struct FPDFEMB_TEXTMATRIX
{
	double	a, b, c, d;
};

// Function: FPDFEMB_OutputText
//			Output text string onto a DIB device.
// Parameters:
//			dib			-	DIB handle, as the output device
//			x, y		-	DIB coordinations for the origin point of the first character.
//			font_handle	-	Handle to the font
//			font_size	-	Font size in pixels
//			matrix		-	Matrix for the text output. Can be NULL.
//			text		-	Zero-terminated unicode text string
//			argb		-	Color of the text, in 0xaarrggbb format.
// Return Value:
//			Error code, or FPDFERR_SUCCESS for success.
//
FPDFEMB_RESULT FPDFEMB_OutputText(FPDFEMB_BITMAP dib, int x, int y, FPDFEMB_FONT font_handle, double font_size,
								  FPDFEMB_TEXTMATRIX* matrix, const FPDFEMB_WCHAR* text, unsigned long argb);

#ifdef __cplusplus
};
#endif

#endif	// #ifdef _FPDFEMB_H_


code:
#ifdef __cplusplus
extern "C" {
#endif

/** Extended interfaces for JPEG, JPEG2000 and JBIG2 decoders **/
typedef struct
{
	/** Initialize the decoding context, with memory allocator provided by FPDFEMB.
	   Implementation should return a pointer to the decoding context.
	*/
	void*	(*Init)(void* (*alloc_func)(unsigned int), void (*free_func)(void*));

	/** Finish with the decoding. */
	void	(*Finish)(void* pContext);

	/** Input JPEG encoded data from the source.
		This function may be called multiple times during decoding progress.
	*/
	void	(*Input)(void* pContext, const unsigned char* src_buf, unsigned long src_size);

	/** Read the header information. Return non-zero for success, 0 for failure */
	int		(*ReadHeader)(void* pContext);

	/** Get info from the decoder, including image width, height and number of components */
	void	(*GetInfo)(void* pContext, int* width, int* height, int* nComps);

	/** Read one scanline from decoded image */
	int		(*ReadScanline)(void* pContext, unsigned char* dest_buf);

	/** Get number of available source bytes left in the input stream */
	unsigned long	(*GetAvailInput)(void* pContext);
} FPDFEMB_JPEG_DECODER;

void FPDFEMB_SetJpegDecoder(FPDFEMB_JPEG_DECODER* pDecoder);

typedef struct
{
	/** Initialize the decoder with the full source data.
		Implementation should return a pointer to the context.
	*/
	void*	(*Init)(const unsigned char* src_buf, unsigned long src_size);

	/** Destroy the context */
	void	(*Finish)(void* context);

	/** Get image info from the context, including width, height, number of components
		in original codestream, and number of components in output image. For some
		particular type of encoded image, like paletted image, these two numbers of
		components may vary.
	*/
	void	(*GetInfo)(void* context, unsigned long* width, unsigned long* height,
				unsigned long* codestream_nComps, unsigned long* output_nComps);

	/** Do the real data decoding, output to a pre-allocated buffer.
		bTranslateColor indicates whether the decoder should use JPEG2000 embedded
		color space info to translate image into sRGB color space.
		"offsets" array describes the byte order of all components. For example,
		{2,1,0} means the first components is output to last byte.
	*/
	void	(*Decode)(void* context, unsigned char* dest_buf, int pitch,
				int bTranslateColor, unsigned char* offsets);
} FPDFEMB_JPEG2000_DECODER;

void FPDFEMB_SetJpeg2000Decoder(FPDFEMB_JPEG2000_DECODER* pDecoder);

typedef struct
{
	/** Do the whole decoding process. Supplied parameters include width, height, source image
		data and size, global data and size (can be shared among different images), destination
		buffer and scanline pitch in dest buffer.
	*/
	void	(*Decode)(unsigned long width, unsigned long height, const unsigned char* src_buf,
				unsigned long src_size, const unsigned char* global_buf, unsigned long global_size,
				unsigned char* dest_buf, int dest_pitch);
} FPDFEMB_JBIG2_DECODER;

void FPDFEMB_SetJbig2Decoder(FPDFEMB_JBIG2_DECODER* pDecoder);

#ifdef __cplusplus
};
#endif

license: mit


code:
#ifndef skiagm_DEFINED
#define skiagm_DEFINED

#include "SkCanvas.h"
#include "SkPaint.h"
#include "SkRefCnt.h"
#include "SkSize.h"
#include "SkString.h"
#include "SkTRegistry.h"

namespace skiagm {

	static inline SkISize make_isize(int w, int h) {
		SkISize sz;
		sz.set(w, h);
		return sz;
	}

    class GM {
    public:
        GM();
        virtual ~GM();

		void draw(SkCanvas*);
		SkISize getISize() { return this->onISize(); }
        const char* shortName() {
            if (fShortName.size() == 0) {
                fShortName = this->onShortName();
            }
            return fShortName.c_str();
        }

	protected:
		virtual void onDraw(SkCanvas*) = 0;
		virtual SkISize onISize() = 0;
        virtual SkString onShortName() = 0;

    private:
        SkString fShortName;
    };

    typedef SkTRegistry<GM*, void*> GMRegistry;
}

#endif


code:
/*
 * This module converts keysym values into the corresponding ISO 10646-1
 * (UCS, Unicode) values.
 */

#include <X11/X.h>

long keysym2ucs(KeySym keysym);


code:
#ifndef sk_stdint_DEFINED
#define sk_stdint_DEFINED

typedef signed char int8_t;
typedef unsigned char   uint8_t;
typedef short  int16_t;
typedef unsigned short  uint16_t;
typedef int  int32_t;
typedef unsigned   uint32_t;
typedef long long  int64_t;
typedef unsigned long long   uint64_t;

#endif


code:
/* -*- mode: c; tab-width: 8; -*- */
/* vi: set sw=4 ts=8: */
/* Reference version of egl.h for EGL 1.4.
 */

/*
** Copyright (c) 2007-2009 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/

#ifndef __egl_h_
#define __egl_h_

/* All platform-dependent types and macro boilerplate (such as EGLAPI
 * and EGLAPIENTRY) should go in eglplatform.h.
 */
#include <EGL/eglplatform.h>

#ifdef __cplusplus
extern "C" {
#endif

/* EGL Types */
/* EGLint is defined in eglplatform.h */
typedef unsigned int EGLBoolean;
typedef unsigned int EGLenum;
typedef void *EGLConfig;
typedef void *EGLContext;
typedef void *EGLDisplay;
typedef void *EGLSurface;
typedef void *EGLClientBuffer;

/* EGL Versioning */
#define EGL_VERSION_1_0			1
#define EGL_VERSION_1_1			1
#define EGL_VERSION_1_2			1
#define EGL_VERSION_1_3			1
#define EGL_VERSION_1_4			1

/* EGL Enumerants. Bitmasks and other exceptional cases aside, most
 * enums are assigned unique values starting at 0x3000.
 */

/* EGL aliases */
#define EGL_FALSE			0
#define EGL_TRUE			1

/* Out-of-band handle values */
#define EGL_DEFAULT_DISPLAY		((EGLNativeDisplayType)0)
#define EGL_NO_CONTEXT			((EGLContext)0)
#define EGL_NO_DISPLAY			((EGLDisplay)0)
#define EGL_NO_SURFACE			((EGLSurface)0)

/* Out-of-band attribute value */
#define EGL_DONT_CARE			((EGLint)-1)

/* Errors / GetError return values */
#define EGL_SUCCESS			0x3000
#define EGL_NOT_INITIALIZED		0x3001
#define EGL_BAD_ACCESS			0x3002
#define EGL_BAD_ALLOC			0x3003
#define EGL_BAD_ATTRIBUTE		0x3004
#define EGL_BAD_CONFIG			0x3005
#define EGL_BAD_CONTEXT			0x3006
#define EGL_BAD_CURRENT_SURFACE		0x3007
#define EGL_BAD_DISPLAY			0x3008
#define EGL_BAD_MATCH			0x3009
#define EGL_BAD_NATIVE_PIXMAP		0x300A
#define EGL_BAD_NATIVE_WINDOW		0x300B
#define EGL_BAD_PARAMETER		0x300C
#define EGL_BAD_SURFACE			0x300D
#define EGL_CONTEXT_LOST		0x300E	/* EGL 1.1 - IMG_power_management */

/* Reserved 0x300F-0x301F for additional errors */

/* Config attributes */
#define EGL_BUFFER_SIZE			0x3020
#define EGL_ALPHA_SIZE			0x3021
#define EGL_BLUE_SIZE			0x3022
#define EGL_GREEN_SIZE			0x3023
#define EGL_RED_SIZE			0x3024
#define EGL_DEPTH_SIZE			0x3025
#define EGL_STENCIL_SIZE		0x3026
#define EGL_CONFIG_CAVEAT		0x3027
#define EGL_CONFIG_ID			0x3028
#define EGL_LEVEL			0x3029
#define EGL_MAX_PBUFFER_HEIGHT		0x302A
#define EGL_MAX_PBUFFER_PIXELS		0x302B
#define EGL_MAX_PBUFFER_WIDTH		0x302C
#define EGL_NATIVE_RENDERABLE		0x302D
#define EGL_NATIVE_VISUAL_ID		0x302E
#define EGL_NATIVE_VISUAL_TYPE		0x302F
#define EGL_PRESERVED_RESOURCES		0x3030
#define EGL_SAMPLES			0x3031
#define EGL_SAMPLE_BUFFERS		0x3032
#define EGL_SURFACE_TYPE		0x3033
#define EGL_TRANSPARENT_TYPE		0x3034
#define EGL_TRANSPARENT_BLUE_VALUE	0x3035
#define EGL_TRANSPARENT_GREEN_VALUE	0x3036
#define EGL_TRANSPARENT_RED_VALUE	0x3037
#define EGL_NONE			0x3038	/* Attrib list terminator */
#define EGL_BIND_TO_TEXTURE_RGB		0x3039
#define EGL_BIND_TO_TEXTURE_RGBA	0x303A
#define EGL_MIN_SWAP_INTERVAL		0x303B
#define EGL_MAX_SWAP_INTERVAL		0x303C
#define EGL_LUMINANCE_SIZE		0x303D
#define EGL_ALPHA_MASK_SIZE		0x303E
#define EGL_COLOR_BUFFER_TYPE		0x303F
#define EGL_RENDERABLE_TYPE		0x3040
#define EGL_MATCH_NATIVE_PIXMAP		0x3041	/* Pseudo-attribute (not queryable) */
#define EGL_CONFORMANT			0x3042

/* Reserved 0x3041-0x304F for additional config attributes */

/* Config attribute values */
#define EGL_SLOW_CONFIG			0x3050	/* EGL_CONFIG_CAVEAT value */
#define EGL_NON_CONFORMANT_CONFIG	0x3051	/* EGL_CONFIG_CAVEAT value */
#define EGL_TRANSPARENT_RGB		0x3052	/* EGL_TRANSPARENT_TYPE value */
#define EGL_RGB_BUFFER			0x308E	/* EGL_COLOR_BUFFER_TYPE value */
#define EGL_LUMINANCE_BUFFER		0x308F	/* EGL_COLOR_BUFFER_TYPE value */

/* More config attribute values, for EGL_TEXTURE_FORMAT */
#define EGL_NO_TEXTURE			0x305C
#define EGL_TEXTURE_RGB			0x305D
#define EGL_TEXTURE_RGBA		0x305E
#define EGL_TEXTURE_2D			0x305F

/* Config attribute mask bits */
#define EGL_PBUFFER_BIT			0x0001	/* EGL_SURFACE_TYPE mask bits */
#define EGL_PIXMAP_BIT			0x0002	/* EGL_SURFACE_TYPE mask bits */
#define EGL_WINDOW_BIT			0x0004	/* EGL_SURFACE_TYPE mask bits */
#define EGL_VG_COLORSPACE_LINEAR_BIT	0x0020	/* EGL_SURFACE_TYPE mask bits */
#define EGL_VG_ALPHA_FORMAT_PRE_BIT	0x0040	/* EGL_SURFACE_TYPE mask bits */
#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200	/* EGL_SURFACE_TYPE mask bits */
#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400	/* EGL_SURFACE_TYPE mask bits */

#define EGL_OPENGL_ES_BIT		0x0001	/* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENVG_BIT			0x0002	/* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENGL_ES2_BIT		0x0004	/* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENGL_BIT			0x0008	/* EGL_RENDERABLE_TYPE mask bits */

/* QueryString targets */
#define EGL_VENDOR			0x3053
#define EGL_VERSION			0x3054
#define EGL_EXTENSIONS			0x3055
#define EGL_CLIENT_APIS			0x308D

/* QuerySurface / SurfaceAttrib / CreatePbufferSurface targets */
#define EGL_HEIGHT			0x3056
#define EGL_WIDTH			0x3057
#define EGL_LARGEST_PBUFFER		0x3058
#define EGL_TEXTURE_FORMAT		0x3080
#define EGL_TEXTURE_TARGET		0x3081
#define EGL_MIPMAP_TEXTURE		0x3082
#define EGL_MIPMAP_LEVEL		0x3083
#define EGL_RENDER_BUFFER		0x3086
#define EGL_VG_COLORSPACE		0x3087
#define EGL_VG_ALPHA_FORMAT		0x3088
#define EGL_HORIZONTAL_RESOLUTION	0x3090
#define EGL_VERTICAL_RESOLUTION		0x3091
#define EGL_PIXEL_ASPECT_RATIO		0x3092
#define EGL_SWAP_BEHAVIOR		0x3093
#define EGL_MULTISAMPLE_RESOLVE		0x3099

/* EGL_RENDER_BUFFER values / BindTexImage / ReleaseTexImage buffer targets */
#define EGL_BACK_BUFFER			0x3084
#define EGL_SINGLE_BUFFER		0x3085

/* OpenVG color spaces */
#define EGL_VG_COLORSPACE_sRGB		0x3089	/* EGL_VG_COLORSPACE value */
#define EGL_VG_COLORSPACE_LINEAR	0x308A	/* EGL_VG_COLORSPACE value */

/* OpenVG alpha formats */
#define EGL_VG_ALPHA_FORMAT_NONPRE	0x308B	/* EGL_ALPHA_FORMAT value */
#define EGL_VG_ALPHA_FORMAT_PRE		0x308C	/* EGL_ALPHA_FORMAT value */

/* Constant scale factor by which fractional display resolutions &
 * aspect ratio are scaled when queried as integer values.
 */
#define EGL_DISPLAY_SCALING		10000

/* Unknown display resolution/aspect ratio */
#define EGL_UNKNOWN			((EGLint)-1)

/* Back buffer swap behaviors */
#define EGL_BUFFER_PRESERVED		0x3094	/* EGL_SWAP_BEHAVIOR value */
#define EGL_BUFFER_DESTROYED		0x3095	/* EGL_SWAP_BEHAVIOR value */

/* CreatePbufferFromClientBuffer buffer types */
#define EGL_OPENVG_IMAGE		0x3096

/* QueryContext targets */
#define EGL_CONTEXT_CLIENT_TYPE		0x3097

/* CreateContext attributes */
#define EGL_CONTEXT_CLIENT_VERSION	0x3098

/* Multisample resolution behaviors */
#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A	/* EGL_MULTISAMPLE_RESOLVE value */
#define EGL_MULTISAMPLE_RESOLVE_BOX	0x309B	/* EGL_MULTISAMPLE_RESOLVE value */

/* BindAPI/QueryAPI targets */
#define EGL_OPENGL_ES_API		0x30A0
#define EGL_OPENVG_API			0x30A1
#define EGL_OPENGL_API			0x30A2

/* GetCurrentSurface targets */
#define EGL_DRAW			0x3059
#define EGL_READ			0x305A

/* WaitNative engines */
#define EGL_CORE_NATIVE_ENGINE		0x305B

/* EGL 1.2 tokens renamed for consistency in EGL 1.3 */
#define EGL_COLORSPACE			EGL_VG_COLORSPACE
#define EGL_ALPHA_FORMAT		EGL_VG_ALPHA_FORMAT
#define EGL_COLORSPACE_sRGB		EGL_VG_COLORSPACE_sRGB
#define EGL_COLORSPACE_LINEAR		EGL_VG_COLORSPACE_LINEAR
#define EGL_ALPHA_FORMAT_NONPRE		EGL_VG_ALPHA_FORMAT_NONPRE
#define EGL_ALPHA_FORMAT_PRE		EGL_VG_ALPHA_FORMAT_PRE

/* EGL extensions must request enum blocks from the Khronos
 * API Registrar, who maintains the enumerant registry. Submit
 * a bug in Khronos Bugzilla against task "Registry".
 */

/* EGL Functions */

EGLAPI EGLint EGLAPIENTRY eglGetError(void);

EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id);
EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy);

EGLAPI const char * EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name);

EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
			 EGLint config_size, EGLint *num_config);
EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
			   EGLConfig *configs, EGLint config_size,
			   EGLint *num_config);
EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
			      EGLint attribute, EGLint *value);

EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
				  EGLNativeWindowType win,
				  const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
				   const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
				  EGLNativePixmapType pixmap,
				  const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface);
EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
			   EGLint attribute, EGLint *value);

EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api);
EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void);

EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void);

EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void);

EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(
	      EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
	      EGLConfig config, const EGLint *attrib_list);

EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
			    EGLint attribute, EGLint value);
EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);

EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval);

EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config,
			    EGLContext share_context,
			    const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx);
EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw,
			  EGLSurface read, EGLContext ctx);

EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void);
EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw);
EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void);
EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx,
			   EGLint attribute, EGLint *value);

EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine);
EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface);
EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,
			  EGLNativePixmapType target);

/* This is a generic function pointer type, whose name indicates it must
 * be cast to the proper type *and calling convention* before use.
 */
typedef void (*__eglMustCastToProperFunctionPointerType)(void);

/* Now, define eglGetProcAddress using the generic function ptr. type */
EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY
       eglGetProcAddress(const char *procname);

#ifdef __cplusplus
}
#endif

#endif /* __egl_h_ */


code:
#ifndef __eglext_h_
#define __eglext_h_

#ifdef __cplusplus
extern "C" {
#endif

/*
** Copyright (c) 2007-2009 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/

#include <EGL/eglplatform.h>

/*************************************************************/

/* Header file version number */
/* Current version at http://www.khronos.org/registry/egl/ */
#define EGL_EGLEXT_VERSION 4

#ifndef EGL_KHR_config_attribs
#define EGL_KHR_config_attribs 1
#define EGL_CONFORMANT_KHR			0x3042	/* EGLConfig attribute */
#define EGL_VG_COLORSPACE_LINEAR_BIT_KHR	0x0020	/* EGL_SURFACE_TYPE bitfield */
#define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR		0x0040	/* EGL_SURFACE_TYPE bitfield */
#endif

#ifndef EGL_KHR_lock_surface
#define EGL_KHR_lock_surface 1
#define EGL_READ_SURFACE_BIT_KHR		0x0001	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
#define EGL_WRITE_SURFACE_BIT_KHR		0x0002	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
#define EGL_LOCK_SURFACE_BIT_KHR		0x0080	/* EGL_SURFACE_TYPE bitfield */
#define EGL_OPTIMAL_FORMAT_BIT_KHR		0x0100	/* EGL_SURFACE_TYPE bitfield */
#define EGL_MATCH_FORMAT_KHR			0x3043	/* EGLConfig attribute */
#define EGL_FORMAT_RGB_565_EXACT_KHR		0x30C0	/* EGL_MATCH_FORMAT_KHR value */
#define EGL_FORMAT_RGB_565_KHR			0x30C1	/* EGL_MATCH_FORMAT_KHR value */
#define EGL_FORMAT_RGBA_8888_EXACT_KHR		0x30C2	/* EGL_MATCH_FORMAT_KHR value */
#define EGL_FORMAT_RGBA_8888_KHR		0x30C3	/* EGL_MATCH_FORMAT_KHR value */
#define EGL_MAP_PRESERVE_PIXELS_KHR		0x30C4	/* eglLockSurfaceKHR attribute */
#define EGL_LOCK_USAGE_HINT_KHR			0x30C5	/* eglLockSurfaceKHR attribute */
#define EGL_BITMAP_POINTER_KHR			0x30C6	/* eglQuerySurface attribute */
#define EGL_BITMAP_PITCH_KHR			0x30C7	/* eglQuerySurface attribute */
#define EGL_BITMAP_ORIGIN_KHR			0x30C8	/* eglQuerySurface attribute */
#define EGL_BITMAP_PIXEL_RED_OFFSET_KHR		0x30C9	/* eglQuerySurface attribute */
#define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR	0x30CA	/* eglQuerySurface attribute */
#define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR	0x30CB	/* eglQuerySurface attribute */
#define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR	0x30CC	/* eglQuerySurface attribute */
#define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR	0x30CD	/* eglQuerySurface attribute */
#define EGL_LOWER_LEFT_KHR			0x30CE	/* EGL_BITMAP_ORIGIN_KHR value */
#define EGL_UPPER_LEFT_KHR			0x30CF	/* EGL_BITMAP_ORIGIN_KHR value */
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglLockSurfaceKHR (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglUnlockSurfaceKHR (EGLDisplay display, EGLSurface surface);
#endif /* EGL_EGLEXT_PROTOTYPES */
typedef EGLBoolean (EGLAPIENTRYP PFNEGLLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface);
#endif

#ifndef EGL_KHR_image
#define EGL_KHR_image 1
#define EGL_NATIVE_PIXMAP_KHR			0x30B0	/* eglCreateImageKHR target */
typedef void *EGLImageKHR;
#define EGL_NO_IMAGE_KHR			((EGLImageKHR)0)
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);
#endif /* EGL_EGLEXT_PROTOTYPES */
typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image);
#endif

#ifndef EGL_KHR_vg_parent_image
#define EGL_KHR_vg_parent_image 1
#define EGL_VG_PARENT_IMAGE_KHR			0x30BA	/* eglCreateImageKHR target */
#endif

#ifndef EGL_KHR_gl_texture_2D_image
#define EGL_KHR_gl_texture_2D_image 1
#define EGL_GL_TEXTURE_2D_KHR			0x30B1	/* eglCreateImageKHR target */
#define EGL_GL_TEXTURE_LEVEL_KHR		0x30BC	/* eglCreateImageKHR attribute */
#endif

#ifndef EGL_KHR_gl_texture_cubemap_image
#define EGL_KHR_gl_texture_cubemap_image 1
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR	0x30B3	/* eglCreateImageKHR target */
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR	0x30B4	/* eglCreateImageKHR target */
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR	0x30B5	/* eglCreateImageKHR target */
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR	0x30B6	/* eglCreateImageKHR target */
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR	0x30B7	/* eglCreateImageKHR target */
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR	0x30B8	/* eglCreateImageKHR target */
#endif

#ifndef EGL_KHR_gl_texture_3D_image
#define EGL_KHR_gl_texture_3D_image 1
#define EGL_GL_TEXTURE_3D_KHR			0x30B2	/* eglCreateImageKHR target */
#define EGL_GL_TEXTURE_ZOFFSET_KHR		0x30BD	/* eglCreateImageKHR attribute */
#endif

#ifndef EGL_KHR_gl_renderbuffer_image
#define EGL_KHR_gl_renderbuffer_image 1
#define EGL_GL_RENDERBUFFER_KHR			0x30B9	/* eglCreateImageKHR target */
#endif

#ifndef EGL_KHR_reusable_sync
#define EGL_KHR_reusable_sync 1

typedef void* EGLSyncKHR;
typedef khronos_utime_nanoseconds_t EGLTimeKHR;

#define EGL_SYNC_STATUS_KHR			0x30F1
#define EGL_SIGNALED_KHR			0x30F2
#define EGL_UNSIGNALED_KHR			0x30F3
#define EGL_TIMEOUT_EXPIRED_KHR			0x30F5
#define EGL_CONDITION_SATISFIED_KHR		0x30F6
#define EGL_SYNC_TYPE_KHR			0x30F7
#define EGL_SYNC_REUSABLE_KHR			0x30FA
#define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR		0x0001	/* eglClientWaitSyncKHR <flags> bitfield */
#define EGL_FOREVER_KHR				0xFFFFFFFFFFFFFFFFull
#define EGL_NO_SYNC_KHR				((EGLSyncKHR)0)
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
#endif /* EGL_EGLEXT_PROTOTYPES */
typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNCKHR) (EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCKHR) (EGLDisplay dpy, EGLSyncKHR sync);
typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCKHR) (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHR) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHR) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
#endif

#ifndef EGL_KHR_image_base
#define EGL_KHR_image_base 1
/* Most interfaces defined by EGL_KHR_image_pixmap above */
#define EGL_IMAGE_PRESERVED_KHR			0x30D2	/* eglCreateImageKHR attribute */
#endif

#ifndef EGL_KHR_image_pixmap
#define EGL_KHR_image_pixmap 1
/* Interfaces defined by EGL_KHR_image above */
#endif

#ifndef EGL_IMG_context_priority
#define EGL_IMG_context_priority 1
#define EGL_CONTEXT_PRIORITY_LEVEL_IMG		0x3100
#define EGL_CONTEXT_PRIORITY_HIGH_IMG		0x3101
#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG		0x3102
#define EGL_CONTEXT_PRIORITY_LOW_IMG		0x3103
#endif

#ifdef __cplusplus
}
#endif

#endif