UTS6710/aps/include/middleware/network/common/pic_if.h

/************************************************************************/
/**
*
* \file	pic_if.h
*
*
* \brief	This file provides PICTURE Related API Definition . \n
*
* \note  	Copyright (c) 2008 Sunplus Technology Co., Ltd. \n
*			All rights reserved.
*
*
* \author		rebecca.hsieh@sunplus.com	 08/05/2008	Creation
**********************************************************************/

#ifndef _PIC_IF_H
#define _PIC_IF_H

#include "types.h"

#ifdef PIC_IF_IMPLEMENTATION
#define PIC_IF_EXTERN
#else
#define PIC_IF_EXTERN extern
#endif

//#define PIC_JR_API_I
//#define PIC_JR_API_II

#define PIC_SAFE_WORKING_MEMORY_GAP (512)
#define PIC_INTERNAL_WORKING_MEMORY (512<<10)
#define PIC_NEEDED_WORKING_MEMORY (PIC_INTERNAL_WORKING_MEMORY +(PIC_SAFE_WORKING_MEMORY_GAP<<1))

#define MESSAGE_QUEUE_TYPE_PIC 			  (1<<18)
#define PIC_ROM_CloseFile PIC_FILE_CloseFile

/*
* Define the return value of the Picture interface.
*/
#define PIC_IF_STOP_ACTION                               (5)
#define PIC_IF_INVALID_W_H                               (4)
#define PIC_IF_PRE_PARSING_ERROR                         (3)
#define PIC_IF_UNSUPPORTED_FILE_FORMAT                   (2)
#define PIC_IF_WARNING_PIC_INSTANCE_CANNOT_CLOSE         (1)
#define PIC_IF_SUCCESSFUL 			         (0)
#define PIC_IF_PIC_ALREADY_INITIALIZED		         (-1)
#define PIC_IF_MALLOC_ERROR			         (-2)
#define PIC_IF_PIC_INSNTANCE_OPEN	                 (-3)
#define PIC_IF_PIC_NOT_INITIALIZED                       (-4)
#define PIC_IF_PIC_INSTANCE_MEMORY_LOST                  (-5)
#define PIC_IF_PIC_HANDLE_NULL                           (-6)
#define PIC_IF_MAXIMUN_INSTANCE_REACHED	                 (-7)
#define PIC_IF_INVALID_PIC_HANDLE                        (-8)
#define PIC_IF_INVALID_WORKING_BUFFER_ADDR               (-9)
#define PIC_IF_INVALID_PIC_PARAMS                        (-10)
#define PIC_IF_FILE_OPEN_ERROR                           (-11)
#define PIC_IF_PIC_INSTANCE_NOT_OPEN_READY               (-12)
#define PIC_IF_INTERNAL_THREAD_NOT_DESTROYED             (-13)
#define PIC_IF_INVALID_FILE_HANDLE                       (-14)
#define PIC_IF_INVALID_WORKING_PIC_INFO_ADDR             (-15)
#define PIC_IF_SETUP_FILE_INFO_ERROR                     (-16)
#define PIC_IF_CREATE_DECODE_THREAD_FAIL                 (-17)
#define PIC_IF_RESOURCE_ALLOCATION_ERROR                 (-18)
#define PIC_IF_INVALID_MEMORY                            (-19)
#define PIC_IF_CLOSE_FILE_FAIL                           (-20)
#define PIC_IF_STATE_TRANSITION_ERROR                    (-21)
#define PIC_IF_PIC_FILE_HANDLE_NULL                      (-22)
#define PIC_IF_MAXIMUN_FILES_PER_INSTANCE_REACHED	 (-23)
#define PIC_IF_INITIALIZE_INSTANCE_ERROR		 (-24)
#define PIC_IF_STATIC_MEMORY_NOT_ENOUGH                  (-25)
#define PIC_IF_FUNCTION_NOT_SUPPORT		         (-26)
#define PIC_IF_INVALID_PIC_TYPE                          (-27)
#define PIC_IF_FETCH_DATA_ERROR                          (-28)
#define PIC_IF_FORMAT_NOT_MATCH_EXT_NAME                 (-29)
#define PIC_IF_DECODING_THREAD_NOT_RUNNING               (-30)
#define PIC_IF_UNSUPPORTED_FORMAT                        (-31)
#define PIC_IF_INVALID_SRC_FRAME_BUFFER_INDEX            (-32)
#define PIC_IF_INVALID_TAR_FRAME_BUFFER_INDEX            (-33)
#define PIC_IF_INVALID_COPY_OPERATION                    (-34)
#define PIC_IF_INVALID_EFFECT_MODE                       (-35)
#define PIC_IF_STOP_FILE_FAIL                            (-36)
#define PIC_IF_STOP_EFFECT_FAIL                          (-37)
#define PIC_IF_WAIT_IDLE_FAIL                            (-38)
#define PIC_IF_RETRIVE_INFO_NOT_READY                    (-39)
#define PIC_IF_STOP_ENCODE_FAIL                          (-40)  // scott add 03/26 2010
#define PIC_IF_HW_NOT_AVAILABLE				(-41)
#define PIC_IF_GL_RECEIVE_FAIL                              (-42)
#define PIC_IF_JR_STATE_TRANSITION_ERROR                    (-43) //zeno_JRII
#define PIC_IF_STOP_JR_FAIL					(-44) //zeno_JRII

// scott modified 04/26 2010
// fix mantis no.78197
/*
* Define the EXIF related string length.
*/
#define exif_string_length 20
#define exif_long_string_length 256
// end scott modified 04/26 2010

/**
 *	\brief Handle to a PIC Instance
 */
typedef UINT32 PIC_Handle;

/**
 *	\brief Handle to a PIC file
 */
typedef UINT32 PIC_FILE_Handle;

/**
 *	\brief Thread Priority
 */
enum PIC_Priority_t
{
	PIC_LOGO_THREAD = 1,			/*!< making the thread as Highest priority */
	PIC_NORMAL_THREAD,			/*!< making the thread as normal priority */
	PIC_DFB_THREAD,                          /*!< using dedicate DFB thread*/
};

//***********************************************************************
//    for pic_DFB use in internal level
//***********************************************************************
/**
 *	\brief Define the function pointers for Direct FB read and seek rom.
 */
typedef struct _pic_dfb_IO_t
{
	long (*pfRead)(int fid,void *Buffer, size_t dSize);/*!the function pointer of read from DirectFB. */
	off_t (*pfSeek)(int fid,off_t dOffset, int dWhence);/*!the function pointer of seek from DirectFB. */
} pic_dfb_IO_t;

/**
 *	\brief Retrive Info definition
 */
enum PIC_InfoStag_t
{
	PIC_PREPARSING_INFO = 0,			/*!< get the preparsing info */
	PIC_DISPLAY_ON_FRAME_INFO = 1,			/*!< get the info on frame buffer */
	PIC_DECODE_DONE_INFO = 2,			/*!< get the decode done info */
};

/**
 *	\brief PIC State definition
 */
enum PIC_state_t
{
	PIC_STATE_NULL = 0,			/*!< null state */
	PIC_STATE_IDLE = 1,			/*!< PIC Idle state */
	PIC_STATE_INIT = 2,			/*!< PIC initial state */
	PIC_STATE_DECODE = 3,		/*!< PIC decoding state */
	PIC_STATE_PIC_INFO_ON_FRAME_READY = 4, /*!< PIC decoder calculate pos and W and H on Frame buffer */
	PIC_STATE_DECODE_DONE = 5,	/*!< PIC decode done state */
	PIC_STATE_STOP = 6,			/*!< PIC Stop state */
};

#if 0
//zeno_JRII
/**
 *	\brief PIC_JR State definition
 */
enum PIC_JR_state_t
{
	PIC_JR_STATE_IDLE = 0,			/*!< PIC_JR Idle state */
	PIC_JR_STATE_INIT = 1,			/*!< PIC_JR initial state */
	PIC_JR_STATE_RENDERING = 2,	/*!< PIC_JR rendering state */
	PIC_JR_STATE_DONE = 3,			/*!< PIC_JR done state */
	PIC_JR_STATE_STOP = 4,			/*!< PIC_JR stop state */
};
//zeno_JRII_END
#endif

/**
 *	\brief the buffer PIC thread will decode to.
 */
enum PIC_Target_t
{
	PIC_TARGET_FRAME_BUFFER_NO = 0,	/*!< using frame buffer index */
	PIC_TARGET_BUFFER_ADDRESS = 1,	/*!< using the other buffer other than frame buffer */
};

/**
 *	\brief the plane PIC thread will decode to.
 */

enum PIC_Scale_t
{
	PIC_V_H_SCALE_INDEPENDENT = 0,			/*!<not  the same downsampling rate */
	PIC_V_H_SCALE_THE_SAME = 1,			/*!< the same downsampling rate */

};

/**
 *	\brief the plane PIC thread will decode to.
 */

enum PIC_Plane_t
{
	PIC_VPP_PLANE = 0,			/*!< VPP plane */
	PIC_G2D_PLANE = 1,			/*!< G2D plane */
};

//zeno_20100429
/**
 *	\brief GIF JR path
 */
enum PIC_GIF_JR_Path_t
{
	PIC_GIF_NON_JR = 0,			/*!< making the thread as Highest priority */
	PIC_GIF_JR = 1,			/*!< making the thread as normal priority */
};

/**
 *	\brief PIC rotate by JR or SW which will pass to PIC thread
 */
