drv.h

audio-video-codecs.rar语音编解码器

#define VIDEO_DRV_RENDER_FRAME_FUNC(func, driver, frame, rect)                 \
    vm_status func(VideoDriver *driver, void *frame, VideoDrvRect *rect)

/* Name: VIDEO_DRV_SET_VIDEO_MODE_FUNC.
 *
 * Purpose:
 *  initialize video regime with some parameters.
 *
 * Parameters:
 *  rect    - window rectangle;
 *  mode    - specifies video regime to use.
 */

#define VIDEO_DRV_SET_VIDEO_MODE_FUNC(func, driver, rect, mode)                \
    vm_status func(VideoDriver *driver, VideoDrvRect *rect, VideoDrvVideoMode mode)

/* Name: VIDEO_DRV_GET_WINDOW_FUNC.
 *
 * Purpose:
 *  Return descriptor of the window.
 *
 * Return value:
 *  Type of teturn variable depends on driver which was used.
 */

#define VIDEO_DRV_GET_WINDOW_FUNC(func, driver)                                \
    void* func(VideoDriver *driver)

/* Name: VIDEO_DRV_RUN_EVENT_LOOP_FUNC.
 *
 * Purpose:
 *  Run event loop.
 *
 * Remarks:
 *  1. Function doesn't run infinity loop. It checks and releases all events
 *  from queue and quits.
 */

#define VIDEO_DRV_RUN_EVENT_LOOP_FUNC(func, driver)                            \
    vm_status func(VideoDriver *driver)

/* Next types can be used to work with driver functions. */

typedef VIDEO_DRV_INIT_FUNC (VideoDrvInitFunc, driver, params);
typedef VIDEO_DRV_CLOSE_FUNC(VideoDrvCloseFunc, driver);

typedef VIDEO_DRV_CREATE_BUFFERS_FUNC(VideoDrvCreateBuffersFunc,
                                      driver, min_b, max_b, bufs,
                                      video_mem_type, video_mem_info);
typedef VIDEO_DRV_FREE_BUFFERS_FUNC(VideoDrvFreeBuffersFunc,
                                    driver, num_b, bufs);
typedef VIDEO_DRV_CREATE_SURFACE_FUNC(VideoDrvCreateSurfaceFunc, driver);
typedef VIDEO_DRV_FREE_SURFACE_FUNC(VideoDrvFreeSurfaceFunc, driver, srf);

typedef VIDEO_DRV_LOCK_SURFACE_FUNC(VideoDrvLockSurfaceFunc,
                                    driver, srf, planes);
typedef VIDEO_DRV_UNLOCK_SURFACE_FUNC(VideoDrvUnlockSurfaceFunc, driver, srf);

typedef VIDEO_DRV_RENDER_FRAME_FUNC(VideoDrvRenderFrameFunc,
                                    driver, frame, rect);
typedef VIDEO_DRV_SET_VIDEO_MODE_FUNC(VideoDrvSetVideoModeFunc,
                                      driver, rect, mode);

typedef VIDEO_DRV_GET_WINDOW_FUNC(VideoDrvGetWindowFunc, driver);
typedef VIDEO_DRV_RUN_EVENT_LOOP_FUNC(VideoDrvRunEventLoopFunc, driver);

/* Name: VideoDrvSpec.
 *
 * Purpose:
 *  Store information about driver, store pointers to driver functions.
 */

typedef struct VideoDrvSpec
{
    vm_char*                    drv_name;
    VideoDrvBool                drv_rebuf;
    Ipp32u                      drv_videomem_type;  /*VideoDrvVideoMemType*/

    VideoDrvInitFunc*           drvInit;
    VideoDrvCloseFunc*          drvClose;

    VideoDrvCreateBuffersFunc*  drvCreateBuffers;
    VideoDrvFreeBuffersFunc*    drvFreeBuffers;
    VideoDrvCreateSurfaceFunc*  drvCreateSurface;   /* usually unused directly */
    VideoDrvFreeSurfaceFunc*    drvFreeSurface;     /* usually unused directly */

    VideoDrvLockSurfaceFunc*    drvLockSurface;
    VideoDrvUnlockSurfaceFunc*  drvUnlockSurface;

    VideoDrvRenderFrameFunc*    drvRenderFrame;
    VideoDrvSetVideoModeFunc*   drvSetVideoMode;

    VideoDrvGetWindowFunc*      drvGetWindow;
    VideoDrvRunEventLoopFunc*   drvRunEventLoop;
} VideoDrvSpec;

/* Name: VideoDrvSpec.
 *
 * Purpose:
 *  Store driver specification.
 *
 * Structure fields:
 *  img_width, img_height   - original image sizes;
 *  m_pVideoMemInfo         - video memory information (optional parameter);
 *  m_DrvSpec               - driver functions;
 *  m_pDrv                  - specific driver information.
 */

