ddc_previewer.c

the preview code includes auto focus, auto whitebalance. it is on TI DM6437 platform

                    else
                    {
                        getDarkFrameStatusReturnCode = DDC_PREV_SOK;
                    }
                }

            }
        }
    }
    return getDarkFrameStatusReturnCode;
}



/**
 *  \brief DDC_prevPreview
 *  It is used to trigger previewing operation.
 */
static DDC_prevResult DDC_prevPreview(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_preview *prevPreview
    )
{
    DDC_prevResult previewReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result previewPalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;
    PSP_previewerStatus previewStatus = {PSP_PREVIEWER_CHANNEL_BUSY};
    Uint8 previewWBLO = 0;
    CSL_Status previewCSLReturnCode = CSL_ESYS_FAIL;
#ifdef PREV_INSTRUMENTATION_ENABLED
    PSP_LOG_EVENT( &DVTEvent_Log, "PREVIEWER",
        PSP_DVT_DESC( PSP_DVT_eFUNC_START,
            PSP_DVT_dINST,
            PSP_DVT_dCHANNEL_ID,
            PSP_DVT_dNONE),
        0, PSP_PREVIEWER_IOCTL_PREVIEW);
#endif /* PREV_INSTRUMENTATION_ENABLED */

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == prevPreview))
    {
        previewReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        /* raise an error if previewer parameters are not configured yet */
        if (DDC_PREVIEWER_CHANNEL_CONFIGURED
            != ddcChannelHandle->configState)
        {
            previewReturnCode = DDC_PREV_INVALID_STATE;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        else
        {
            previewReturnCode = DDC_prevValidateInputParams(ddcChannelHandle,
                prevPreview->outBufSize);
            if (DDC_PREV_SOK == previewReturnCode)
            {
                /* if input buffer address is not 32 byte aligned */
                if ((Uint32)(0x00u) != ((Uint32)(prevPreview->inBuf)
                        & (Uint32)(DDC_PREV_32_ALIGNED_MASK)))
                {
                    previewReturnCode = DDC_PREV_INVALID_PARAM;
                    DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
                    PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                }
                else
                {
                    /* to validate output image parameters call
                     * DDC_prevValidateOutputParams */
                    previewReturnCode = DDC_prevValidateOutputParams(
                        ddcChannelHandle,
                        prevPreview->outBufSize,
                        prevPreview->outBuf);
                    if (DDC_PREV_SOK == previewReturnCode)
                    {
                        /* check channel status - if it is busy - raise an
                         * error */
                        previewReturnCode = DDC_prevGetStatus(ddcChannelHandle,
                            (PSP_previewerStatus*)(&previewStatus));
                        if (DDC_PREV_SOK == previewReturnCode)
                        {
                            /* if channel status is busy */
                            if (PSP_PREVIEWER_CHANNEL_BUSY
                                == previewStatus.channelStatus)
                            {
                                previewReturnCode = DDC_PREV_INVALID_STATE;
                                DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
                                PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                            }
                            else /* if channel status is free */
                            {
                                /* take channel semaphore */
                                previewPalReturnCode = PAL_osSemTake(
                                    ddcChannelHandle->channelSem,
                                    PAL_OSSEM_NO_TIMEOUT);
                                if (PAL_SOK != previewPalReturnCode)
                                {
                                    previewReturnCode = DDC_PREV_RESOURCE_ERROR;
                                    DDC_PREVIEWER_DEBUG_PRINT("Resource");
                                    DDC_PREVIEWER_DEBUG_PRINT(" Error\n");
                                    PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                                }
                                else
                                {
                                    /* trigger previewer */
                                    previewCSLReturnCode
                                        = LLC_prevOneShotPreviewer(
                                            (PSP_previewerChannelCreateMode*)
                                            (&(ddcChannelHandle->channelMode)),
                                            prevPreview,
                                            ddcPrevDeviceObj.regs);
                                    if (CSL_SOK != previewCSLReturnCode)
                                    {
                                        previewReturnCode = DDC_PREV_E_FAIL;
                                        PREVIEWER_DEBUG_ERR_TRACE(
                                            __LINE__);
                                        PAL_osSemGive(
                                            ddcChannelHandle->channelSem);
                                    }
                                    else
                                    {
                                        /* take ISR semaphore */
                                        previewPalReturnCode = PAL_osSemTake(
                                            ddcPrevDeviceObj.semIsr,
                                            PAL_OSSEM_NO_TIMEOUT);
                                        /* if it fails to take ISR semaphore */
                                        if (PAL_SOK != previewPalReturnCode)
                                        {
                                            previewReturnCode
                                                = DDC_PREV_RESOURCE_ERROR;
                                            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                                            /* release channel semaphore, but
                                             * error code should be return as
                                             * semaphore for ISR has not been
                                             * retrieved. */
                                            PAL_osSemGive(
                                                ddcChannelHandle->channelSem);
                                        }
                                        else /* ISR semaphore taken
                                                successfully */
                                        {
                                            /* get Write buffer memory overflow
                                             * (Preview engine) */
                                            LLC_prevGetWriteBufMemOverflow
                                                ((Uint8*)(&previewWBLO),
                                                 (Ptr)CSL_VPSS_0_REGS
                                                );
                                            if (CSL_VPSS_PCR_PRV_WBL_O_OVERFLOW
                                                == previewWBLO)
                                            {
                                                previewReturnCode
                                                    = DDC_PREV_OVERFLOW_ERROR;
                                                PREVIEWER_DEBUG_ERR_TRACE(
                                                    __LINE__);
                                            }
                                            /* Give channel semaphore */
                                            previewPalReturnCode = PAL_osSemGive
                                                (ddcChannelHandle->channelSem);
                                            if (PAL_SOK != previewPalReturnCode)
                                            {
                                                previewReturnCode
                                                    = DDC_PREV_RESOURCE_ERROR;
                                                PREVIEWER_DEBUG_ERR_TRACE(
                                                    __LINE__);
                                            }
                                        }
                                    }
                                } /* if PAL_SOK neq previewPalReturnCode for
                                     PAL_osSemTake for channel semaphore */
                            } /* if prev status eq PSP_PREVIEWER_... */
                        } /* if previewer status is read successfully */
                    } /* if output parameters are validated successfully */
                } /* if input address is validated successfully */
            } /* if input size is validated successfully */
        }
    }
#ifdef PREV_INSTRUMENTATION_ENABLED
    PSP_LOG_EVENT( &DVTEvent_Log, "PREVIEWER",
        PSP_DVT_DESC( PSP_DVT_eFUNC_END,
            PSP_DVT_dINST,
            PSP_DVT_dCHANNEL_ID,
            PSP_DVT_dNONE),
        0, PSP_PREVIEWER_IOCTL_PREVIEW);
#endif /* PREV_INSTRUMENTATION_ENABLED */
    return previewReturnCode;
}



/**
 *  \brief DDC_prevGetCropSize
 *  It is used to calculates crop size.
 */
static DDC_prevResult DDC_prevGetCropSize(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerCropSize* prevCropSize
    )
{
    DDC_prevResult getCropSizeReturnCode = DDC_PREV_NOT_SUPPORTED;

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == prevCropSize))
    {
        getCropSizeReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        /* raise an error if previewer parameters are not configured yet */
        if (DDC_PREVIEWER_CHANNEL_CONFIGURED
            != ddcChannelHandle->configState)
        {
            getCropSizeReturnCode = DDC_PREV_INVALID_STATE;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        else
        {
            prevCropSize->hCrop = 0;
            prevCropSize->vCrop = 0;

            /* if Horizontal Median Filter is enabled, horizontal crop will be
             * 4 pixels */
            if ((Uint32)(0x0u)
                != ((ddcChannelHandle->DDC_prevParams).features
                    & PSP_PREVIEWER_HMF))
            {
                prevCropSize->hCrop += DDC_PREV_HMF_HCROP;
            }
            /* if noise filter is enabled, horizontal crop will be 4 pixels and
             * vertical crop will be 4 lines */
            if ((Uint32)(0x0u)
                != ((ddcChannelHandle->DDC_prevParams).features
                    & PSP_PREVIEWER_NOISE_FILTER))
            {
                prevCropSize->hCrop += DDC_PREV_NOISE_FILTER_HCROP;
                prevCropSize->vCrop += DDC_PREV_NOISE_FILTER_VCROP;
            }
            /* if CFA is enabled, horizontal crop will be 4 pixels and
             * vertical crop will be 4 lines */
            if ((Uint32)(0x0u)
                != ((ddcChannelHandle->DDC_prevParams).features
                    & PSP_PREVIEWER_CFA))
            {
                prevCropSize->hCrop += DDC_PREV_CFA_HCROP;
                prevCropSize->vCrop += DDC_PREV_CFA_VCROP;
            }
            /* if luminance enahancement is enabled, horizontal crop will be
             * 2 pixels */
            if ((Uint32)(0x0u)
                != ((ddcChannelHandle->DDC_prevParams).features
                    & PSP_PREVIEWER_LUMA_ENHANCE))
            {
                prevCropSize->hCrop += DDC_PREV_LUMA_HCROP;
            }
            getCropSizeReturnCode = DDC_PREV_SOK;
        }
    }
    return getCropSizeReturnCode;
}

/**
 *  \brief DDC_prevSetReadReqExpand
 *  It is used to set read request expand
 */
static DDC_prevResult DDC_prevSetReadReqExpand(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerReadReqExp *prevReadReqExp
    )
{
    DDC_prevResult setReadReqExpReturnCode = DDC_PREV_NOT_SUPPORTED;
    CSL_Status setReadReqExpCSLReturnCode = CSL_ESYS_FAIL;

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == prevReadReqExp))
    {
        setReadReqExpReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        setReadReqExpCSLReturnCode = LLC_prevSetReadReqExpand(
            (Uint16)(prevReadReqExp->prevExp),
            (Ptr)CSL_VPSS_0_REGS);
        if (CSL_SOK != setReadReqExpCSLReturnCode)
        {
            setReadReqExpReturnCode = DDC_PREV_E_FAIL;
        }
        else
        {
            setReadReqExpReturnCode = DDC_PREV_SOK;
        }
    }
    return setReadReqExpReturnCode;
}


/**
 *  \brief DDC_prevValidateInputParams
 *  It is used to validate input image parameters for previewer.
 */
static DDC_prevResult DDC_prevValidateInputParams(
    DDC_prevChannelHandle ddcChannelHandle,
    Int32 inBufSize
    )
{
    DDC_prevResult validateInputReturnCode = DDC_PREV_NOT_SUPPORTED;
    Uint32 validateInputHSize = 0;
    Uint32 validateInputVSize = 0;
    Uint32 validateInputSize = 0;

    /* parameter validation, if outbuffer address is not 32 byte aligned raise
     * an error */
    if ((NULL == ddcChannelHandle)
        || (0 == inBufSize))
    {
        validateInputReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {