#ifndef __ZMF_EXT_H__
#define __ZMF_EXT_H__
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif

/**
 * The pixel format supported by ZMF
 */
typedef enum {
    ZmfPixelFormatI420              = 1,
    ZmfPixelFormatIYUV              = 2,
    ZmfPixelFormatRGB24             = 3,
    ZmfPixelFormatABGR              = 4,
    ZmfPixelFormatARGB              = 5,
    ZmfPixelFormatARGB4444          = 6,
    ZmfPixelFormatRGB565            = 7,
    ZmfPixelFormatARGB1555          = 8,
    ZmfPixelFormatYUY2              = 9,
    ZmfPixelFormatYV12              = 10,
    ZmfPixelFormatUYVY              = 11,
    ZmfPixelFormatMJPG              = 12,
    ZmfPixelFormatNV21              = 13,
    ZmfPixelFormatNV12              = 14,
    ZmfPixelFormatBGRA              = 15
} ZmfPixelFormatType;

/**
 * zmf video file format:
 * [HEAD][LAYER]*
 * HEAD -> uint16_t<WIDHT>, uint16_t <HEIGHT>, uint8_t <FPS>
 * LAYER-> ZmfFileVideoLayer, [Fragment]*
 * Fragment -> uint16_t<LENGTH>, [DATA]
 *
 * - WIDHT, HEIGHT, LENGTH is big endian
 * - DATA is byte buffer
 */
typedef struct {
    /** the number of fragment in one layer */
    unsigned char numFragments;
    /** fragment level = fragPriority << 8 |  fragSvcLevel
     * 0x80 is last layer bit in one image frame, i.e. ZmfVideoCaptureEncoder.bLastFrag
     * 0x70 is layer index, i.e. ZmfVideoCaptureEncoder.simulcastIdx
     */
    unsigned char fragPriority;
    /** 0x40 is keyframe bit */
    unsigned char fragSvcLevel;
} ZmfFileVideoLayer;

/**
 * runtime state of external capture encoder
 */
typedef struct {
    /** [in] codec name */
    const char* plName;
    /** [in] encoded data length */
    unsigned bufLength : 16;
    /** [in] fragment level */
    unsigned fragLevel : 16;
    /** [in] whelther the current captured buffer is last fragment ine one layer */
    unsigned bLastFrag : 1;
    /** [in] whelther the current captured buffer is last layer in one frame*/
    unsigned bLastLayer: 1;
    /** [in] layer index */
    unsigned simulcastIdx : 6;
    /** [in] whelther the current layer is keyframe */
    unsigned bKeyFrame : 1;
    /** [out] set next output keyframe */ 
    unsigned nextKeyFrame : 1;
    /** [out] set new framerate [0-64] */
    unsigned newFrameRate : 6; 
    /** [out] notify percent loss [0-100] */
    unsigned packetLoss   : 16;
    /** [out] set new bitrate, kbps */
    unsigned newBitRate   : 16;
    /** [out] notify rtt, ms */
    unsigned rtt          : 16;
} ZmfVideoCaptureEncoder;

/** the callback to receive captured image
 * iImgAngle - iCamOrient equal to device rotate angle.
 * if encoder is NULL, the pixel format of buf must be ZmfPixelFormatI420
 *
 * @param[in] pUser   the user data registered by Zmf_VideoCaptureAddCallback
 * @param[in] captureId the id of captured image
 * @param[in] iFace   the capture Face
 * @param[in] iImgAngle the image rotated angle (CW)
 * @param[in] iCamOrient the camera fixed orient
 * @param[in] iWidth  the image width
 * @param[in] iHeight the image height
 * @param[in] buf     the image data buffer
 * @param[in] len     the image data length
 * @param[in,out] encoder capture encoder
 */
typedef void (*ZmfVideoCaptureCallback)(void* pUser, const char* captureId, int iType, 
                                        int iImgAngle, int iCamOrient, int* iWidth, int* iHeight,
                                        unsigned char *buf, ZmfVideoCaptureEncoder* encoder);