struct VideoDriver
{
    Ipp32s                  img_width;
    Ipp32s                  img_height;

    VideoDrvVideoMemType    m_VideoMemType;
    VideoDrvVideoMemInfo    m_VideoMemInfo;

    VideoDrvSpec            m_DrvSpec;
    void*                   m_pDrv;
};

/* Macroses defined below can be used for errors handling in drivers code.
 *
 * Agreements:
 *  0. Names of macroses: VIDEO_DRV_<name>;
 *  1. module   - macroses parameter, string containing module name;
 *  2. func     - macroses parameter, string containing function name;
 *  3. msg      - macroses parameter, message specifies an error occured;
 *  4. below only macroses-specific parameters values will be described.
 */

/* Name: VIDEO_DRV_RESULT.
 *
 * Purpose:
 *  Defines result variable for macroses below.
 */
#define VIDEO_DRV_RESULT result

/* Name: VIDEO_DRV_FUNC_SET.
 *
 * Purpose:
 *  Concatinate module name and file name into full file name.
 */

#define VIDEO_DRV_FUNC_SET(module, func)                                       \
    VM_STRING(module func)

/* Name: VIDEO_DRV_RESULT_SET.
 *
 * Purpose:
 *  Set <result> variable, defined by user.
 *
 * Parameters:
 *  level   - level of an error (error, warning, ...);
 *  err     - error occured.
 *
 * Remarks:
 *  1. <result> variable should be defined before usage of this macro;
 *  2. <err> and <result> should have same tpes.
 */

#define VIDEO_DRV_RESULT_SET(level, module, err, func, msg)                    \
{                                                                              \
    if (VIDEO_DRV_USE_DEBUG)                                                   \
    {                                                                          \
        vm_debug_trace_withfunc(level,                                         \
                                VIDEO_DRV_FUNC_SET(module, func),              \
                                msg);                                          \
        /*printf ("%s: %s\n", VIDEO_DRV_FUNC_SET(module, func), msg);*/       \
    }                                                                          \
    VIDEO_DRV_RESULT = err;                                                              \
}

/* Name: VIDEO_DRV_ERR_SET.
 *
 * Purpose:
 *  Set <result> variable, defined by user (use this macro to report about
 * errors).
 *
 * Parameters:
 *  err     - error occured.
 *
 * Remarks:
 *  1. <result> variable should be defined before usage of this macro;
 *  2. <err> and <result> should have same tpes.
 */

#define VIDEO_DRV_ERR_SET(module, err, func, msg) \
    VIDEO_DRV_RESULT_SET(VM_DEBUG_ERROR, module, err, func, msg)

/* Name: VIDEO_DRV_WRN_SET.
 *
 * Purpose:
 *  Set <result> variable, defined by user (use this macro to report about
 * warnings).
 *
 * Parameters:
 *  err     - error occured.
 *
 * Remarks:
 *  1. <result> variable should be defined before usage of this macro;
 *  2. <err> and <result> should have same tpes.
 */

#define VIDEO_DRV_WRN_SET(module, err, func, msg) \
    VIDEO_DRV_RESULT_SET(VM_DEBUG_WARNING, module, err, func, msg)

/* Name: VIDEO_DRV_DBG_SET.
 *
 * Purpose:
 *  Print debug message (message for information purposes only).
 */

#if (0 < VIDEO_DRV_USE_DEBUG)
#define VIDEO_DRV_DBG_SET(module, func, msg)                                   \
{                                                                              \
    {                                                                          \
        vm_debug_trace_withfunc(VM_DEBUG_PROGRESS,                             \
                                VIDEO_DRV_FUNC_SET(module, func),              \
                                msg);                                         \
        /*printf("%s: %s\n", VIDEO_DRV_FUNC_SET(module, func), msg);*/         \
    }                                                                          \
}
#else /* !(0 < VIDEO_DRV_USE_DEBUG) */
#define VIDEO_DRV_DBG_SET(module, func, msg)
#endif

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

    /* Memory align function. */
    size_t umc_vdrv_AlignValue(size_t nValue, size_t lAlign);

    /* Init buffers functions. */
    extern VIDEO_DRV_CREATE_BUFFERS_FUNC(umc_vdrv_CreateBuffers,
                                         driver, min_b, max_b, bufs,
                                         video_mem_type, video_mem_info);

    /* Free buffers functions. */
    extern VIDEO_DRV_FREE_BUFFERS_FUNC(umc_vdrv_FreeBuffers,
                                       driver, num_b, bufs);

    /* Create surface functions for different formats. */
    extern VIDEO_DRV_CREATE_SURFACE_FUNC(umc_vdrv_CreateSurface_ipps,
                                         driver);

    /* Free surface functions for different formats. */
    extern VIDEO_DRV_FREE_SURFACE_FUNC(umc_vdrv_FreeSurface_ipps,
                                       driver,srf);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* __DRV_H__ */