typedef enum _scale_type_t
{
	PIC_JR_NORMAL_ROTATE = 0, /*!<  using JR normal policy to ratate.  */
	PIC_JR_BYPASS_ROTATE,/*!<  using JR bypass policy to ratate.  */
	PIC_SW_NORMAL_ROTATE,/*!<  using sw normal policy to ratate.  */
	PIC_ROTATE_MAX /*!< the max number of scale type */
} scale_type_t;

/**
 *	\brief Define the degree of Picture sharpness of JR.
 */
typedef enum
{
	PIC_SHARPNESS_0 = 0, /*!the Picture Sharpness by JR filter  degree 0 */
	PIC_SHARPNESS_1,/*!the Picture Sharpness by JR filter  degree 1 , the default one*/
	PIC_SHARPNESS_2,/*!the Picture Sharpness by JR filter  degree 2 */
	PIC_SHARPNESS_3,/*!the Picture Sharpness by JR filter  degree 3 */
	PIC_SHARPNESS_4,/*!the Picture Sharpness by JR filter  degree 4 */
	PIC_SHARPNESS_5,/*!the Picture Sharpness by JR filter  degree 5 */
} PICSharpness;


/**
 *	\brief the data structure of the parameter for PIC_RetrieveInfo
 */
typedef struct
{
	scale_type_t scale_type;	/*!< the scaler policy for rotate info. */
	UINT32 scale_width;			/*!< the width of this picture on frame buffer, get the value after decoding. */
	UINT32 scale_height;		/*!< the height of this picture on frame buffer, get the value after decoding. */
	UINT32 scale_offset;		/*!< the scaling offset of this picture on frame buffer, get the value after decoding. */
	UINT32 x_onFrame;				/*!< the real start position of the decoded picture on the frame */
	UINT32 y_onFrame;				/*!< the real start position of the decoded picture on the frame */
} PIC_FrmInfo_t;

/**
 *	\brief Define the general color format for G2D.
 */
typedef enum
{
	PIC_RGBA = 0, /*!the Picture color format for G2D is RGBA arrangement. */
	PIC_CrYCbA,/*!the Picture color format for G2D is crYCbA arrangement.*/
	PIC_ARGB,/*!the Picture color format for G2D is ARGB arrangement. */
	PIC_COLOR_MAX,
} PIC_G2D_Color_t;

/**
 *	\brief Define the endian arrangment for RGBA or ARGB.
 */
typedef enum
{
	PIC_BigEndian = 0, /*!the Picture color format  is RGBA or ARGB arrangement. */
	PIC_LittleEndian,/*!the Picture color format is ABGR or BGRA arrangement.*/
} PIC_Endian_t;

/**
 *	\brief Define if the small image will be Enlarged or not.
 */
typedef enum
{
	PIC_Enlarge_Image = 0, /*!It's necessary to Enlarge the picture which is smaller than window.*/
	PIC_Enlarge_None, /*!It's not necessary to Enlarge the picture which is smaller than window. */
} PIC_Enlarge_t;

/**
 *	\brief Define if the image will be Orientated or not.
 */
typedef enum
{
	PIC_Orientate_Image = 0, /*!It's necessary to Orientate the picture which has orientate exif.*/
	PIC_Orientate_None, /*!It's not necessary to Orientate the picture which has orientate exif. */
} PIC_Orientate_t;



/**
 *	\brief the data structure of the parameter for PIC_Decode
 */
typedef struct
{
	enum PIC_Plane_t dDisplayPlane;	/*!<the decoding plane */
	UINT32 number;				/*!< the frame buffer number */
	UINT8 *Luma;				/*!< the address of Luma buffer  */
	UINT8 *Chroma;				/*!< the address of Chroma buffer  */
	UINT32 width;				/*!< the width of this picture */
	UINT32 height;				/*!< the height of this picture */
	UINT32 pos_x;				/*!< the x position of the start position decoding on frame buffer for this picture  */
	UINT32 pos_y;				/*!< the y position of the start position decoding on frame buffer for this picture  */
	UINT32 thumbnail_decode;	/*!< the flag indicate if decoding thumbnail image or not. */
	enum PIC_Scale_t dVH_scale;  /*!< the flag indicate if decoding  image V & H scaling factor is the same or not  */
	void *MWQueueHandle;		/*!<for upper layer Queue Handle */
	UINT32 gif_fCtrl;				/*!< control gif decode frame number (for GIF) */
	UINT8 gif_tb_ctrl;			/*!< control gif two-buffer decode (for GIF) */
	int (*CBFunc)(UINT32 dFrameID);/*!< the call back function of switching Frame Buffer. */
	UINT32 LineOffset;			/*!<the Line pitch for current Plane.*/
	UINT32 G2DHdl;				/*!<the G2D handle when G2D plane.*/
	PICSharpness dPICSharp;	 /*!< the sharpness for picture, this parameter can tune the JR coefficient. */
	PIC_G2D_Color_t dG2D_Arrange;/*!< Indicate the arrangement of the color of pixels in G2D. */
	PIC_Endian_t dRGBEndian; /*!< the endian arrangement. */
	PIC_Enlarge_t dEnlarge;    /*!< Indicate the image will enlarge to fit the window or not.*/
	PIC_Orientate_t dOrientate;    /*!< Indicate the image will Orientate or not.*/
} target_addr_t;

/**
 *	\brief the data structure of the parameter for PIC_Encode
 */
typedef struct
{
	enum PIC_Plane_t dDisplayPlane;	/*!<the Encoding plane */
	UINT8 dVideoFrame;          /*!< the Memory type of VPP frames about source frame. Only usefule when VPP source.*/
	UINT32 dFrameID;            /*!< the dedicate Frame ID which will be encoded. */
	UINT8 * pBitstreamBuffer;	/*!< the address for saving bitstream. Need the size of 1 VPP frame size.*/
	UINT8 * pProcessBuffer;	    /*!< the address for Processing Encoding. Need the size of 2 VPP frames size.*/
	UINT8 * TransBuffer_Luma;	/*!< Only use when Src image is on G2D. It's need to transfer to YUV color Domain. Need the memoy as the size of  Luma buffer of VPP. And Needs on SDRAM1.*/
	UINT8 * TransBuffer_Chroma;	/*!< Only use when Src image is on G2D. It's need to transfer to YUV color Domain. Need the memoy as the size of  Chroma buffer of VPP. And Needs on SDRAM2.*/
	UINT8 * VideoBuffer_Luma;  /*!< Only use when the resolution of src video frame is greater than 720P. It's need to downscaling to 720P. Need the memory as the size of 720P. And Needs on SDRAM1.*/
	UINT8 * VideoBuffer_Chroma;	/*!< Only use when the resolution of src video frame is greater than 720P. It's need to downscaling to 720P. Need the memory as the size of 720P/2. And Needs on SDRAM2.*/
	UINT32 scale_width;			/*!<  the width of the image on Frame buffer.  */
	UINT32 scale_height;		/*!<  the height of the image on Frame buffer.  */
	UINT32 LinePitch;             /*!< the linepitch of current Plane.(maybe g2d or Vpp)  */
	UINT32 G2D_Hdl;		/*!<the G2D handle when G2D plane.*/
// scott add 03/26 2010
// JPEG Encoder support
	UINT32 pos_x;		/*!<  the x position of the image on Frame buffer.  */
	UINT32 pos_y;		/*!<  the y position of the image on Frame buffer.  */
// end scott add 03/26 2010
	void *MWQueueHandle;		/*!<for upper layer Queue Handle */
} Encode_params_t;

//zeno_JR
/**
 *	\brief Define the source color format for JR.
 */
typedef enum
{
	PIC_JR_SRC_YUV420 = 0,	/*!< the YUV420 source color format for JR. */
	PIC_JR_SRC_RGB565,		/*!< the RGB565 source color format for JR. */
	PIC_JR_SRC_RGBA8888,	/*!< the RGBA8888 source color format for JR. */
	PIC_JR_SRC_ARGB8888,	/*!< the ARGB8888 source color format for JR. */
	PIC_JR_SRC_CrYCbA8888,	/*!< the CrYCbA8888 source color format for JR. */
	PIC_JR_SRC_ACrYCb8888,	/*!< the ACrYCb8888 source color format for JR. */
	PIC_JR_SRC_COLOR_MAX,
} PIC_JR_Src_Color_t;

/**
 *	\brief Define the target color format for JR.
 */
typedef enum
{
	PIC_JR_TAR_YCbCr420 = 0,	/*!< the YCbCr420 target color format for JR. */
	PIC_JR_TAR_YCbCrBW,		/*!< the YCbCrBW target color format for JR. */
	PIC_JR_TAR_RGB565,			/*!< the RGB565 target color format for JR. */
	PIC_JR_TAR_ARGB1555,		/*!< the ARGB1555 target color format for JR. */
	PIC_JR_TAR_RGBA5551,		/*!< the RGBA5551 target color format for JR. */
	PIC_JR_TAR_RGBA4444,		/*!< the RGBA4444 target color format for JR. */
	PIC_JR_TAR_RGBA8888,		/*!< the RGBA8888 target color format for JR. */
	PIC_JR_TAR_ARGB8888,		/*!< the ARGB8888 target color format for JR. */
	PIC_JR_TAR_CrYCbA8888,	/*!< the CrYCbA8888 target color format for JR. */
	PIC_JR_TAR_ACrYCb8888,	/*!< the ACrYCb8888 target color format for JR. */
	PIC_JR_TAR_COLOR_MAX,
} PIC_JR_Tar_Color_t;

/**
 *	\brief the data structure of the parameter for PIC_JR_Use
 */
typedef enum
{
	PIC_JR_BIG_ENDIAN = 0,		/*!< the big endian color format for JR. */
	PIC_JR_LITTLE_ENDIAN,		/*!< the little endian color format for JR. */
} PIC_JR_Endian;

/**
 *	\brief the data structure of the parameter for PIC_JR_Use
 */
typedef struct
{
	UINT8 *pSrc_Luma_Buffer;	/*!< the luma address of source bitstream. */
	UINT8 *pSrc_Chroma_Buffer;	/*!< the chroma address of source bitstream. */
	UINT8 *pTar_Luma_Buffer;	/*!< the luma address of target bitstream. */
	UINT8 *pTar_Chroma_Buffer;	/*!< the chroma address of target bitstream. */

	UINT32 src_width;	/*!<  the width of source image. */
	UINT32 src_height;	/*!<  the height of source image. */
	UINT32 src_pos_x;	/*!<  the x position of source image. */
	UINT32 src_pos_y;	/*!<  the y position of source image. */

	UINT32 tar_width;	/*!<  the width of target image. */
	UINT32 tar_height;	/*!<  the height of target image. */
	UINT32 tar_pos_x;	/*!<  the x position of target image. */
	UINT32 tar_pos_y;	/*!<  the y position of source image. */

	UINT32 src_LinePitch;	/*!< the linepitch of source Plane.(maybe G2D or VPP) */
	UINT32 tar_LinePitch;	/*!< the linepitch of target Plane.(maybe G2D or VPP) */

	UINT8 orientation;	/*!< the orientation of target image. */
	PIC_JR_Endian endian_format;	/*!< the endian format */
	//UINT32 mcu_line_num;	/*!< the fetch mcu line number */

	PIC_JR_Src_Color_t src_color_format;	/*!< the source color format for JR. */
	PIC_JR_Tar_Color_t tar_color_format;	/*!< the target color format for JR. */

	void *MWQueueHandle;	/*!<for upper layer Queue Handle. */

	//UINT8 jr_state;	/*!<jr state. */
	//UINT32 mcu_line_count;	/*!<mcu_line counter. */
} JR_params_t;
//zeno_JR_END

#if 1
//zeno_JRII
/**
 *	\brief the data structure of the parameter for PIC_JR_Basis
 */
typedef struct
{
	UINT8 *pTar_Luma_Buffer;	/*!< the luma address of target bitstream. */
	UINT8 *pTar_Chroma_Buffer;	/*!< the chroma address of target bitstream. */

	UINT32 src_width;	/*!<  the width of source image. */
	UINT32 src_height;	/*!<  the height of source image. */
	UINT32 src_pos_x;	/*!<  the x position of source image. */
	UINT32 src_pos_y;	/*!<  the y position of source image. */

	UINT32 tar_width;	/*!<  the width of target image. */
	UINT32 tar_height;	/*!<  the height of target image. */
	UINT32 tar_pos_x;	/*!<  the x position of target image. */
	UINT32 tar_pos_y;	/*!<  the y position of source image. */

	UINT32 src_LinePitch;	/*!< the linepitch of source Plane.(maybe G2D or VPP) */
	UINT32 tar_LinePitch;	/*!< the linepitch of target Plane.(maybe G2D or VPP) */

	UINT8 orientation;	/*!< the orientation of target image. */
	PIC_JR_Endian endian_format;	/*!< the endian format */

	PIC_JR_Src_Color_t src_color_format;	/*!< the source color format for JR. */
	PIC_JR_Tar_Color_t tar_color_format;	/*!< the target color format for JR. */

	void *MWQueueHandle;	/*!<for upper layer Queue Handle. */
} JR_Basis_params_t;

/**
 *	\brief the data structure of the parameter for PIC_JR_Basis_Src
 */
typedef struct
{
	UINT8 *pSrc_Luma_Buffer;	/*!< the luma address of source bitstream. */
	UINT8 *pSrc_Chroma_Buffer;	/*!< the chroma address of source bitstream. */

	UINT32 mcu_line_num;	/*!< the fetch mcu line number */

	PIC_JR_Src_Color_t src_color_format;	/*!< the source color format for JR. */

	void *MWQueueHandle;	/*!<for upper layer Queue Handle. */

	UINT32 mcu_line_count;	/*!<mcu_line counter. */
} JR_Basis_Src_params_t;
//zeno_JRII_END
#endif

// scott modified 04/26 2010
// fix mantis no.78197
// scott add 12/28 2009
// for EXIF completion (include IFD0 and Exif SubIFD)
/**
 *	\brief the data structure of the JPEG EXIF Info
 */
typedef struct
{
//    Boolean exif_parser_end;  /*!< check if the EXIF info. parsing is finished */
	UINT8 *exif_bs_position;  /*!< the pointer to the current bitstream position */
	UINT8 *exif_camera_position;  /*!< the pointer to the current Exif SubIFD (camera info.) position */
	UINT8 *exif_gps_position;  /*!< the pointer to the current GPS info. position */
	UINT8 *exif_makernote_position;  /*!< the pointer to the current Makernote position */
	UINT8 *exif_thumbnail_position;  /*!< the pointer to the current thumbnail image info. position */
	UINT32 app1_length;  /*!< APP1 data size */
	UINT8  exif_byte_order[2];  /*!< the endian format of EXIF data */
	UINT8  InteropIndex[3];  /*!< the InteropIndex tag */
	UINT32 InteropVersion;  /*!< the InteropVersion tag */
	UINT32 ProcessingSoftware[exif_string_length]; /*!< the ProcessingSoftware tag */
	UINT32 SubfileType;  /*!< the SubfileType tag */
	UINT32 OldSubfileType;  /*!< the OldSubfileType tag */
	UINT32 ImageWidth;  /*!< the ImageWidth tag */
	UINT32 ImageHeight;  /*!< the ImageHeight tag */
	UINT32 BitsPerSample;  /*!< the BitsPerSample tag */
	UINT32 Compression;  /*!< the Compression tag */
	UINT32 PhotometricInterpretation;  /*!< the PhotometricInterpretation tag */
	UINT32 Thresholding;  /*!< the Thresholding tag */
	UINT32 CellWidth;  /*!< the CellWidth tag */
	UINT32 CellLength;  /*!< the CellLength tag */
	UINT32 FillOrder;  /*!< the FillOrder tag */
	UINT8  DocumentName[exif_long_string_length];  /*!< the DocumentName tag */
	UINT8  ImageDescription[exif_long_string_length];  /*!< the ImageDescription tag */
	UINT8  Make[exif_long_string_length];  /*!< the Make tag */
	UINT8  Model[exif_long_string_length];  /*!< the Model tag */
	UINT32 Stripoffsets; /*!< not use now */
	UINT32 Orientation;  /*!< the Orientation tag */
	UINT32 Samplesperpixel;  /*!< the Samplesperpixel tag */
	UINT32 Rowsperstrip;  /*!< the Rowsperstrip tag */
	UINT32 Stripbytecounts; /*!< not use now */
	UINT32 Minsamplevalue;  /*!< the Minsamplevalue tag */
	UINT32 Maxsamplevalue;  /*!< the Maxsamplevalue tag */
	UINT32 Xresolution[2];  /*!< the Xresolution tag */
	UINT32 Yresolution[2];  /*!< the Yresolution tag */
	UINT32 Planarconfiguration;  /*!< the Planarconfiguration tag */
	UINT8  Pagename[exif_string_length];  /*!< the Pagename tag */
	UINT32 Xposition[2];  /*!< the Xposition tag */
	UINT32 Yposition[2];  /*!< the Yposition tag */
	UINT32 Freeoffsets; /*!< not use now */
	UINT32 Freebytecounts; /*!< not use now */
	UINT32 Grayresponseunit; /*!< not use now */
	UINT32 Grayresponsecurve; /*!< not use now */
	UINT32 T4Options;  /*!< the T4Options tag */
	UINT32 T6Options;  /*!< the T6Options tag */
	UINT32 Resolutionunit;  /*!< the Resolutionunit tag */
	UINT32 Pagenumber;  /*!< the Pagenumber tag */
//    UINT32 Colorresponseunit; /*!< not use now */
	UINT32 Transferfunction; /*!< not use now */
	UINT8  Software[exif_long_string_length];  /*!< the Software tag */
	UINT8  Modifydate[exif_string_length];  /*!< the Modifydate tag */
	UINT8  Artist[exif_string_length];  /*!< the Artist tag */
	UINT8  Hostcomputer[exif_string_length];  /*!< the Hostcomputer tag */
	UINT32 Predictor;  /*!< the Predictor tag */
	UINT32 Whitepoint[2];  /*!< the Whitepoint tag */
	UINT32 Primarychromaticities[6];  /*!< the Primarychromaticities tag */
	UINT32 Colormap; /*!< not use now */
	UINT32 Halftonehints;  /*!< the Halftonehints tag */
	UINT32 Tilewidth;  /*!< the Tilewidth tag */
	UINT32 Tilelength;  /*!< the Tilelength tag */
	UINT32 Tileoffsets; /*!< not use now */
	UINT32 Tilebytecounts; /*!< not use now */
	UINT32 Badfaxlines; /*!< not use now */
	UINT32 Cleanfaxdata; /*!< not use now */
	UINT32 Consecutivebadfaxlines; /*!< not use now */
	UINT32 Subifd;/*!< not use now */
	UINT32 Inkset;  /*!< the Inkset tag */
	UINT8  Inknames[exif_string_length];  /*!< the Inknames tag */
	UINT32 Numberofinks;/*!< not use now */
	UINT8  Dotrange[exif_string_length];  /*!< the Dotrange tag */
	UINT32 Targetprinter[exif_string_length];/*!< not use now */
	UINT32 Extrasamples;  /*!< the Extrasamples tag */
	UINT32 Sampleformat;  /*!< the Sampleformat tag */
	UINT32 Sminsamplevalue;/*!< not use now */
	UINT32 Smaxsamplevalue;/*!< not use now */
	UINT32 Transferrange;/*!< not use now */
	UINT32 Clippath;/*!< not use now */
	UINT32 Xclippathunits;/*!< not use now */
	UINT32 Yclippathunits;/*!< not use now */
	UINT32 Indexed;/*!< not use now */
	UINT32 Jpegtables;/*!< not use now */
	UINT32 Opiproxy;/*!< not use now */
	UINT32 Globalparametersifd;/*!< not use now */
	UINT32 Profiletype;/*!< not use now */
	UINT32 Faxprofile;/*!< not use now */
	UINT32 Codingmethods;/*!< not use now */
	UINT32 Versionyear;/*!< not use now */
	UINT32 Modenumber;/*!< not use now */
	UINT32 Decode;/*!< not use now */
	UINT32 Defaultimagecolor;/*!< not use now */
	UINT32 Jpegproc;/*!< not use now */
	UINT32 Thumbnailoffset;  /*!< the Thumbnailoffset tag */
	UINT32 Thumbnaillength;  /*!< the Thumbnaillength tag */
	UINT32 Jpegrestartinterval;  /*!< the Jpegrestartinterval tag */
	UINT32 Jpeglosslesspredictors;/*!< not use now */
	UINT32 Jpegpointtransforms;/*!< not use now */
	UINT32 Jpegqtables;/*!< not use now */
	UINT32 Jpegdctables;/*!< not use now */
	UINT32 Jpegactables;/*!< not use now */
	UINT32 Ycbcrcoefficients[3];  /*!< the Ycbcrcoefficients tag */
	UINT8  Ycbcrsubsampling[2];  /*!< the Ycbcrsubsampling tag */
	UINT32 Ycbcrpositioning;  /*!< the Ycbcrpositioning tag */
	UINT32 Referenceblackwhite[12];  /*!< the Referenceblackwhite tag */
	UINT32 Striprowcounts; /*!< not use now */
	UINT32 Applicationnotes;  /*!< the Applicationnotes tag */
	UINT8  Relatedimagefileformat[exif_string_length];  /*!< the Relatedimagefileformat tag */
	UINT32 Relatedimagewidth;  /*!< the Relatedimagewidth tag */
	UINT32 Relatedimageheight;  /*!< the Relatedimageheight tag */
	UINT32 Rating;  /*!< the Rating tag */
	UINT32 Ratingpercent;  /*!< the Ratingpercent tag */
	UINT32 Imageid;/*!< not use now */
	UINT32 Wangannotation;/*!< not use now */
	UINT32 Matteing;/*!< not use now */
	UINT32 Datatype;/*!< not use now */
	UINT32 Imagedepth;/*!< not use now */
	UINT32 Tiledepth;/*!< not use now */
	UINT32 Model2;/*!< not use now */
	UINT32 Cfarepeatpatterndim;/*!< not use now */
	UINT32 Cfapattern2;/*!< not use now */
	UINT32 Batterylevel;/*!< not use now */
	UINT32 Kodakifd;/*!< not use now */
	UINT8  Copyright[exif_long_string_length];  /*!< the Copyright tag */
	UINT32 Exposuretime[2];  /*!< the Exposuretime tag */
	UINT32 Fnumber[2];  /*!< the Fnumber tag */
	UINT32 Mdfiletag;/*!< not use now */
	UINT32 Mdscalepixel;/*!< not use now */
	UINT32 Mdcolortable;/*!< not use now */
	UINT32 Mdlabname;/*!< not use now */
	UINT32 Mdsampleinfo;/*!< not use now */
	UINT32 Mdprepdate;/*!< not use now */
	UINT32 Mdpreptime;/*!< not use now */
	UINT32 Mdfileunits;/*!< not use now */
	UINT32 Pixelscale;/*!< not use now */
	UINT32 Iptc_Naa;  /*!< the Iptc_Naa tag */
	UINT32 Intergraphpacketdata;/*!< not use now */
	UINT32 Intergraphflagregisters;/*!< not use now */
	UINT32 Intergraphmatrix;/*!< not use now */
	UINT32 Modeltiepoint;/*!< not use now */
	UINT32 Site;/*!< not use now */
	UINT32 Colorsequence;/*!< not use now */
	UINT32 It8Header;/*!< not use now */
	UINT32 Rasterpadding;/*!< not use now */
	UINT32 Bitsperrunlength;/*!< not use now */
	UINT32 Bitsperextendedrunlength;/*!< not use now */
	UINT32 Colortable;/*!< not use now */
	UINT32 Imagecolorindicator;/*!< not use now */
	UINT32 Backgroundcolorindicator;/*!< not use now */
	UINT32 Imagecolorvalue;/*!< not use now */
	UINT32 Backgroundcolorvalue;/*!< not use now */
	UINT32 Pixelintensityrange;/*!< not use now */
	UINT32 Transparencyindicator;/*!< not use now */
	UINT32 Colorcharacterization;/*!< not use now */
	UINT32 Hcusage;/*!< not use now */
	UINT32 Trapindicator;/*!< not use now */
	UINT32 Cmykequivalent;/*!< not use now */

	UINT8  Seminfo[exif_string_length];  /*!< the Seminfo tag */

	UINT32 Afcp_Iptc;/*!< not use now */
	UINT32 Modeltransform;/*!< not use now */
	UINT32 Wb_Grgblevels;/*!< not use now */
	UINT32 Leafdata;/*!< not use now */
	UINT32 Photoshopsettings;/*!< not use now */
	UINT32 Exifoffset;/*!< not use now */
	UINT32 Icc_Profile;/*!< not use now */
	UINT32 Imagelayer;/*!< not use now */
	UINT32 Geotiffdirectory;/*!< not use now */
	UINT32 Geotiffdoubleparams;/*!< not use now */
	UINT32 Geotiffasciiparams;/*!< not use now */
	UINT32 Exposureprogram;  /*!< the Exposureprogram tag */
	UINT8  Spectralsensitivity[exif_string_length];  /*!< the Spectralsensitivity tag */

	UINT32 Gpsinfo;  /*!< the Gpsinfo tag */
	UINT32 IsoSpeedrating;  /*!< the IsoSpeedrating tag */
	UINT32 Opto_Electricconvfactor;  /*!< the Opto_Electricconvfactor tag */
	UINT32 Interlace;  /*!< the Interlace tag */
	UINT32 Timezoneoffset;  /*!< the Timezoneoffset tag */
	UINT32 Selftimermode;  /*!< the Selftimermode tag */
	UINT32 Faxrecvparams;  /*!< the Faxrecvparams tag */
	UINT32 Faxsubaddress;  /*!< the Faxsubaddress tag */
	UINT32 Faxrecvtime;  /*!< the Faxrecvtime tag */
	UINT32 Leafsubifd;  /*!< the Leafsubifd tag */
	UINT16 Exifversion[2];  /*!< the Exifversion tag */
	UINT8  Datetimeoriginal[exif_string_length];  /*!< the Datetimeoriginal tag */
	UINT8  Createdate[exif_string_length];  /*!< the Createdate tag */
	UINT32 Componentsconfiguration;  /*!< the Componentsconfiguration tag */
	UINT32 Compressedbitsperpixel[2];  /*!< the Compressedbitsperpixel tag */
	INT32  Shutterspeedvalue[2];  /*!< the Shutterspeedvalue tag */
	UINT32 Aperturevalue[2];  /*!< the Aperturevalue tag */
	INT32  Brightnessvalue[2];  /*!< the Brightnessvalue tag */
	INT32  Exposurecompensation[2];  /*!< the Exposurecompensation tag */
	UINT32 Maxaperturevalue[2];  /*!< the Maxaperturevalue tag */
	UINT32 Subjectdistance[2];  /*!< the Subjectdistance tag */
	UINT32 Meteringmode;  /*!< the Meteringmode tag */

	UINT32 Lightsource;  /*!< the Lightsource tag */
	UINT32 Flash;  /*!< the Flash tag */
	UINT32 Focallength[2];  /*!< the Focallength tag */
	UINT16 Subjectarea[4];  /*!< the Subjectarea tag */
	UINT32 Stonits;/*!< not use now */

	UINT32 Makernotefactory;  /*!< the MakerNote tag */

	UINT8  Usercomment[exif_long_string_length];  /*!< the Usercomment tag */
	UINT32 Subsectime;/*!< the Subsectime tag */
	UINT32 Subsectimeoriginal;/*!< the Subsectimeoriginal tag */
	UINT32 Subsectimedigitized;/*!< the Subsectimedigitized tag */
	UINT32 Msdocumenttext;  /*!< the Msdocumenttext tag */
	UINT32 Mspropertysetstorage;  /*!< the Mspropertysetstorage tag */
	UINT32 Msdocumenttextposition;  /*!< the Msdocumenttextposition tag */
	UINT32 Imagesourcedata;/*!< not use now */
	UINT32 Xptitle;  /*!< the Xptitle tag */
	UINT32 Xpcomment;  /*!< the Xpcomment tag */
	UINT32 Xpauthor;  /*!< the Xpauthor tag */
	UINT32 Xpkeywords;  /*!< the Xpkeywords tag */
	UINT32 Xpsubject;  /*!< the Xpsubject tag */
	UINT32 Flashpixversion[2];  /*!< the Flashpixversion tag */
	UINT32 Colorspace;  /*!< the Colorspace tag */
	UINT32 Exifimagewidth;  /*!< the Exifimagewidth tag */
	UINT32 Exifimageheight;  /*!< the Exifimageheight tag */
	UINT8  Relatedsoundfile[exif_string_length];  /*!< the Relatedsoundfile tag */
	UINT32 Interopoffset;  /*!< the Interopoffset tag */
	UINT32 Flashenergy[2];  /*!< the Flashenergy tag */
	UINT32 Spatialfrequencyresponse;/*!< not use now */
	UINT32 Noise;  /*!< the Noise tag */
	UINT32 Focalplanexresolution[2];  /*!< the Focalplanexresolution tag */
	UINT32 Focalplaneyresolution[2];  /*!< the Focalplaneyresolution tag */
	UINT32 Focalplaneresolutionunit;  /*!< the Focalplaneresolutionunit tag */
	UINT32 Imagenumber;  /*!< the Imagenumber tag */
	UINT32 Securityclassification;  /*!< the Securityclassification tag */
	UINT32 Imagehistory;  /*!< the Imagehistory tag */

	UINT8  Subjectlocation[2];  /*!< the Subjectlocation tag */
	UINT32 Exposureindex[2];  /*!< the Exposureindex tag */
	UINT32 Tiff_Epstandardid;  /*!< the Tiff_Epstandardid tag */
	UINT32 Sensingmethod;  /*!< the Sensingmethod tag */

	UINT32 Filesource;  /*!< the Filesource tag */
	UINT32 Scenetype;  /*!< the Scenetype tag */
	UINT32 Cfapattern[2];  /*!< the Cfapattern tag */
	UINT32 Customrendered;  /*!< the Customrendered tag */
	UINT32 Exposuremode;  /*!< the Exposuremode tag */
	UINT32 Whitebalance;  /*!< the Whitebalance tag */
	UINT32 Digitalzoomratio[2];  /*!< the Digitalzoomratio tag */
	UINT32 Focallengthin35Mmformat;  /*!< the Focallengthin35Mmformat tag */
	UINT32 Scenecapturetype;  /*!< the Scenecapturetype tag */
	UINT32 Gaincontrol;  /*!< the Gaincontrol tag */
	UINT32 Contrast;  /*!< the Contrast tag */
	UINT32 Saturation;  /*!< the Saturation tag */
	UINT32 Sharpness;  /*!< the Sharpness tag */
	UINT32 Devicesettingdescription;  /*!< the Devicesettingdescription tag */
	UINT32 Subjectdistancerange;  /*!< the Subjectdistancerange tag */
	UINT8  Imageuniqueid[exif_string_length];  /*!< the Imageuniqueid tag */
	UINT32 Gdalmetadata;  /*!< the Gdalmetadata tag */
	UINT32 Gamma[2];  /*!< the Gamma tag */

	UINT32 Expandsoftware;/*!< not use now */
	UINT32 Expandlens;/*!< not use now */
	UINT32 Expandfilm;/*!< not use now */
	UINT32 Expandfilterlens;/*!< not use now */
	UINT32 Expandscanner;/*!< not use now */
	UINT32 Expandflashlamp;/*!< not use now */

	UINT32 Pixelformat;  /*!< the Pixelformat tag */
	UINT32 Transformation;  /*!< the Transformation tag */
	UINT32 Uncompressed;  /*!< the Uncompressed tag */
	UINT32 Imagetype;  /*!< the Imagetype tag */


	UINT32 Widthresolution;/*!< not use now */
	UINT32 Heightresolution;/*!< not use now */
	UINT32 Imageoffset;/*!< not use now */
	UINT32 Imagebytecount;/*!< not use now */
	UINT32 Alphaoffset;/*!< not use now */
	UINT32 Alphabytecount;/*!< not use now */
	UINT32 Imagedatadiscard;/*!< not use now */
	UINT32 Alphadatadiscard;/*!< not use now */
	UINT32 Ocescanjobdesc;/*!< not use now */
	UINT32 Oceapplicationselector;/*!< not use now */
	UINT32 Oceidnumber;/*!< not use now */
	UINT32 Oceimagelogic;/*!< not use now */
	UINT32 Annotations;/*!< not use now */
	UINT8  Printim[exif_long_string_length];/*!< not use now */
	UINT8  Dngversion[4];  /*!< the Dngversion tag */
	UINT8  Dngbackwardversion[4];  /*!< the Dngbackwardversion tag */
	UINT8  Uniquecameramodel[exif_string_length];  /*!< the Uniquecameramodel tag */
	UINT8  Localizedcameramodel[exif_string_length];  /*!< the Localizedcameramodel tag */
	UINT32 Cfaplanecolor;/*!< not use now */
	UINT32 Cfalayout;  /*!< the Cfalayout tag */
	UINT32 Linearizationtable;/*!< not use now */
	UINT32 Blacklevelrepeatdim;/*!< not use now */
	UINT32 Blacklevel;  /*!< the Blacklevel tag */
	UINT32 BlackleveldeltaH;/*!< not use now */
	UINT32 BlackleveldeltaV;/*!< not use now */
	UINT32 Whitelevel;  /*!< the Whitelevel tag */
	UINT32 Defaultscale[2];  /*!< the Defaultscale tag */
	UINT32 Defaultcroporigin;  /*!< the Defaultcroporigin tag */
	UINT32 Defaultcropsize;  /*!< the Defaultcropsize tag */
	UINT32 Colormatrix1;/*!< not use now */
	UINT32 Colormatrix2;/*!< not use now */
	UINT32 Cameracalibration1;/*!< not use now */
	UINT32 Cameracalibration2;/*!< not use now */
	UINT32 Reductionmatrix1;/*!< not use now */
	UINT32 Reductionmatrix2;/*!< not use now */
	UINT32 Analogbalance;/*!< not use now */

	UINT32 Asshotneutral;  /*!< the Asshotneutral tag */
	UINT32 Asshotwhitexy;  /*!< the Asshotwhitexy tag */
	INT32  Baselineexposure;  /*!< the Baselineexposure tag */
	UINT32 Baselinenoise;  /*!< the Baselinenoise tag */
	UINT32 Baselinesharpness;  /*!< the Baselinesharpness tag */
	INT32  Bayergreensplit;  /*!< the Bayergreensplit tag */
	UINT32 Linearresponselimit;  /*!< the Linearresponselimit tag */
	UINT8  Cameraserialnumber[exif_string_length];  /*!< the Cameraserialnumber tag */

	UINT32 Dnglensinfo[4];  /*!< the Dnglensinfo tag */
	UINT32 Chromablurradius;  /*!< the Chromablurradius tag */
	UINT32 Antialiasstrength;  /*!< the Antialiasstrength tag */
	UINT32 Shadowscale;  /*!< the Shadowscale tag */
	UINT32 Sr2Private;  /*!< the Sr2Private tag */
	UINT32 Makernotesafety;  /*!< the Makernotesafety tag */

	UINT32 Rawimagesegmentation;  /*!< the Rawimagesegmentation tag */
	UINT32 Calibrationilluminant1;  /*!< the Calibrationilluminant1 tag */
	UINT32 Calibrationilluminant2;  /*!< the Calibrationilluminant2 tag */
	UINT32 Bestqualityscale;  /*!< the Bestqualityscale tag */

	UINT8  Rawdatauniqueid[exif_string_length];  /*!< the Rawdatauniqueid tag */

	UINT32 Aliaslayermetadata;  /*!< the Aliaslayermetadata tag */
	UINT8  Originalrawfilename[exif_string_length];  /*!< the Originalrawfilename tag */
	UINT8  Originalrawfiledata[exif_string_length];  /*!< the Originalrawfiledata tag */
	UINT32 Activearea[4];  /*!< the Activearea tag */
	UINT32 Maskedareas[4];  /*!< the Maskedareas tag */
	UINT32 Asshoticcprofile;/*!< not use now */
	INT32  Asshotpreprofilematrix;  /*!< the Asshotpreprofilematrix tag */
	UINT32 Currenticcprofile;  /*!< the Currenticcprofile tag */
	INT32  Currentpreprofilematrix;  /*!< the Currentpreprofilematrix tag */
	UINT32 Colorimetricreference;  /*!< the Colorimetricreference tag */
	UINT8  Panasonictitle[exif_string_length];  /*!< the Panasonictitle tag */
	UINT8  Panasonictitle2[exif_string_length];  /*!< the Panasonictitle2 tag */

	UINT8  Cameracalibrationsig[exif_string_length];  /*!< the Cameracalibrationsig tag */
	UINT8  Profilecalibrationsig[exif_string_length];  /*!< the Profilecalibrationsig tag */
	UINT32 Profileifd;  /*!< the Profileifd tag */
	UINT8  Asshotprofilename[exif_string_length];  /*!< the Asshotprofilename tag */
	UINT32 Noisereductionapplied;  /*!< the Noisereductionapplied tag */
	UINT8  Profilename[exif_string_length];  /*!< the Profilename tag */
	UINT32 Profilehuesatmapdims[3];  /*!< the Profilehuesatmapdims tag */
	UINT32 Profilehuesatmapdata1;  /*!< the Profilehuesatmapdata1 tag */
	UINT32 Profilehuesatmapdata2;  /*!< the Profilehuesatmapdata2 tag */
	UINT32 Profiletonecurve;  /*!< the Profiletonecurve tag */
	UINT32 Profileembedpolicy;  /*!< the Profileembedpolicy tag */
	UINT8  Profilecopyright[exif_string_length];  /*!< the Profilecopyright tag */
	INT32  Forwardmatrix1;  /*!< the Forwardmatrix1 tag */
	INT32  Forwardmatrix2;  /*!< the Forwardmatrix2 tag */
	UINT8  Previewapplicationname[exif_string_length];  /*!< the Previewapplicationname tag */
	UINT8  Previewapplicationversion[exif_string_length];  /*!< the Previewapplicationversion tag */
	UINT8  Previewsettingsname[exif_string_length];  /*!< the Previewsettingsname tag */

	UINT32 Previewsettingsdigest;  /*!< the Previewsettingsdigest tag */
	UINT32 Previewcolorspace;  /*!< the Previewcolorspace tag */
	UINT8  Previewdatetime[exif_string_length];  /*!< the Previewdatetime tag */
	UINT32 Rawimagedigest;  /*!< the Rawimagedigest tag */
	UINT32 Originalrawfiledigest;  /*!< the Originalrawfiledigest tag */
	UINT32 Subtileblocksize;/*!< not use now */
	UINT32 Rowinterleavefactor;/*!< not use now */
	UINT32 Profilelooktabledims[3];  /*!< the Profilelooktabledims tag */
	UINT32 Profilelooktabledata;  /*!< the Profilelooktabledata tag */
	UINT32 Opcodelist1;/*!< not use now */
	UINT32 Opcodelist2;/*!< not use now */
	UINT32 Opcodelist3;/*!< not use now */
	UINT32 Noiseprofile;/*!< not use now */
	UINT32 Padding;/*!< not use now */
	INT32  Offsetschema;  /*!< the Offsetschema tag */
	UINT8  Ownername[exif_string_length];  /*!< the Ownername tag */
	UINT8  Serialnumber[exif_string_length];  /*!< the Serialnumber tag */
	UINT8  Lens[exif_string_length];  /*!< the Lens tag */
	UINT32 exif_maker_length;  /*!< the data size of maker */
	UINT32 exif_model_length;  /*!< the data size of model number */
	UINT32 exif_date_length;  /*!< the data size of date/time */
	UINT32 exif_total_length;  /*!< the length of total exif */
	UINT32 e_numerator;  /*!< the numerator of exposure time */
	UINT32 e_denominator;  /*!< the denominator of exposure time */
	UINT32 f_numerator;  /*!< the numerator of FNumber */
	UINT32 f_denominator;  /*!< the denominator of FNumber */
} Pic_EXIF_t;
// end scott modified 04/26 2010

#if 0 // johnson
/**
 *	\brief the Data structure for the info for retrieving PIC info.
 */
typedef struct
{
	UINT32 pic_width;			/*!< the width of this picture */
	UINT32 pic_height;			/*!< the height of this picture */
	UINT32 pic_tn_width;		/*!< the width of the thumbnail of this picture */
	UINT32 pic_tn_height;		/*!< the height of the thumbnail of this picture */
	UINT8 pic_support;			/*!<record when preparser,if the pic support or not. */
	UINT8 pic_tn_support;		/*!<recorde when preparser,if the thumbnail format in Jpeg support or not.
								   0:no thumbnail or non support  */
	Pic_EXIF_t pic_exif_data;	/*!< the EXIF info for the picture */
//	Pic_EXIF_Info_t pic_exif_info;	/*!< the DateTime for the picture */  // scott modified 04/26 2010
	UINT32 png_interlace;		/*!< the interlace info for PNG */
	UINT32 png_colortype;		/*!< the colortype info for PNG */
	UINT8* png_palette_addr;  /*!<the palette table address of PNG.*/
	UINT32 consume_size;       /*!< the storage to consume size of decoder on working buffer*/
	UINT32 scaling_factor;		/*!< the scaling factor for picture */
	UINT32 scaling_factor_2;	/*!< the 2nd scaling factor for GIF */
	ifunc7 init_func;			/*!< the init function for picture */
	ifunc7 decoding_func;		/*!< the decoding function for picture */
	ifunc7 scaling_func;		/*!< the scaling function for picture */
	ifunc7 load_local_var;		/*!< the loading function for picture */
	UINT32 col_tab_size;	/*!< the color table size */
	int pic_format;	/*!< the file format */
	int gif_anime; //sunwhy add for anime support
} PIC_Info_t;
#endif

/**
 *	\brief PIC effect definitions
 */
enum effect_mode_t
{
	PIC_ROTATION_NONE = 0,		/*!<  0: no effect */
	PIC_ROTATION_LEFT,			/*!<  1: rotate left */
	PIC_ROTATION_180,			/*!<  2: rotate 180 degree */
	PIC_ROTATION_RIGHT,			/*!<  3: rotate right */
	PIC_ROTATION_L_R_REVERSE,	/*!<  4: left and right reverse */
	PIC_ROTATION_UP_DOWN_REVERSE,	/*!<  5: up and down reverse */
	PIC_EFFECT_MAX,				/*!<  21: the max number of effect */
};
/**
 *	\brief PIC effect info which will pass to PIC thread
 */
typedef struct
{
	UINT32 src_frame_index;		/*!<  the index of frame buffer wich there is source data.  */
	UINT32 tar_frame_index;		/*!<  the index of frame buffer wich will be the target buffer which theeffect will apply to.  */
	UINT32 scale_pos_x;
	UINT32 scale_pos_y;
	UINT32 scale_width;			/*!<  the width of the image on Frame buffer.  */
	UINT32 scale_height;		/*!<  the height of the image on Frame buffer.  */
	enum effect_mode_t effect_mode;	/*!<  the effect which will be use for this picture.  */
	void *effect_work_info;		/*!< the pointer of effect working info location */
	void *MWQueueHandle;		/*!<for Middleware Queue Handle */
	UINT32 Window_Width;		/*!<for display window width */
	UINT32 Window_Height;		/*!<for display window height */
	scale_type_t scale_type;                  /*!<scaling by JR or SW*/
} PIC_EFFECT_INFO_t;

/**
 *	\brief PIC respond message definition
 */
typedef enum
{
	PIC_RESPOND_DECODE_DONE = 1,	/*!< 1: Picture Decode Done. */
	PIC_RESPOND_INFO_ON_FRAME_READY,/*!< Picture Info on Frame buffer is ready. */
	PIC_RESPOND_DECODE_STOP,    /*!<  Picture Decode Stop. */
	PIC_RESPOND_EFFECT_DONE,	/*!<  Picture Effect Done. */
	PIC_RESPOND_EFFECT_STOP,	/*!<  Picture Effect Stop. */
	PIC_RESPOND_DECODE_DONE_BY_READ_ERROR,	/*!<  Picture decode done by reading error. */
	PIC_RESPOND_DECODE_DONE_WITH_DECODE_ERROR, /*!<Picture decode done with decode error.  */
	PIC_RESPOND_ENCODE_DONE,	/*!<  Picture encode done. */
	PIC_RESPOND_ENCODE_STOP,	/*!<  Picture Encode Stop. */ // scott add 03/26 2010
	PIC_RESPOND_JR_USE_DONE,	/*!<  Picture JR_Use done. */ //zeno_JR
	PIC_RESPOND_JR_BASIS_DONE,	/*!<  Picture JR_Basis done. */ //zeno_JRII
	PIC_RESPOND_JR_BASIS_SRC_DONE,	/*!<  Picture JR_Basis_Src done. */ //zeno_JRII
	PIC_RESPOND_JR_BASIS_SRC_ALLDONE,	/*!<  Picture JR_Basis_Src done. */ //zeno_JRII
	PIC_RESPOND_JR_STOP,	/*!<  Picture JR_Basis Stop. */ //zeno_JRII
	PIC_RESPOND_REGION_CHANGE,
	PIC_RESPOND_MAX,			/*!<  the max number of respond messages. */
} PIC_RESPOND_Message_t;

typedef enum
{
	PIC_REGION_CHANGE_STATE_KEEP = 0,
	PIC_REGION_CHANGE_STATE_IDLE,
	PIC_REGION_CHANGE_STATE_START,
	PIC_REGION_CHANGE_STATE_ACTION,
	PIC_REGION_CHANGE_STATE_DONE
} PIC_REGION_CHANGE_STATE_E;
/**
 *	\brief PIC respond message body, the same defination as PE.
 */
typedef struct _PIC_Respond_MessageBody_t
{
	UINT32 eventId;   /*!<Event ID number specified in enum structure in this file. (respond message) */
	UINT32 dparam;   /*!<Param Associated with the event. */
} PIC_Respond_Message_t;

#define PIC_RESPOND_MESSAGE_BODY_SIZE (sizeof(PIC_Respond_Message_t))

/******************************************************************************************/
/**
 * \fn		int PIC_Initialize(void)
 *
 * \brief		Initialize the PIC Module
 *
 *\return        \e PIC_IF_SUCCESSFUL on success.
 *                  \e PIC_IF_PIC_ALREADY_INITIALIZED on mudule has been initialized.
 *                  \e PIC_IF_MALLOC_ERROR on no memory allocates for pic module object.
 *
 * \note		PIC_Initialize must be called before using PIC_IF.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Initialize(void);

/***********************************************************************************/
/**
 * \fn		int PIC_Finalize(void)
 *
 * \brief		Finalize the PIC Module
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *                  \e PIC_IF_PIC_NOT_INITIALIZED on no pic module exist.
 *                  \e PIC_IF_PIC_INSNTANCE_OPEN on there is still instace not closing, the pic module can't close.
 *			\e PIC_IF_PIC_INSTANCE_MEMORY_LOST on the instance pointer is null, it's not reasonable.
 * \note	 	CleanUp All PE Related Resources.
 *******************************************************************************/