/**
 * The callback to receive video render data 
 *
 * @param[in] pUser         the user data registered by Zmf_AddVideoRenderCallback
 * @param[in] renderId      video render unique name
 * @param[in] sourceType    video render source type @see ZmfVideoSourceType
 * @param[in] iAngle        
 * @param[in] iMirror 
 * @param[in] iWidth
 * @param[in] iHeight
 * @param[in] buf           I420 render data
 *
 * @return                  if process render data should return > 0, other 0
 *
 * @remarks
 *  if buf == 0 or iWidth ==0 or iHeight == 0, means the render will close,
 *  so should call Zmf_OnVideoRenderRequestRemove.
 */
typedef int  (*ZmfVideoRenderCallback)(void* pUser, const char* renderId, int sourceType, int iAngle,
                                       int iMirror, int* iWidth, int* iHeight, unsigned char *buf,
                                       unsigned long timeStamp);

/** the callback to fill audio output buffer
 * @param[in] pUser  the user data registered by Zmf_AddAudioOutputCallback
 */
typedef int  (*ZmfAudioOutputCallback)(void* pUser, const char* outputId, int iSampleRateHz, int iChannels,
                                       unsigned char *buf, int len);

/** the callback to receive audio input data 
 *
 * @param[in] pUser  the user data registered by Zmf_AddAudioInputCallback
 * @param[in] inputId       unique name of the audio input
 * @param[in] sampleRateHz  the sample rating of the pcm data
 * @param[in] iChannels     the channel number of the pcm data
 * @param[in] buf           the pcm data
 * @param[in] len           the pcm data length
 * @param[in,out] micLevel  
 * @param[in] playDelayMS   the play delay ms
 * @param[in] recDelayMS    the record dely ms
 * @param[in] clockDrift    the clock drift ms
 */
typedef void (*ZmfAudioInputCallback)(void* pUser, const char* inputId, int iSampleRateHz, int iChannels,
                                      const unsigned char *buf, int len, int *micLevel,
                                      int playDelayMS, int recDelayMS, int clockDrift);
/**
 * The Event Callback
 *
 */
typedef void (*ZmfEventListenCallback) (int iEventType, const char *json, int len);


/**
 * The sensor data input data entry to ZMF
 *
 */
void Zmf_OnSensorData       (const ZmfSensorData *sensor);

/**
 * The audio input data entry to ZMF
 *
 * @param[in] inputId       unique name of the audio input
 * @param[in] sampleRateHz  the sample rating of the pcm data
 * @param[in] iChannels     the channel number of the pcm data
 * @param[in] buf           the pcm data
 * @param[in] len           the pcm data length
 * @param[in,out] micLevel  
 * @param[in] playDelayMS
 * @param[in] recDelayMS
 * @param[in] clockDrift
 *
 */
void Zmf_OnAudioInput       (const char *inputId, int sampleRateHz, int iChannels,  const unsigned char *buf, int len,
                             int *micLevel, int playDelayMS, int recDelayMS, int clockDrift);

/**
 * The outlet which audio output can get data from.
 *
 * @param[in] outputId      unique name of the audio output
 * @param[in] sampleRateHz  the sample rating of the pcm data
 * @param[in] iChannels     the channel number of the pcm data
 * @param[in] buf           the pcm data to be filled
 * @param[in] len           the pcm data length
 */
void Zmf_OnAudioOutput      (const char *outputId, int sampleRateHz, int iChannels, unsigned char *buf, int len);

/**
 * The video capture data entry to ZMF
 * iImgAngle - iCamOrient equal to device rotate angle.
 * if encoder is NULL, the pixel format of buf must be ZmfPixelFormatI420
 *
 * @param[in] captureId     unique name of the video capture
 * @param[in] iFace         the capture face, @see ZmfVideoFaceType
 * @param[in] iImgAngle     the image rotated angle (CW)
 * @param[in] iCamOrient    the camera fixed orient
 * @param[in,out] iWidth    the image width, expected width
 * @param[in,out] iHeight   the image height, expected height
 * @param[in] buf           the image data
 * @param[in,out] encoder   the capture encoder
 */
void Zmf_OnVideoCapture     (const char *captureId, int iFace, int iImgAngle, int iCamAngle,
                             int *iWidth, int *iHeight, unsigned char *bufI420,
                             ZmfVideoCaptureEncoder* encoder);


/**
 * The video render data entry to ZMF
 *
 * @param[in] renderId      unique name of the video render source
 * @param[in] sourceType    the render source type, @see ZmfVideoSourceType
 * @param[in] iAngle        the image rotated angle (CW)ZmfVideoCaptureCallback
 * @param[in] iWidth        the image width
 * @param[in] iHeight       the image height
 * @param[in] buf           the image data I420 buffer
 */
void Zmf_OnVideoRender      (const char *renderId, int sourceType, int iAngle, int iMirror,
                             int *iWidth, int *iHeight, unsigned char *bufI420, unsigned long timeStamp);

/**
 * add video capture data callback
 *
 * @param[in] pUser         the callback user data
 * @param[in] pfnCb         the callback
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_VideoCaptureAddCallback    (void *pUser, ZmfVideoCaptureCallback pfnCb);

/**
 * remove video capture data callback
 *
 * @param[in]  pUser        the callback user data
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_VideoCaptureRemoveCallback (void *pUser);

/**
 * add render data callback
 *
 * @param[in] pUser         the callback user data
 * @param[in] pfnCb         the callback
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_VideoRenderAddCallback     (void *pUser, ZmfVideoRenderCallback pfnCb);

/**
 * remove render data callback
 *
 * @param[in]  pUser        the callback user data
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_VideoRenderRemoveCallback  (void *pUser);

/**
 * remove speak data callback
 *
 * @param[in]  pUser        the callback user data
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_AudioOutputAddCallback     (void *pUser, ZmfAudioOutputCallback pfnCb);

/**
 * remove speak data callback
 *
 * @param[in]  pUser        the callback user data
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_AudioOutputRemoveCallback  (void *pUser);

/**
 * add mic data callback
 *
 * @param[in] pUser         the callback user data
 * @param[in] pfnCb         the callback
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_AudioInputAddCallback      (void *pUser, ZmfAudioInputCallback pfnCb);

/**
 * remove mic data callback
 *
 * @param[in]  pUser        the callback user data
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_AudioInputRemoveCallback   (void *pUser);

/**
 * utility for convert pixel from I420
 *
 * @param[in] dstFrame      the buffer to save the convert result
 * @param[in] dstFormat     the convert result pixel format
 * @param[in] srcFrame      the source I420 buffer
 * @param[in] srcWidth      the width of image
 * @param[in] srcHeight     the height of image
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_ConvertFromI420 (void* dstFrame, int dstFormat,
                          const void* srcFrame, int srcWidth, int srcHeight);

/**
 * utility for convert pixel to I420
 *
 * @param[in] dstFrame      the I420 buffer to save the convert result
 * @param[in] dstFormat     the convert result pixel format
 * @param[in] srcFrame      the source buffer
 * @param[in] srcWidth      the width of image
 * @param[in] srcHeight     the height of image
 * @param[in] rotateAngle   the clockwise rotation angle
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_ConvertToI420(void* dstframe,
                       int srcFormat, const void* srcFrame, unsigned srcBufLen,
                       int srcWidth, int srcHeight,int crop_x, int crop_y,
                       int *dstWidth, int *dstHeight, int rotateAngle);

/**
 * utility for scale i420
 *
 * @param[in] srcFrame      the source buffer
 * @param[in] srcWidth      the source width of image
 * @param[in] srcHeight     the source height of image
 * @param[in] dstFrame      the I420 buffer to save the convert result
 * @param[in] dstWidth      the target width of image
 * @param[in] dstHeight     the target height of image
 *
 * @return                  0 on succeed, otherwise failed.
 */
int  Zmf_ScaleI420(void* srcframe, int srcWidth, int srcHeight,
                   void* dstframe, int dstWidth, int dstHeight);

/**
 * trigger ZmfVideoRenderDidReceive event
 *
 * @param[in] renderId      unique name of the render
 * @param[in] hWnd          the window which the render has been added
 * @param[in] iWidth        the width of image
 * @param[in] iHeight       the height of image
 */
void Zmf_OnVideoRenderDidReceived  (const char *renderId, void* hWnd, int iWidth, int iHeight);

/**
 * trigger ZmfVideoRenderDidResize event
 *
 * @param[in] renderId      unique name of the render
 * @param[in] hWnd          the window which the render has been added
 * @param[in] iWidth        the new width of image
 * @param[in] iHeight       the new height of image
 */
void Zmf_OnVideoRenderDidResized   (const char *renderId, void* hWnd, int iWidth, int iHeight);

/**
 * trigger ZmfVideoRenderDidStart event
 *
 * @param[in] renderId      unique name of the render
 * @param[in] hWnd          the window which the render has been added
 */
void Zmf_OnVideoRenderDidStarted   (const char *renderId, void* hWnd, int iWidth, int iHeight);

/**
 * trigger ZmfVideoRenderRequestRemove event
 *
 * @param[in] renderId      unique name of the render
 * @param[in] hWnd          the window which the render has been added
 */
void Zmf_OnVideoRenderRequestRemove(const char *renderId, void* hWnd);

/**
 * trigger ZmfVideoRenderDidMatch event
 *
 * @param[in] renderId      unique name of the render
 * @param[in] hWnd          the window which the render has been added
 * @param[in] matching      the percent of mathcing
 */
void Zmf_OnVideoRenderDidMatch (const char *provideId, void* hWnd, int matching);

/**
 * tell ZMF the video capture has stopped
 * 
 * @param[in] captureId     unique name of the device
 */
void Zmf_OnVideoCaptureDidStop     (const char *captureId);

/**
 * tell ZMF the video capture exposure state changed
 *
 * @param[in] captureId     unique name of the video capture
 * @param[in] bStarted      bStarted 0 means the exposure is off , others on.
 */
void Zmf_OnVideoCaptureExposure   (const char *captureId, int bStarted);

/**
 * tell ZMF the audio output has stopped
 *
 * @param[in] outputId      unique name of the device
 */
void Zmf_OnAudioOutputDidStop      (const char *outputId);

/**
 * tell ZMF the audio input has stopped
 *
 * @param[in] inputId       unique name of the device
 */
void Zmf_OnAudioInputDidStop       (const char *inputId);

/**
 * Set Audio Event Callback
 */
int Zmf_AudioSetListener   (ZmfEventListenCallback pfnAudioListen);

/**
 * Set Video Event Callback
 */
int Zmf_VideoSetListener   (ZmfEventListenCallback pfnVideoListen);

typedef enum {
    ZmfLogDebug     = 0,
    ZmfLogInfo      = 1,
    ZmfLogWarn      = 2,
    ZmfLogError     = 3,
} ZmfLogLevel;

/**
 * Set  Log level
 */
void Zmf_LogSetLevel (int iLogLevel);
void Zmf_LogV(int iLogLevel, const char *format, va_list argv);

/** Font layout info */
typedef struct {
    unsigned        shadowRGBA;
    float           shadowBlurRadius;
    float           shadowOffsetX, shadowOffsetY;
    unsigned        outlineRGBA;
    float           outlineWidth;
    unsigned        fontRGBA;
    float           fontSize;
    unsigned        boundingWidth;
    float           scale;
    char            fontName[1024];
} ZmfFontLayout;

/** I420 Buffer */
typedef struct _ZmfI420Stencil {
    unsigned char   *bufI420;
    unsigned        width, height;
} ZmfI420Stencil;

/**
 * alloc I420 buffer
 *
 * @param[in] str   string
 * @param[in] info  layout info
 * @return I420 buffer
 */
ZmfI420Stencil* Zmf_I420StencilFromString(const char*str, ZmfFontLayout* info);

/**
 * delete I420 buffer
 */
void Zmf_I420StencilDelete(ZmfI420Stencil *stencil);

/**
 * blend I420
 *
 * @param[in] aligns Alignment @ref ZmfAlignmentType
 */
int Zmf_I420StencilBlend(const ZmfI420Stencil*stencil, unsigned dstX, unsigned dstY, unsigned char *dstI420, unsigned dstW, unsigned dstH);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif