/* Copyright (c) 2006 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property 
 * and proprietary rights in and to this software, related documentation 
 * and any modifications thereto.  Any use, reproduction, disclosure or 
 * distribution of this software and related documentation without an 
 * express license agreement from NVIDIA Corporation is strictly prohibited.
 */

/** @file GFJxEnc.h
    GFSDK JPEG Encode API header file.
*/

#ifndef _GF_JPEG_ENC__
#define _GF_JPEG_ENC__

#include "GF.h"
#include "GFRm.h"

#ifdef __cplusplus
extern "C"
{
#endif  /* __cplusplus */

/** @addtogroup groupJxEnc JxEncAPI JPEG Encoder API
<ul>
<li> @ref pageJxEncAppNotes
<ul>
<li> @ref pageJxEncAppNotes1
</ul>
</ul>
*/
/*@{*/

/** JxEncAPI property flag: JPEG quantization table is programmable.
    @see GFJxEncGetProperty(), GFPROPERTY::Capability
*/
#define GF_JX_ENC_CAP_QTABLE        0x00000001

/** JxEncAPI property flag: Interrupt data capture mode and polling mode
    supported, if this flag is off then only polling mode is supported.
    @see GFJxEncGetProperty(), GFPROPERTY::Capability 
*/
#define GF_JX_ENC_CAP_INTERRUPT     0x00000004

/** JxEncAPI property flag: Digital zoom supported.
    @see GFJxEncGetProperty(), GFPROPERTY::Capability 
*/
#define GF_JX_ENC_CAP_DIGITAL_ZOOM  0x00000008

/** JxEncAPI property flag: Motion JPEG mode supported.
    @see GFJxEncGetProperty(), GFPROPERTY::Capability 
*/
#define GF_JX_ENC_CAP_MOTION_JPEG   0x00000010

/** JxEncAPI property flag: Rate control supported.
    @see GFJxEncGetProperty(), GFPROPERTY::Capability 
*/
#define GF_JX_ENC_CAP_RATE_CONTROL  0x00000020

/** JxEncAPI property flag: Planar YUV422 data supported.
    @see GFJxEncGetProperty(), GFPROPERTY::Capability 
*/
#define GF_JX_ENC_CAP_422_PLANAR    0x00000040

/** JxEncAPI property flag: Rotation supported.
    @see GFJxEncGetProperty(), GFPROPERTY::Capability 
*/
#define GF_JX_ENC_CAP_ROTATION      0x00000080


/** Image source/target dimensions and data source for JPEG encoding.

    This structure is passed as parameter to GFJxEncStart() and describes
    data source, source cropping rectangle and destination image size.

    The surface the application wants to encode is pSrcSurf. If the application
    wants to encode an image from a camera or to re-encode a JPEG bitstream,
    this field should be set to NULL. If the application wants to encode an
    image from the display, this field should point to the primary surface. If
    an application wants to encode an existing image, it must create a system
    memory surface to hold the image and set this field to the system memory
    surface.

    @see GFJxEncStart()
*/
typedef struct _GFJXENCSTART
{
    PGFRMSURFACE pSrcSurf;/**< Surface to encode,
                                 NULL for camera or re-encode JPEG
                          */
    PGFRECT pSrcRect;     /**< Source image area need to encode */
    NvU32   DestWidth;    /**< Final encoded image width */
    NvU32   DestHeight;   /**< Final encode image height */
    NvU32   uiOptions;    /**< Bitmask of flags to control encoding
                               <table>
                               <tr><td>#GF_CAPT_BITSTREAM </td>
                                   <td>If set only bitstream is output, if
                                       unset JFIF header will be added</td>
                               </tr>
                               <tr><td>#GF_CAPT_PIECE_MEAL</td>
                                   <td>Piecemeal encoding @todo clarify
                                       meaning</td>
                               </tr>
                               </table>
                          */
    NvU32   Error; /**< Returns detailed error code on GFJxEncStart() failure
                        <table>
                        <tr><td>#GF_CAPT_ERROR_VIDEO_MEMORY_NOT_BIG_ENOUGH</td>
                            <td>Not enough free video memory, try to release
                                unnecessary video surfaces</td></tr>
                        <tr><td>#GF_CAPT_ERROR_WRONG_CONFIG</td>
                            <td>Wrong input parameters, for example srcRect
                                size greater than pSrcSurf dimensions</td></tr>
                        <tr><td>#GF_CAPT_ERROR_NO_CALLBACK</td>
                            <td>No callback function available</td></tr>
                        </table>
                   */
} GFJXENCSTART, *PGFJXENCSTART;

/** JxEncAPI GFJXENCSTART::uiOptions flagbit: If set only bitstream is output,
    if unset JFIF header will be added.
    @see GFJXENCSTART, GFJxEncStart()
*/
#define GF_CAPT_BITSTREAM   1   

/** JxEncAPI GFJXENCSTART::uiOptions flagbit: Piecemeal encoding
    @todo clarify meaning
    @see GFJXENCSTART, GFJxEncStart()
*/
#define GF_CAPT_PIECE_MEAL  2

/** JxEncAPI GFJXENCSTART::Error return code: Not enough free video memory.
    Try to release unnecessary video surfaces.
    @see GFJXENCSTART, GFJxEncStart()
*/
#define GF_CAPT_ERROR_VIDEO_MEMORY_NOT_BIG_ENOUGH 1

/** JxEncAPI GFJXENCSTART::Error return code: Wrong input parameters.
    E.g. srcRect size greater than pSrcSurf dimensions.
    @see GFJXENCSTART, GFJxEncStart()
*/
#define GF_CAPT_ERROR_WRONG_CONFIG 2

/** JxEncAPI GFJXENCSTART::Error return code: No callback function available.
    @todo clarify
    @see GFJXENCSTART, GFJxEncStart()
*/
#define GF_CAPT_ERROR_NO_CALLBACK 4

/** Descriptor for JPEG encode buffers.
    This structure describes a buffer and its fill status for encoded
    JPEG data or raw YUV transfered from the JPEG encoder to the
    application. It is used with GFJxEncCapture() and GFJxEncFetchImage()
    in either polling or callback data fetch mode.

    @see GFJxEncCapture(), GFJxEncFetchImage(), GFJxEncPRComplete()
*/
typedef struct _GFJXENC_BUF {
    NvU8    *pBuf;          /**< Pointer to the buffer */
    NvU32   bufSize;        /**< Size of the buffer in bytes */
    NvU32   nBytesCaptured; /**< Number of bytes captured,
                                 app initializes to 0
                            */
} GFJXENC_BUF, *PGFJXENC_BUF;

/** Fetch buffer descriptor for use with GFJxEncFetchImage().
    This data structure is used by GFJxEncInterruptHandler() to fetch encoded
    image data when IntType is GFJX_ENC_STREAM_BUF_INTR or GFJX_ENC_DONE_INTR.
*/
typedef struct _GFJXENC_FETCH_BUF{
    PGFJXENC_BUF pBuf;
    NvU32        numOfBuf;
    NvU32        status;
} GFJXENC_FETCH_BUF, *PGFJXENC_FETCH_BUF;


/** JxEncAPI data fetch status code: All data of the current frame was fetched.
    @see GFJxEncFetchImage(), GFJxEncCapture()
*/
#define JXENC_DATA_COMPLETE         0x1

/** JxEncAPI data fetch status code: Data was fetched only partially.
    The application should make more calls to GFJxEncFetchImage() to fetch
    the rest.
    @see GFJxEncFetchImage(), GFJxEncCapture()
*/
#define JXENC_MORE_FETCH            0x2

/** JxEncAPI data fetch status code: New frame was encoded and is ready to
    fetch.
    @see GFJxEncFetchImage(), GFJxEncCapture()
*/
#define JXENC_NEW_FRAME             0x8

/** JxEncAPI data fetch status code: Time out error occured while encoded data is fetching.
    fetch.
    @see GFJxEncFetchImage(), GFJxEncCapture()
*/
#define JXENC_TIME_OUT              0x10

// definition of uiFeature for GFJxEncSetAttribute
//the following definations are for set only

/** JxEncAPI attribute: Choose preset QTable, coefficients in luma and chroma
    Qtable are all 1.
    
    Interpretation of associated data block: None.

    Attribute is set-only.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_SET_100QUALITY   0   

/** JxEncAPI attribute: Choose preset QTable, standard Qtable A and B,
    divided by 2.

    Interpretation of associated data block: None.

    Attribute is set-only.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_SET_85QUALITY    1   

/** JxEncAPI attribute: Choose preset QTable, standard Qtable A and B.

    Interpretation of associated data block: None.

    Attribute is set-only.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_SET_75QUALITY    2   

/** JxEncAPI attribute: Choose preset QTable, standard Qtable C and D.

    Interpretation of associated data block: None.

    Attribute is set-only.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_SET_50QUALITY    3   

/** JxEncAPI attribute: Choose preset QTable, standard Qtable C and D,
    multiplied by 2.

    Interpretation of associated data block: None.

    Attribute is set-only.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_SET_25QUALITY    4   

/** JxEncAPI attribute: Choose preset QTable, standard Qtable C and D,
    multiplied by 4.

    Interpretation of associated data block: None.

    Attribute is set-only.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_SET_12QUALITY    5   

//the following definations can be used for set and get

/** JxEncAPI attribute: Set custom luma QTable.

    Interpretation of associated data block:
    A table of 64 16-bit (type NvU16) entries with quantization coefficients
    to be used for luma MCU's.

    Attribute can be set and get.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_LQTABLE      6

/** JxEncAPI attribute: Set custom chroma QTable.

    Interpretation of associated data block:
    A table of 64 16-bit (type NvU16) entries with quantization coefficients
    to be used for chroma MCU's.

    Attribute can be set and get.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_CQTABLE      7

/** JxEncAPI attribute: Decimation filter enable/disable.

    Interpretation of associated data block:
    <pre>
    NvU32 decimation enable
          0 = disable
          1 = enable
    </pre>

    Attribute can be set and get.

    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_FILTER       8   

/** JxEncAPI attribute: Huffman bit stuffing.

    Interpretation of associated data block:
    <pre>
    NvU32 Huffman stuffing enable
          0 = disable
          1 = enable
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_HUFF_BSTUFF  13  

/** JxEncAPI attribute: Motion JPEG capturing mode enable/disable.

    Interpretation of associated data block:
    <pre>
    NvU32 Motion JPEG capturing mode enable
          0 = disable
          1 = enable
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_MOTION_JPEG  14

/** JxEncAPI attribute: Raw data capturing mode enable/disable.

    Interpretation of associated data block:
    <pre>
    NvU32 Raw data capturing mode enable
          0 = disable
          1 = enable
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_RAW_DATA     15

/** JxEncAPI attribute: Re-encode a JPEG bitstream.
        
    Registration of callback function for JPEG re-encode application:
    <pre>
    #PGFJXDECCALLBACK structure
    </pre>

    Attribute is set only.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_BITSTREAM    16

/** JxEncAPI attribute: JPEG encoding colour format.

    Only YUV420 and YUV422 encoding is supported. The JPEG encoder converts
    the incoming image to the configured colour format, and then encodes it
    in the JPEG bitstream.
    
      Only YUV420 and YUV422 are
    valid.

    Interpretation of associated data block:
    <pre>
    NvU32 Colour format identifier, one of:
          #GF_SURFACE_PLANAR_YUV422
          #GF_SURFACE_YUV420
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute(), GFRMSURFACE::ColorFormat
*/
#define JX_ENC_ENCODE_FORMAT    17

/** JxEncAPI attribute: Maximum JPEG byte size.

    The JPEG encoder will not generate a JPEG bitstream larger than this.

    Interpretation of associated data block:
    <pre>
    NvU32 Maximum size in bytes
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_MAX_SIZE     18

/** JxEncAPI attribute: Camera focal point.

    Image area which is close to the focal point will be encoded with higher
    quality. Takes effect only when #JX_ENC_MAX_SIZE is set.

    Interpretation of associated data block:
    <pre>
    NvU32 Focal point X position
    NvU32 Focal point Y position
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute(), #JX_ENC_DEGRADATION,
         #JX_ENC_MAX_SIZE
*/
#define JX_ENC_FOCAL_POINT  19

/** JxEncAPI attribute: Image quality degradation from focal point.

    Image areas further from the focal point get encoded with fewer bits.
    The number of bits is linearly degraded based on the percentage of
    degradation in the X and Y directions. This attribute takes effect only
    when JX_ENC_MAX_SIZE is set.

    Interpretation of associated data block:
    <pre>
    NvU32 X direction degradation percentage
    NvU32 Y direction degradation percentage
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute(), #JX_ENC_FOCAL_POINT,
         #JX_ENC_MAX_SIZE
*/
#define JX_ENC_DEGRADATION  20

/** JxEncAPI attribute: JPEG encode rotation and flip control.

    Interpretation of associated data block:
    <pre>
    NvU32 Rotation and flip control, one of the following constants
            #JX_ENC_ROTATE_0
            #JX_ENC_ROTATE_90
            #JX_ENC_ROTATE_180
            #JX_ENC_ROTATE_270
          optionally logically ORed with zero or more of the following flags
            #JX_ENC_H_FLIP
            #JX_ENC_V_FLIP
    </pre>

    Default is #JX_ENC_ROTATE_0.

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_ROTATION         21

/** JxEncAPI attribute: Rotation and flip control for rartial rotation API.

    Enables and configures the partial rotation engine for partially rotated
    JPEG encoding. Partially rotated JPEG encoding allows for rotated encoding
    of large image sizes with a small image capture buffer.

    Interpretation of associated data block:
    <pre>
    NvU32 Rotation and flip control, one of the following constants
            #JX_PRENC_ROTATE_UNSET - reset and disable partial rotation engine
            #JX_ENC_ROTATE_0
            #JX_ENC_ROTATE_90
            #JX_ENC_ROTATE_180
            #JX_ENC_ROTATE_270
          if not #JX_PRENC_ROTATE_UNSET optionally logically ORed with zero or
          more of the following flags
            #JX_ENC_H_FLIP
            #JX_ENC_V_FLIP
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_PARTIAL_ROTATE   22

/** JxEncAPI attribute: Bypass FIFO.

    Interpretation of associated data block:
    <pre>
    NvU32 Raw data capturing mode enable
          0 = Fetching encoded data through DMA FIFO
          1 = Fetching encoded data directly through output buffer not through
              DMA FIFO
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_BYPASS_FIFO      23

/** JxEncAPI attribute: Piece-Meal encoding.

    Interpretation of associated data block:
    <pre>
    NvU32 Piece-Meal encoding enable
          0 = enable
          1 = disable
    </pre>

    Attribute is get only.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_PIECE_MEAL       24

/** JxEncAPI attribute: Fetch Low bitstream.
    
    Registration of callback function for fetching raw data stream from JPEG encoder:
    <pre>
    #PGFJXDECCALLBACK structure
    </pre>

    Attribute is set only.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/

#define JX_ENC_RAW_DATA_STREAM     25

/** JxEncAPI attribute: Fetch Low JPEG bitstream.
    
    Registration of callback function for fetching JPEG raw data stream from JPEG encoder:
    <pre>
    #PGFJXDECCALLBACK structure
    </pre>

    Attribute is set only.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/

#define JX_ENC_RAW_JPEG_CAPTURE   26

/** JxEncAPI attribute: Set Timeout value

    
    Interpretation of associated data block:
    <pre>
    NvU32 timeout   timeout value
        0       = no timeout
        > 0     = timeout value
    </pre>

    Attribute is set only.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/

#define JX_ENC_TIMEOUT_CONF        27 

/** JxEncAPI attribute: Stop preview enable/disable.

    Interpretation of associated data block:
    <pre>
    NvU32 Stop preview mode enable
          0 = disable
          1 = enable
    </pre>

    Attribute can be set and get.
    @see GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/

#define JX_ENC_STOP_PREVIEW        28


/** Option for attributes #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE:
    Non-rotated JPEG encode.
    @see #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE, GFJxEncSetAttribute(),
         GFJxEncGetAttribute()
*/

#define JX_ENC_ROTATE_0                0x0

/** Option for attributes #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE:
    JPEG encode rotated 90 degrees.
    @see #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE, GFJxEncSetAttribute(),
         GFJxEncGetAttribute()
*/
#define JX_ENC_ROTATE_90               0x1

/** Option for attributes #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE:
    JPEG encode rotated 180 degrees.
    @see #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE, GFJxEncSetAttribute(),
         GFJxEncGetAttribute()
*/
#define JX_ENC_ROTATE_180              0x2

/** Option for attributes #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE:
    JPEG encode rotated 270 degrees.
    @see #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE, GFJxEncSetAttribute(),
         GFJxEncGetAttribute()
*/
#define JX_ENC_ROTATE_270              0x3

/** Option for attributes #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE:
    JPEG encode horizontally flipped.
    @see #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE, GFJxEncSetAttribute(),
         GFJxEncGetAttribute()
*/
#define JX_ENC_H_FLIP                  0x10

/** Option for attributes #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE:
    JPEG encode vertically flipped.
    @see #JX_ENC_ROTATION, #JX_ENC_PARTIAL_ROTATE, GFJxEncSetAttribute(),
         GFJxEncGetAttribute()
*/
#define JX_ENC_V_FLIP                  0x20

/** Option for attribute #JX_ENC_PARTIAL_ROTATE: Reset and disable partial
    rotation.
    Pass this to GFJxEncSetAttribute() for attribute #JX_ENC_PARTIAL_ROTATE
    to unset the Partial Rotation Flag and reset the PR Engine.
    @see #JX_ENC_PARTIAL_ROTATE, GFJxEncSetAttribute(), GFJxEncGetAttribute()
*/
#define JX_ENC_ROTATE_UNSET            0xff

typedef void (*GFJX_ENC_CALLBACK)(void *userData);

/** JxEncAPI interrupt operation types.
    Constants to specify operation for a call to GFJxEncInterruptControl().
    @see GFJX_ENC_INTERRUPT_TYPE, GFJxEncInterruptControl()
*/
typedef enum
{
    /** Enable interrupt/status assertion for an interrupt type. */
    GFJX_ENC_INTERRUPT_ENABLE,

    /** Disable interrupt/status assertion for an interrupt type. */
    GFJX_ENC_INTERRUPT_DISABLE,

    /** Clear interrupt/status assertion for an interrupt type. */
    GFJX_ENC_INTERRUPT_CLEAR,

    /** Query for interrupt/status assertion for an interrupt type. */
    GFJX_ENC_INTERRUPT_QUERY_STATUS,

    /** Set DMA FIFO threshold. */
    GFJX_ENC_INTERRUPT_SET_DMA_FIFO_THRESHOLD,

    /** Get DMA FIFO threshold. */
    GFJX_ENC_INTERRUPT_GET_DMA_FIFO_THRESHOLD, 

    /** Set strean buffer threshold. */
    GFJX_ENC_INTERRUPT_SET_BUF_THRESHOLD, 

    /** Get strean buffer threshold. */
    GFJX_ENC_INTERRUPT_GET_BUF_THRESHOLD      

} GFJX_ENC_INTERRUPT_OPERATION_TYPE;    


/** JxEncAPI interrupt types.
    @see GFJX_ENC_INTERRUPT_OPERATION_TYPE, GFJxEncInterruptControl()
*/
typedef enum
{
    /** JPEG read DMA FIFO low threshold.
        Interrupt/status is asserted if the JPEG read DMA FIFO status is less
        than the JPEG read DMA FIFO threshold value.
    */
    GFJX_ENC_DMA_FIFO_LOW_INTR = 0,   

    /** JPEG read DMA FIFO high threshold.
        Interrupt/status is asserted if the JPEG read DMA FIFO status is
        greater than or equal to the JPEG read DMA FIFO threshold value.
    */
    GFJX_ENC_DMA_FIFO_HIGH_INTR = 0x1,

    /** Stream buffer threshold interrupt. */
    GFJX_ENC_STREAM_BUF_INTR = 0x2,       

    /** Main buffer end hit interrupt. */
    GFJX_ENC_MAIN_BUF_HIT_INTR = 0x4,     

    /** Encoding done interrupt. */
    GFJX_ENC_DONE_INTR = 0x8,             

    /** Encoded stream transfer done interrupt. */
    GFJX_ENC_TRANSFER_DONE_INTR = 0x10,   

    /** Maximum bit count hit interrupt. */
    GFJX_ENC_MAX_BIT_HIT_INTR = 0x20,     

    /** Circular buffer overflow interrupt. */
    GFJX_ENC_CIR_BUF_OVERFLOW_INTR = 0x40 

}  GFJX_ENC_INTERRUPT_TYPE;

/** JxEncAPI virtual function pointer table. */
typedef struct _GFJXENCTABLE
{
    GF_RETTYPE (* JxEncGetProperty)(GFJxEncHandle hJxEnc, PGFPROPERTY pJXProp);
    GF_RETTYPE (* JxEncSetAttribute)(GFJxEncHandle hJxEnc,
        NvU32 uiFeature, NvU32* pInfo);
    GF_RETTYPE (* JxEncGetAttribute)(GFJxEncHandle hJxEnc, 
        NvU32 uiFeature, NvU32* pInfo);
    GF_RETTYPE (* JxEncStart)(GFJxEncHandle hJxEnc, PGFJXENCSTART pStart);
    GF_RETTYPE (* JxEncFetchImage)(GFJxEncHandle hJxEnc, 
        PGFJXENC_BUF aBuf, NvU32 nBuf, NvU32 *pStatus);
    GF_RETTYPE (* JxEncEnd)(GFJxEncHandle hJxEnc);
    GF_RETTYPE (* JxEncSetupInterrupt)(GFJxEncHandle hJxEnc, 
        void (*Inter)(void *), void *IPara);
    GF_RETTYPE (* JxEncCapture)(GFJxEncHandle hJxEnc, 
        PGFJXENC_BUF aBuf, NvU32 nBuf, NvU32 *pStatus); 
    GF_RETTYPE (* JxEncInterruptControl)(GFJxEncHandle hJxEnc,
       GFJX_ENC_INTERRUPT_TYPE IntType, GFJX_ENC_INTERRUPT_OPERATION_TYPE op,
       void * pData);
    GF_RETTYPE (* JxEncInterruptHandler)(GFJxEncHandle hJxEnc, 
            GFJX_ENC_INTERRUPT_TYPE IntType, void * pData); // Reserved.
    GF_RETTYPE (*JxEncPRComplete)(GFJxEncHandle hJxEnc,
        PGFJXENC_BUF inBuf,NvU32 inBufNum,PGFJXENC_BUF outBuf,
        NvU32 outBufNum,PGFJXENC_BUF dcacBuf,NvU32 dcacBufNum);
    GF_RETTYPE (*JxEncBracket)(GFJxEncHandle hJxEnc,
                               GFJX_ENC_CALLBACK before,
                               GFJX_ENC_CALLBACK after,
                               void *userData);                                  
} GFJXENCTABLE, *PGFJXENCTABLE;

#ifdef PROJECT_SEC_G1
// Attribute constant and data structure for EXIF
#define JX_ENC_SET_EXIF_INFO    30

typedef struct _GFJXENCEXIFINFO
{
    NvS8    CameraMaker[32];
    NvS8    CameraModel[40];
    NvS8    FirmwareVersion[5];
    NvU32   FNumberNum;
    NvU32   FNumberDenom;
    NvS32   ExpBiasNum;
    NvS32   ExpBiasDenom;
    NvU16   WhiteBalance;
    NvU32   DigitalZoomNum;
    NvU32   DigitalZoomDenom;
} GFJXENCEXIFINFO;
#endif

// Typesafe functions for opening and closing this component
GF_RETTYPE GFJxEncOpen(GFRmHandle hRm, GFJxEncHandle *phJxEnc,
                       GF_STATE_TYPE state, GFRmChHandle hCh);
void GFJxEncClose(GFJxEncHandle *phJxEnc);

/* #### JxEnc Helper macros.  Maybe useful for backward compatible API. #### */

/** @name Functions
@{*/

/** This function returns version and capabilities of API and hardware.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param pJXProp (PGFPROPERTY) Pointer to property structure to be filled in

    @retval #GF_SUCCESS \a pJXProp filled in successfully
    @retval #GF_ERROR   Some error occured

    The #GFPROPERTY structure passed with parameter \a pJXProp will be
    filled in on successfull return. The GFPROPERTY::Capability field
    will hold a combination of flagbits indicating capabilities specific
    to the JxEncAPI:

    <table>
    <tr><td>#GF_JX_ENC_CAP_QTABLE      </td>
        <td>JPEG quantization table is programmable.</td></tr>   
    <tr><td>#GF_JX_ENC_CAP_INTERRUPT   </td>
        <td>Interrupt data capture mode and polling mode supported,
            if this flag is off then only polling mode is supported.</td></tr>
    <tr><td>#GF_JX_ENC_CAP_DIGITAL_ZOOM</td>
        <td>Digital zoom supported.</td></tr>
    <tr><td>#GF_JX_ENC_CAP_MOTION_JPEG </td>
        <td>Motion JPEG mode supported.</td></tr>
    <tr><td>#GF_JX_ENC_CAP_RATE_CONTROL</td>
        <td>Rate control supported.</td></tr>
    <tr><td>#GF_JX_ENC_CAP_422_PLANAR  </td>
        <td>Planar YUV422 data supported.</td></tr>
    <tr><td>#GF_JX_ENC_CAP_ROTATION    </td>
        <td>Rotation supported.</td></tr>
    </table>

    It is a good practice to call this function to query for the API version
    and its capabilities before using the rest of the JxEncAPI functions.

    @see GFPROPERTY
*/
#define GFJxEncGetProperty(hJxEnc, pJXProp) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncGetProperty(hJxEnc, pJXProp)

/** Set configuration of a feature of the JPEG encoder hardware.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param uiFeature (NvU32) Feature type identifier, see table.
    @param pInfo (NvU32*) Pointer to feature specific input parameter block.
                          Pointer type will be reinterpreted according to
                          feature type.

    @retval #GF_SUCCESS Configuration changed successfully
    @retval #GF_ERROR   Some error occured

    The feature to be set is identified with parameter \a uiFeature,
    specific input parameters are passed via a block in parameter \a pInfo.
    The contents of this data block is interpreted depending on the
    feature to be set.

    The following features are defined, for the data to be provided in
    \a pInfo see the individual attribute's documentation.

    <table>
    <tr><td>\b Attribute </td><td>\b Direction </td><td>\b Synopsis </td></tr>
    <tr><td>#JX_ENC_SET_100QUALITY</td><td>set     </td>
        <td>Choose preset QTable, coefficients in luma
            and chroma Qtable are all 1.</td></tr>
    <tr><td>#JX_ENC_SET_85QUALITY </td><td>set     </td>
        <td>Choose preset QTable, standard Qtable A and B,
        divided by 2.</td></tr>
    <tr><td>#JX_ENC_SET_75QUALITY </td><td>set     </td>
        <td>Choose preset QTable, standard Qtable A and B.</td></tr>
    <tr><td>#JX_ENC_SET_50QUALITY </td><td>set     </td>
        <td>Choose preset QTable, standard Qtable C and D.</td></tr>
    <tr><td>#JX_ENC_SET_25QUALITY </td><td>set     </td>
        <td>Choose preset QTable, standard Qtable C and D,
        multiplied by 2.</td></tr>
    <tr><td>#JX_ENC_SET_12QUALITY </td><td>set     </td>
        <td>Choose preset QTable, standard Qtable C and D,
        multiplied by 4.</td></tr>  
    <tr><td>#JX_ENC_LQTABLE       </td><td>set, get</td>
        <td>Set custom luma QTable.</td></tr>
    <tr><td>#JX_ENC_CQTABLE       </td><td>set, get</td>
        <td>Set custom chroma QTable.</td></tr>
    <tr><td>#JX_ENC_FILTER        </td><td>set, get</td>
        <td>Decimation filter enable/disable.</td></tr>
    <tr><td>#JX_ENC_HUFF_BSTUFF   </td><td>set, get</td>
        <td>Huffman bit stuffing.</td></tr>
    <tr><td>#JX_ENC_MOTION_JPEG   </td><td>set, get</td>
        <td>Motion JPEG capturing mode enable/disable.</td></tr>
    <tr><td>#JX_ENC_RAW_DATA      </td><td>set, get</td>
        <td>Raw data capturing mode enable/disable.</td></tr>
    <tr><td>#JX_ENC_BITSTREAM     </td><td>set     </td>
        <td>Re-encode a JPEG bitstream.</td></tr>
    <tr><td>#JX_ENC_ENCODE_FORMAT </td><td>set, get</td>
        <td>JPEG encoding colour format.</td></tr>
    <tr><td>#JX_ENC_MAX_SIZE      </td><td>set, get</td>
        <td>Maximum JPEG byte size.</td></tr>
    <tr><td>#JX_ENC_FOCAL_POINT   </td><td>set, get</td>
        <td>Camera focal point.</td></tr>
    <tr><td>#JX_ENC_DEGRADATION   </td><td>set, get</td>
        <td>Image quality degradation from focal point.</td></tr>
    <tr><td>#JX_ENC_ROTATION      </td><td>set, get</td>
        <td>JPEG encode rotation and flip control.</td></tr>
    <tr><td>#JX_ENC_PARTIAL_ROTATE</td><td>set, get</td>
        <td>Rotation and flip control for Partial Rotation API.</td></tr>
    <tr><td>#JX_ENC_BYPASS_FIFO   </td><td>set, get</td>
        <td>Bypass FIFO.</td></tr>
    <tr><td>#JX_ENC_PIECE_MEAL    </td><td>get     </td>
        <td>Piece-Meal encoding.</td></tr>
    <tr><td>#JX_ENC_STOP_PREVIEW   </td><td>set, get</td>
        <td>Stop preview mode enable/disable.</td></tr>
    <tr><td>#JX_ENC_RAW_JPEG_CAPTURE     </td><td>set     </td>
        <td>Fetch Low JPEG bitstream.</td></tr>
    <tr><td>#JX_ENC_RAW_DATA_STREAM     </td><td>set     </td>
        <td>Fetch Low bitstream.</td></tr>
    <tr><td>#JX_ENC_TIMEOUT_CONF     </td><td>set, get</td>
        <td>Set Timeout value.</td></tr>        
    </table>
 
    Most of the time an application should only set a quantization table for
    luminance or chrominance. These quantization tables are in the same format
    as standard quantization tables (1 to 255). Other features are hardware
    dependent.

    @see GFJxEncGetAttribute()
*/
#define GFJxEncSetAttribute(hJxEnc, uiFeature, pInfo) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncSetAttribute(hJxEnc, uiFeature, pInfo)

/** Get current configuration of a feature of the JPEG encoder hardware.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param uiFeature (NvU32) Feature type identifier, 
                             see table in GFJxEncSetAttribute().
    @param pInfo (NvU32*) Pointer to feature specific input parameter block.
                          Pointer type will be reinterpreted according to
                          feature type.

    @retval #GF_SUCCESS \a pInfo filled in successfully
    @retval #GF_ERROR   Some error occured

    @see GFJxEncSetAttribute()
*/
#define GFJxEncGetAttribute(hJxEnc, uiFeature, pInfo) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncGetAttribute(hJxEnc, uiFeature, pInfo)

/** Setup JxEncAPI for JPEG encoding.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param pStart   (#PGFJXENCSTART) Pointer to #GFJXENCSTART structure for
                                definition of encode source and destination

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured, check GFJXENCSTART::Error for
                        detailed error reason code.

    Before starting capture, the application should call this function to setup
    the encoder. Once this function has been called, the application can use
    GFJxEncCapture() to capture as many frames as desired. JxEncCapture()
    starts and optionally fetches data for a frame. JxEncFetchImageData()
    fetches the image data to host CPU side. An application should keep calling
    it until all encoded data is processed. Finally GFJxEncEnd() has to be
    called to release the encoder.

    Parameter \a pStart passes a #GFJXENCSTART structure describing image data
    source, source cropping area, and destination size.

    Encoding is from one of the following sources:
    - VI (Camera, cropping and scale up/down is done via VxVIPSet(), 
          Rotation/flip is done via JxEncSelectEPPRotation() )
    - Screen encoding (GC, source is primary surface)
    - Bitstream encoding. This is used to re-encode a JPEG bit stream, and
      invokes JxDecAPI internally to decode the existing bitstream.                         
      The following options are available for bitstream re-encoding:
        - Crop image size
        - Scale up        
        - Change QTables
        - Apply rate control
        - Rotation (0, 90, 180, 270, H-Flip, V-Flip) 

    On failure an error reason code is returned in field GFJXENCSTART::Error of
    parameter \a pStart.

    @see GFJXENCSTART, GFJxEncSetAttribute(), GFJxEncCapture(),
         GFJxEncFetchImage(), GFJxEncEnd()
*/
#define GFJxEncStart(hJxEnc, pStart) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncStart(hJxEnc, pStart)

/** Polls JxEncAPI for data fetch from JPEG encoder.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param aBuf     (#PGFJXENC_BUF) Pointer to array of #GFJXENC_BUF structures
    @param nBuf     (NvU32)         Number of pointers passed with \a aBuf.
    @param pStatus  (NvU32)         Returns data fetch status, see table

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured

    Captures the JPEG encoded bit stream in the given application owned
    buffers. Capturing the encoded image can be done in polling or interrupt
    mode. This function should be called after GFJxEncCapture(). It is usually
    called from either the application's fetching poll loop, or the interrupt
    callback routine set up with GFJxEncSetupInterrupt().

    The application must fill all the fields in the referenced buffer
    structures and must make sure each PGFJXENC_BUF::nBytesCaptured is set
    to 0. The PGFJXENC_BUF::nBytesCaptured field is updated by the JXEncAPI
    to show the actual number of bytes captured. JXEncAPI keeps filling the
    buffers in the array until it exhausts all the buffers. If all the buffers
    are exhausted and there is more data to be copied, the function returns
    and sets \a pStatus to #JXENC_MORE_FETCH. The application should then keep
    calling GFJxEncFetchImage() to fetch the remaining data. Each buffer in
    the array should be a multiple of 64 bytes for best performance.

    The status of the data fetch is returned in \a pStatus as one of the
    following reason codes:

    <table>
    <tr><td>#JXENC_DATA_COMPLETE</td><td>All data of the current frame was
            fetched.</td></tr>
    <tr><td>#JXENC_MORE_FETCH   </td><td>Data was fetched only partially.
            The application should make more calls to GFJxEncFetchImage() to
            fetch the rest.</td></tr>    
    <tr><td>#JXENC_NEW_FRAME    </td><td>A new frame was encoded and is ready
            to fetch.</td></tr>
    <tr><td>#JXENC_TIME_OUT     </td><td>Timeout on GFJxEncFetchImage
            </td></tr>
    </table>

    @see GFJxEncCapture(), GFJxEncSetupInterrupt(), #GFJXENC_BUF
*/
#define GFJxEncFetchImage(hJxEnc, aBuf, nBuf, pStatus) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncFetchImage(hJxEnc, aBuf, nBuf, pStatus)

/** Polls JxEncAPI for data fetch from JPEG encoder.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured

    This function disables the encoder and releases internal resources related
    to the current capture.

    @see GFJxEncStart()
*/
#define GFJxEncEnd(hJxEnc) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncEnd(hJxEnc)

/** Register a callback function for fetching encoded JPEG data.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param Inter (void(*)(void *)) Application callback function pointer
    @param IPara (void*) Parameter to pass on to application callback function

    @retval #GF_SUCCESS Callback installed successfully
    @retval #GF_ERROR   Some error occured

    This function can be used to register a callback function for fetching
    encoded JPEG data. This function must be called before GFJxEncCapture().
    The callback function must meet the following prototype:

    <pre>
    void InterruptCallback(void* lPara);
    </pre>

    Whenever encoding is triggered, JXEncAPI calls the registered interrupt
    callback function, passing on the application defined parameter \a IPara.

    Inside the callback function, the application can call GFJxEncFetchImage()
    to portionally fetch the encoded datastream.

    If no callback function shall be used, the application could alternatively
    use a polling scheme.

    @see GFJxEncCapture()
*/
#define GFJxEncSetupInterrupt(hJxEnc, Inter, IPara) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncSetupInterrupt(hJxEnc, Inter, IPara)

/** Trigger JPEG encoder for one frame and optionally display capture preview.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param aBuf     (#PGFJXENC_BUF) Pointer to array #GFJXENC_BUF structures
    @param nBuf     (NvU32)         Number of pointers passed with \a aBuf, if
                                    passing 0 then the function is non-blocking
    @param pStatus  (NvU32)         Returns data fetch status, for reason codes
                                    see table at GFJxEncFetchImage() 

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured

    Triggers the JPEG encoder for a frame and optionally displays the same
    frame in a preview window in decimated form.

    Encoded data can be fetched via a polling scheme or via an interrupt
    handler set up with GFJxEncSetupInterrupt(). In any case
    GFJxEncFetchImage() is used to transfer encoded data to application
    buffers.

    If application set up an interrupt handler to fetch encoded data, then
    \a nBuf should be passed as 0. 

    This function can optionally fetch data right after triggering encoding to
    buffers provided via \a aBuf. This will block the CPU until all data is
    returned or buffer space is exhausted. If \a nBuf is 0, the function
    returns right away and \a pStatus is updated to #JXENC_NEW_FRAME to
    indicate data is pending. The application should then call
    GFJxEncFetchImage() either from an interrupt handler or from same thread to
    fetch the encoded/raw data.

    If \a nBuf is not 0, it specifies the number of buffers in the array
    \a aBuf. The function will block until it runs out of buffers. It
    will return #JXENC_MORE_FETCH in parameter \a pStatus if more data is
    available. The application must call GFJxEncFetchImage() to fetch the
    remaining data. See GFJxEncFetchImage() for information on return
    status codes and how the passed buffers are handled.

    JPEG Encoding from camera or raw data capture from camera happens in
    realtime, so if the internal circular buffer in GPU memory is not big
    enough then GFJxEncFetchImage() should be called more fequently to empty
    the outputBuf and avoid buffer overflows.

    @see GFJxEncSetupInterrupt(), GFJxEncFetchImage(), #GFJXENC_BUF
*/
#define GFJxEncCapture(hJxEnc, aBuf, nBuf, pStatus) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncCapture(hJxEnc, aBuf, nBuf, pStatus)

/** JxEncAPI Component-level interrupt control.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param IntType  (#GFJX_ENC_INTERRUPT_TYPE) JxEncAPI interrupt type
    @param op       (#GFJX_ENC_INTERRUPT_OPERATION_TYPE) GFJxEncAPI interrupt
                    operation
    @param pData    (void*) Pointer to input or output data block, see table

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured
    @retval #GF_ERROR_BAD_PARAMETER Invalid parameters

    The following operations (parameter <i>op</i>) are defined for this call.

    <b>Operation #GFJX_ENC_INTERRUPT_ENABLE</b>

        Enable status/interrupt generation for interrupts of type specified by
        \a IntType.
    
        Depending on the interrupt type additional action and the parameter
        \a pData is interpreted as following:
        <table>
        <tr>
            <td>#GFJX_ENC_DMA_FIFO_LOW_INTR </td>
            <td>JPEG read DMA FIFO status/interrupt generation is put into low
                threshold mode, i.e. interrupt/status is asserted if the JPEG
                read DMA FIFO status is less than the threshold value.

                \a pData points to block containing: <br>
                <code>NvU32 DMA FIFO low threshold value in range 0..15</code>

                \a pData can be NULL to leave the threshold value unchanged.
            </td>
        </tr>
        <tr>
            <td>#GFJX_ENC_DMA_FIFO_HIGH_INTR</td>
            <td>JPEG read DMA FIFO status/interrupt generation is put into
                high threshold mode, i.e. interrupt/status is asserted if the
                JPEG read DMA FIFO status is greater than or equal toless than
                the threshold value.

                \a pData points to block containing: <br>
                <code>NvU32 DMA FIFO high threshold value in range 0..15</code>

                \a pData can be NULL to leave the threshold value unchanged.
            </td>
        </tr>
        <tr>
            <td>#GFJX_ENC_STREAM_BUF_INTR   </td>
            <td>\a pData points to block containing: <br>
                <code>NvU32 JPEG stream buffer threshold value in bytes, must
                be multiple of 8</code>

                \a pData can be NULL to leave the threshold value unchanged.
            </td>
        </tr>
        <tr>
            <td>otherwise</td>
            <td>\a pData is ignored</td>
        </tr>
        </table>

    <b>Operation #GFJX_ENC_INTERRUPT_DISABLE</b>

        Disable status/interrupt generation for interrupts of type specified by
        \a IntType.
  
    <b>Operation #GFJX_ENC_INTERRUPT_CLEAR</b>

        Clear status/interrupt assertion for interrupt of type specified by
        \a IntType.

    <b>Operation #GFJX_ENC_INTERRUPT_QUERY_STATUS</b>

        Return current status/interrupt assertion for interrupt of type
        specified by \a IntType. The state is returned in the block referenced
        by \a pData.

        Interpretation of associated data block \a pData
        <pre>
        NvU32 Interrupt/status assertion state, one of:
              GF_INTERRUPT_ON_STATUS_TRUE = asserted
              GF_INTERRUPT_ON_STATUS_FALSE = not asserted
        </pre>

    <b>Operation #GFJX_ENC_INTERRUPT_SET_DMA_FIFO_THRESHOLD</b>

        Set DMA FIFO threshold value that controls interrupt/status assertion
        for interrupt types #GFJX_ENC_DMA_FIFO_LOW_INTR and
        #GFJX_ENC_DMA_FIFO_HIGH_INTR.

        Interpretation of associated data block \a pData
        <pre>
        NvU32 DMA FIFO threshold value in range 0..15
        </pre>

    <b>Operation #GFJX_ENC_INTERRUPT_GET_DMA_FIFO_THRESHOLD</b>

        Return DMA FIFO threshold value that controls interrupt/status
        assertion for interrupt types #GFJX_ENC_DMA_FIFO_LOW_INTR and
        #GFJX_ENC_DMA_FIFO_HIGH_INTR.

        Interpretation of associated data block \a pData
        <pre>
        NvU32 DMA FIFO threshold value in range 0..15
        </pre>

    <b>Operation #GFJX_ENC_INTERRUPT_SET_BUF_THRESHOLD</b>

        Set JPEG stream buffer threshold value that controls interrupt/status
        assertion for interrupt type #GFJX_ENC_STREAM_BUF_INTR.

        Interpretation of associated data block \a pData
        <pre>
        NvU32 DMA read buffer threshold value in bytes, must be multiple of 8
        </pre>

    <b>Operation #GFJX_ENC_INTERRUPT_GET_BUF_THRESHOLD</b>

        Return JPEG stream buffer threshold value that controls
        interrupt/status assertion for interrupt type
        #GFJX_ENC_STREAM_BUF_INTR.

        Interpretation of associated data block \a pData
        <pre>
        NvU32 DMA read buffer threshold value in bytes, must be multiple of 8
        </pre>

    @see GFJX_ENC_INTERRUPT_TYPE, GFJX_ENC_INTERRUPT_OPERATION_TYPE
*/
#define GFJxEncInterruptControl(hJxEnc, IntType, op, pData)\
 ((PGFJXENCTABLE)hJxEnc)->JxEncInterruptControl(hJxEnc, IntType, op, pData)

/** Standard interrupt handler for fetching encoded JPEG data.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param IntType  (#GFJX_ENC_INTERRUPT_TYPE) JxEncAPI interrupt type
    @param pData    (void*) Pointer to input or output data block,
                    depending on \a IntType. See table.

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured

    <table>
    <tr><td>\a IntType </td><td>Interpretation of \a pData </td></tr>
    <tr><td>#GFJX_ENC_STREAM_BUF_INTR, GFJX_ENC_DONE_INTR</td>
        <td>#PGFJXENC_FETCH_BUF</td></tr>
    </table>

    Usually this callback is not used, because the interrupt service thread
    at the application level can call GFJxEncFetchImage() directly to
    complete the task of fetching encoded data.

    @todo clarify
    @see GFJxEncFetchImage()
*/
#define GFJxEncInterruptHandler(hJxEnc, IntType, pData)\
    ((PGFJXENCTABLE)hJxEnc)->JxEncInterruptHandler(hJxEnc, IntType, pData)

/** Generate final JPEG bitstream from a partially rotated bitstream.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param inBuf      (#PGFJXENC_BUF) Pointer to array of #GFJXENC_BUF structs
                                      holding fragmented input bitstream
    @param inBufNum   (NvU32)         Size of array \a inBuf
    @param outBuf     (#PGFJXENC_BUF) Pointer to array of #GFJXENC_BUF structs
                                      to output fragmented JPEG bitstream
    @param outBufNum  (NvU32)         Size of array \a outBuf
    @param dcacBuf    (#PGFJXENC_BUF) ?
    @param dcacBufNum (NvU32)         Size of array \a dcacBuf

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured

    @todo clarify
*/
#define GFJxEncPRComplete(hJxEnc,inBuf,inBufNum,outBuf,outBufNum,dcacBuf,dcacBufNum)\
    ((PGFJXENCTABLE)hJxEnc)->JxEncPRComplete(hJxEnc,inBuf,inBufNum,outBuf,outBufNum,dcacBuf,dcacBufNum)

/** Provide callbacks for immediately before and after any encode events.
    These will be called by JxEncode() when it is invoked.
    Calling this routine a second time will overwrite previously set
      values.

    @param hJxEnc (#GFJxEncHandle) Handle to JxEncAPI
    @param before (#GFJX_ENC_CALLBACK) proc to call before capture
    @param after  (#GFJX_ENC_CALLBACK) proc to call after capture
    @param userData (void *)     data to be supplied to before() and
                                 after() when they are invoked.

    @retval #GF_SUCCESS Success
    @retval #GF_ERROR   Some error occured
*/
#define GFJxEncBracket(hJxEnc, before, after, userData) \
    ((PGFJXENCTABLE)hJxEnc)->JxEncBracket(hJxEnc, before, after, userData)

/*@}*/
/*@}*/
 /** @page pageJxEncAppNotes JxEncAPI Application Notes

    @section pageJxEncAppNotes1 Programming Sequence

    The following procedure requires that GFRmOpen() is called first to start GFSDK usage. 
    The description is for a typical case where encoding of a still image being captured 
    from a camera is done and preview shown on the display.

    1. In case of camera encoding, setup the camera & initialize VIP. <br>

    2. Obtain the handle specific to JPEG encoder by calling GFJxEncOpen(). <br>

    3. Call GFRmSurfaceAlloc() to allocate one referance surface for encoding purposes. <br>

    4. Call GFJxEncSetAttribute() if specific features need to be set, 
       such as encoding width, encoding height, rotation, quality factor, etc. <br>

    5. Start the encoding by calling GFJxEncStart(). <br>
    
    6. If the current source image is from the CPU, the application should call GFJxEncFeedImage() 
       to feed the image to the GFJxEncAPI via GFJxEncCapture().<br>
    
    7. The application should fetch the encoded stream by calling GFJxEncFetchImage().
       Application should keep it calling till whole encoded data is out. <br>
    
    8. For exiting, free all relevent resources and call GFJxEncEnd() to free the JPEG encoder component. <br>

    */
#ifdef __cplusplus
}  // only need to export C interface if
              // used by C++ source code
#endif

#endif //_GF_JPEG_ENC__