PIC_IF_EXTERN int PIC_Finalize(void);

/******************************************************************************************/
/**
 * \fn		int PIC_Open(PIC_Handle* handle,UINT8* pWorkMemory,UINT8*pExtMemory,UINT32 extSize)
 *
 * \brief		Initialize the resource for  PIC Module
 *                                 (ex: working buffer, PIC_Params space)
 *
  * \param	handle :      Pointer to handle that will carry the Handle to the current file.
 *			If the API is succesfully executed.
 * \param	pWorkMemory :      The pointer of the memory which will use by Picture Module.
* \param	pExtMemory :      The pointer of the Extension memory which will use as working buffer.
* \param	extSize :      The size of the extension memory which will use as working buffer.
  *
 * \return		\e  PIC_IF_SUCCESSFUL on success.
 *			\e  PIC_IF_PIC_HANDLE_NULL on PIC_HANDLE is NULL.
 *                  \e  PIC_IF_PIC_NOT_INITIALIZED on PIC Module is not existed.
 *                  \e  PIC_IF_MAXIMUN_INSTANCE_REACHED on the number of instance objects is reached to Maximum.
 *                  \e  PIC_IF_MALLOC_ERROR on no memory allocates for pic module object.
 *
 * \note		the initial state after PIC_Open is PIC_STATE_IDLE
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Open(PIC_Handle *, UINT8*, UINT8*, UINT32);

/******************************************************************************************/
/**
 * \fn		 int PIC_Close(PIC_Handle pPICHandle,UINT8** ppWorkMemory, UINT8** ppExtMemory)
 *
 * \brief		 release the resource for picture module(Close a PE Instance
*                                in the future).
 *
 * \param pPICHandle :  the handle of the current file.
 * \param ppWorkMemory :  the area to save the Pointer to the working memory in picture module.
 * \param ppExtMemory :  the area to save the Pointer to the extension memory in picture module.
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_PIC_HANDLE on PIC handle provided is invalid.
 *			\e PIC_IF_INVALID_WORKING_BUFFER_ADDR on working buffer address is null, it's not reasonable.
 *                  \e PIC_IF_INVALID_PIC_PARAMS on pic params address is null, it's not reasonable.
 *                  \e PIC_IF_CREATE_DECODE_THREAD_FAIL on Decode thread cannot create successfully.
 *
 * \note		State must be at PIC_STATE_IDLE before closing.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Close(PIC_Handle, UINT8** ppWorkMemory, UINT8** ppExtMemory);

/******************************************************************************************/
/**
 * \fn		int PIC_FILE_OpenFile(PIC_Handle handle, PIC_FILE_Handle *pic_file_handle,char *pstFileName)
 *
 * \brief		 Open a file playback object. Malloc the space for working_pic_info space.
 *                                          classify a file and assign the specific decoder function pointer.
 *
 * \param handle : the instance handle for the PIC thread.
 * \param	pic_file_handle :  the Pointer of the lication to save the Handle of the current file.
 * \param	pstFileName : Pointer to a string containing the file name of the object file.
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_PIC_HANDLE on PIC handle provided is invalid.
 *			\e PIC_IF_PIC_INSTANCE_NOT_OPEN_READY on PIC_OPEN not successful for this object, it cannot open a file
 *                  \e PIC_IF_MALLOC_ERROR on no memory allocates for working_pic_info space.
 *                  \e PIC_IF_FILE_OPEN_ERROR on it cannot succeed to open file.
 *
 *
 * \note		A PIC module can only open one playback object.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_FILE_OpenFile(PIC_Handle, PIC_FILE_Handle *, char *);

/******************************************************************************************/
/**
 * \fn		 int PIC_FILE_CloseFile(PIC_Handle handle,PIC_FILE_Handle pic_file_handle )
 *
 * \brief		 Close a file playback object and release the space for working_pic_info.
 *
 * \param handle : the instance handle for the PIC thread.
 * \param	pic_file_handle :  the Pointer of the lication to save the Handle of the current file.
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_PIC_HANDLE on PIC handle provided is invalid.
 *			\e PIC_IF_PIC_INSTANCE_CANNOT_CLOSE on state transaction error.
 *			\e PIC_IF_INVALID_FILE_HANDLE on file handle provided is invalid.
  *			\e PIC_IF_INVALID_WORKING_PIC_INFO_ADDR on it's the invalid address for working pic info address

 * \note		State must be at PIC_STATE_IDLE before closing a File.
 *			File Open Method should be opened by File Name.
 *			After closing a file the state will be set to PIC_STATE_INIT.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_FILE_CloseFile(PIC_Handle, PIC_FILE_Handle);

/******************************************************************************************/
/**
 * \fn		 Int PIC_RetrieveInfo (PIC_Handle handle,PIC_FILE_Handle pic_file_handle,enum PIC_InfoStag_t dInfoType, void *pic_info);
 *
 * \brief		 to get the picture Info.
 *
 * \param handle : the instance handle for the PIC thread.
 * \param	pic_file_handle :  the Handle of the current file.
 * \param   dInfoType : indicate that which kind of info will be retrieve.
 * \param            pic_info : return the pointer to get the picture information
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
 *			\e PIC_IF_FILE_FORMAT_ERROR if Error Occured During Specific
*                                                           File parsing.
* \note		none
******************************************************************************************/
PIC_IF_EXTERN int PIC_RetrieveInfo(PIC_Handle, PIC_FILE_Handle, enum PIC_InfoStag_t, void *);

/******************************************************************************************/
/**
*\fn		 int PIC_Decode(PIC_Handle pPICHandle, PIC_FILE_Handle file_handle, enum PIC_Target_t mem_type, void *target)
*
* \brief		 Decoding the picture to the target buffer.
*
* \param pPICHandle : the instance handle for the PIC thread.
* \param	file_handle :  the Handle of the current file.
* \param    mem_type : PIC_TARGET_FRAME_BUFFER_NO  : the 3rd param will be Frame buffer number
*          PIC_TARGET_BUFFER_ADDRESS     : the 3rd param will be buffer address;
* \param   target          : depending on 2nd param , will be frame buffer number or address and size.
*
* \return		\e PIC_IF_SUCCESSFUL on success.
*			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
*			\e PIC_IF_FUNCTION_NOT_SUPPORT if the system does not
*                                                          support File object.
*			\e PIC_IF_STATE_TRANSITION_ERROR if Current PIC State
*                                                          Prevents this operation to execute.
*			\e PIC_IF_DECODING_ERROR if Error Occured During decoding
*
* \note		State must be at PIC_STATE_INIT before  the decoding.
*			when entering decode function, the state will be set to
*                                   PIC_STATE_DECODE.
******************************************************************************************/
PIC_IF_EXTERN int PIC_Decode(PIC_Handle, PIC_FILE_Handle, enum PIC_Target_t, void *);

/******************************************************************************************/
/**
 * \fn		 int PIC_GetState(PIC_Handle handle,PIC_FILE_Handle pic_file_handle, UINT8* pPICState,UINT8* pic_decode_error)
 *
 * \brief		Get current state of a PIC Decoding.
 *
 * \param handle : the instance handle for the PIC thread.
 * \param	pic_file_handle :  the Handle of the current file.
 * \param	pPICState : Pointer to a variable that will hold the returned state.
 * \param pic_decode_error : if there is any error info produced by decoding.
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_GetState(PIC_Handle, PIC_FILE_Handle, UINT8 *, UINT8 *);

/******************************************************************************************/
/**
 * \fn		 int PIC_Stop(PIC_Handle handle, PIC_FILE_Handle file_handle)
 *
 * \brief		Stop PIC Decoding.
 *
 * \param	handle : the instance handle for the PIC thread.
 * \param	file_handle :  the Handle of the current file.
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Stop(PIC_Handle, PIC_FILE_Handle);

/******************************************************************************************/
/**
 * \fn		 int PIC_GetFileDescriptor(PIC_Handle handle, PIC_FILE_Handle file_handle,int*data)
 *
 * \brief		retrieve the file descriptor
 *
 * \param handle : the instance handle for the PIC thread.
 * \param	file_handle :  the Handle of the current file.
 * \param data : is the pointer of the location to indicate the information of file descriptor.
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_GetFileDescriptor(PIC_Handle, PIC_FILE_Handle, int *);

/******************************************************************************************/
/**
 * \fn		 int PIC_Effect(PIC_Handle pPICEffectHandle, PIC_EFFECT_INFO_t * pic_effect_info)
 *
 * \brief		picture effect, this function is for non-effect-thread .\n
 *
 * \param	pPICEffectHandle : the instance handle for the PIC thread.
 * \param	pic_effect_info : using by PIC_Effect
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Effect(PIC_Handle, PIC_EFFECT_INFO_t *);

/******************************************************************************************/
/**
 * \fn		 int PIC_Stop_Effect(PIC_Handle pic_effect_handle)
 *
 * \brief		stop picture effect, this function is both for non-effect-thread and for an effect thread .
 *
 * \param pic_effect_handle : the PIC handle
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Stop_Effect(PIC_Handle);

/******************************************************************************************/
/**
 * \fn		 int PIC_Effect_Send(PIC_Handle pPICEffectHandle, PIC_EFFECT_INFO_t * pic_effect_info)
 *
 * \brief		Send PIC Effect. This API is for effect thread using.
 *
 * \param	pPICEffectHandle : the Handle of the current file.
 * \param	pic_effect_info : using by PIC_Effect_Send
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_Effect_IF_INVALID_HANDLE if Handle provided is invalid.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Effect_Send(PIC_Handle pPICEffectHandle, PIC_EFFECT_INFO_t * pic_effect_info);

/******************************************************************************************/
/**
 * \fn		int PIC_PriorityOpen(enum PIC_Priority_t dPriority, PIC_Handle * pPICHandle,UINT8* pWorkMemory)
 *
 * \brief		Initialize the resource for  PIC Module and set as the specific priority.
 *                                 (ex: working buffer, PIC_Params space)
 *
 * \param dPriority : the specific value of the PIC thread Priority.
 * \param	pPICHandle :      Pointer to handle that will carry the Handle to the current file.
 *			If the API is succesfully executed.
 * \param   pWorkMemory : the pointer of the memory which will used by picture module.
 *
 * \return		\e  PIC_IF_SUCCESSFUL on success.
 *			\e  PIC_IF_PIC_HANDLE_NULL on PIC_HANDLE is NULL.
 *                  \e  PIC_IF_PIC_NOT_INITIALIZED on PIC Module is not existed.
 *                  \e  PIC_IF_MAXIMUN_INSTANCE_REACHED on the number of instance objects is reached to Maximum.
 *                  \e  PIC_IF_MALLOC_ERROR on no memory allocates for pic module object.
 *
 * \note		the initial state after PIC_Open is PIC_STATE_IDLE
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_PriorityOpen(enum PIC_Priority_t  dPriority, PIC_Handle *, UINT8*);

/******************************************************************************************/
/**
 * \fn		int PIC_ROM_OpenFile(PIC_Handle handle, PIC_FILE_Handle *pic_file_handle,const UINT8 * pRomImage, const UINT32 dSize)
 *
 * \brief		 Open a rom file playback object. Malloc the space for working_pic_info space.
 *                                          classify a file and assign the specific decoder function pointer.
 *
 * \param handle : the instance handle for the PIC thread.
 * \param	pic_file_handle :  the Pointer of the lication to save the Handle of the current file.
 * \param	pRomImage : the Pointer of the rom bitstream.
 * \param dSize : the size of the rom bitstreams.
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_PIC_HANDLE on PIC handle provided is invalid.
 *			\e PIC_IF_PIC_INSTANCE_NOT_OPEN_READY on PIC_OPEN not successful for this object, it cannot open a file
 *                  \e PIC_IF_MALLOC_ERROR on no memory allocates for working_pic_info space.
 *                  \e PIC_IF_FILE_OPEN_ERROR on it cannot succeed to open file.
 *
 *
 * \note		A PIC module can only open one playback object.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_ROM_OpenFile(PIC_Handle pPICHandle, PIC_FILE_Handle * file_handle, const UINT8 * pRomImage, const UINT32 dSize);

/******************************************************************************************/
/**
 * \fn		void PIC_set_disp_center(UINT8 dUse)
 *
 * \brief set if the picture will show on the center of display.
 * \param dUse : 0: not the center, 1: at the center.
 *
 *
 * \note		A PIC module can only open one playback object.
 ******************************************************************************************/
PIC_IF_EXTERN void PIC_set_disp_center(UINT8 dUse);

/******************************************************************************************/
/**
 * \fn		int PIC_WaitIdle(PIC_Handle pPICHandle,INT32 sdTimeOutByms)
 *
 * \brief		 wait for the current instance to IDLE STATE
 *
 * \param pPICHandle : the instance handle for the PIC thread.
 * \param	sdTimeOutByms : the timeout limitation
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_PIC_HANDLE on PIC handle provided is invalid.
 *                  \e PIC_IF_TRANSITION_ERROR on it cannot wait for IDLE .
 *
 *
 * \note		A PIC module can only open one playback object.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_WaitIdle(PIC_Handle pPICHandle, INT32 sdTimeOutByms);

/******************************************************************************************/
/**
*\fn		 int PIC_Encode(PIC_Handle pPICHandle, Encode_params_t *pEncodeParams);
*
* \brief		 Encoding the picture to the target buffer.
*
* \param pPICHandle : the instance handle for the PIC thread.
* \param   pEncodeParams          : all the parameters for encode.
*
*
* \return		\e PIC_IF_SUCCESSFUL on success.
*			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
*
******************************************************************************************/
PIC_IF_EXTERN int PIC_Encode(PIC_Handle pPICHandle, Encode_params_t *pEncodeParams);
// scott add 03/26 2010
// JPEG Encoder support
/******************************************************************************************/
/**
 * \fn		 int PIC_Stop_Encode(PIC_Handle pPICHandle)
 *
 * \brief		stop picture encode
 *
 * \param pPICHandle : the PIC handle
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Stop_Encode(PIC_Handle pPICHandle);
// end scott add 03/26 2010

/******************************************************************************************/
/**
 * \fn		 int PIC_PriorityClose(PIC_Handle pPICHandle,UINT8** ppWorkMemory, UINT8** ppExtMemory)
 *
 * \brief		 release the resource for picture module(pair with PIC_PriorityOpen
*                                ).
 *
 * \param pPICHandle :  Pointer to the handle of the current file.
 * \param ppWorkMemory :  the area to save the Pointer to the working memory in picture module.
 * \param ppExtMemory :  the area to save the Pointer to the extension memory in picture module.
 *
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *			\e PIC_IF_INVALID_PIC_HANDLE on PIC handle provided is invalid.
 *			\e PIC_IF_INVALID_WORKING_BUFFER_ADDR on working buffer address is null, it's not reasonable.
 *                  \e PIC_IF_INVALID_PIC_PARAMS on pic params address is null, it's not reasonable.
 *                  \e PIC_IF_CREATE_DECODE_THREAD_FAIL on Decode thread cannot create successfully.
 *
 * \note		State must be at PIC_STATE_IDLE before closing.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_PriorityClose(PIC_Handle pPICHandle, UINT8** ppWorkMemory, UINT8** ppExtMemory);

//zeno_JR
/******************************************************************************************/
/**
*\fn		 	int PIC_JR_Use(PIC_Handle pPICHandle, JR_params_t *pJRParams);
*
* \brief		JR the source buffer to the target buffer.
*
* \param	pPICHandle : the instance handle for the PIC thread.
* \param	pJRParams  : all the parameters for PIC_JR_Use.
*
*
* \return		\e PIC_IF_SUCCESSFUL on success.
*			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
*
******************************************************************************************/
PIC_IF_EXTERN int PIC_JR_Use(PIC_Handle pPICHandle, JR_params_t *pJRParams);
//zeno_JR_END

//zeno_JRII
/******************************************************************************************/
/**
*\fn		 	int PIC_JR_Basis(PIC_Handle pPICHandle, JR_params_t *pJRParams);
*
* \brief		JR the source buffer to the target buffer basic.
*
* \param	pPICHandle : the instance handle for the PIC thread.
* \param	pJRParams  : all the parameters for PIC_JR_Basis.
*
*
* \return		\e PIC_IF_SUCCESSFUL on success.
*			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
*
******************************************************************************************/
PIC_IF_EXTERN int PIC_JR_Basis(PIC_Handle pPICHandle, JR_Basis_params_t *pJRParams);

/******************************************************************************************/
/**
*\fn		 	int PIC_JR_Basis_Src(PIC_Handle pPICHandle, JR_params_t *pJRParams);
*
* \brief		JR the source buffer to the target buffer source.
*
* \param	pPICHandle : the instance handle for the PIC thread.
* \param	pJRParams  : all the parameters for PIC_JR_Basis_Src.
*
*
* \return		\e PIC_IF_SUCCESSFUL on success.
*			\e PIC_IF_INVALID_HANDLE if Handle provided is invalid.
*
******************************************************************************************/
PIC_IF_EXTERN int PIC_JR_Basis_Src(PIC_Handle pPICHandle, JR_Basis_Src_params_t *pJRParams);

// JR support
/******************************************************************************************/
/**
 * \fn		 int PIC_Stop_JR(PIC_Handle pPICHandle)
 *
 * \brief		stop JR process
 *
 * \param pPICHandle : the PIC handle
 * \return		\e PIC_IF_SUCCESSFUL on success.
 *
 * \note		None.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Stop_JR(PIC_Handle pPICHandle);
//zeno_JRII_END

// zeno_20100429
// GIF JR support only for single GIF
/******************************************************************************************/
/**
 * \fn		 int PIC_Set_GIF_JR_path(PIC_Handle pPICHandle, enum PIC_GIF_JR_Path_t  dGIF_JR)
 *
 * \brief		open JR path only for single GIF
 *
 * \param pPICHandle :  Pointer to the handle of the current file.
 * \param dGIF_JR : enable/disable JR path only for single GIF.
 * \return		\e None.
 *
 * \note		Could be remove when JR support GIF.
 ******************************************************************************************/
PIC_IF_EXTERN int PIC_Set_GIF_JR_path(PIC_Handle pPICHandle, enum PIC_GIF_JR_Path_t  dGIF_JR);

/******************************************************************************************/
/**
 * \fn		void PIC_GetVersion(UINT32 *pdVersion)
 *
 * \brief get the current version number of picture module.
 * \param pdVersion : return the pointer to the version number.
 *
 *
 * \note		Not use now.
 ******************************************************************************************/
PIC_IF_EXTERN void PIC_GetVersion(UINT32 *pdVersion);

PIC_IF_EXTERN void PIC_GetSerial(UINT32 *pdSerial);

#endif							//_PIC_IF_H