ddc_previewer.c

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

        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (0 != (validateParamsHSize % 2)))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid horizontal size with");
            DDC_PREVIEWER_DEBUG_PRINT(" respect to down sample rate\n");
        }

        /* check for valid values output pixel format */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (((PSP_PREVIEWER_PIXELORDER_YCBYCR
                        != DDC_prevParams->outPixelOrderParam)
                    && (PSP_PREVIEWER_PIXELORDER_YCRYCB
                        != DDC_prevParams->outPixelOrderParam))
                && ((PSP_PREVIEWER_PIXELORDER_CBYCRY
                        != DDC_prevParams->outPixelOrderParam)
                    && (PSP_PREVIEWER_PIXELORDER_CRYCBY
                        != DDC_prevParams->outPixelOrderParam))))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid output format\n");
        }

        /* per pixel how many bytes are there in input image */
        if (PSP_PREVIEWER_INWIDTH_8BIT
            == (DDC_prevParams->sizeParam).pixelSize)
        {
            validateParamsBytesPerPixel = 1u;
        }
        else
        {
            validateParamsBytesPerPixel = 2u;
        }

        /* check inPitch value  - it should be 32 byte aligned,
         * it should also be greater then number of pixels in single row
         *  - in case of CCDC, input pitch will not be there. eph value will be
         *  at least one less then height of previewed image, so 1 is added */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (PSP_PREVIEWER_CHANNEL_SDRAM
                == (ddcChannelHandle->channelMode).chanSource.source))
        {
            if (((Uint16)0x0u != (((DDC_prevParams->sizeParam).inPitch)
                        & (Uint16)(DDC_PREV_32_ALIGNED_MASK)))
                || ((validateParamsBytesPerPixel
                        * ((DDC_prevParams->sizeParam).eph + 1))
                    > (DDC_prevParams->sizeParam).inPitch))
            {
                validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid input pitch value\n");
            }
        }

        /* per pixel how many bytes are needed in output image
         * - 2 bytes per pixel */
        validateParamsBytesPerPixel = 2u;

        /* check outPitch value  - it should be 32 byte aligned,
         * it should also be greater then number of pixels in single row */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (((Uint16)0x0u != (((DDC_prevParams->sizeParam).outPitch)
                        & (Uint16)(DDC_PREV_32_ALIGNED_MASK)))
                || ((validateParamsBytesPerPixel * validateParamsHSize)
                    > (DDC_prevParams->sizeParam).outPitch)))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid output pitch value\n");
        }

        /* check dark frame address and offset value
         *  - that should be 32 byte aligned and it will come in picture when
         *   dark frame subtract or lens shading is enabled */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (((Uint32)(0u) != (DDC_prevParams->features
                        & PSP_PREVIEWER_DARK_FRAME_SUBTRACT))
                || ((Uint32)(0u) != (DDC_prevParams->features
                        & PSP_PREVIEWER_LENS_SHADING))))
        {
            if (((Uint16)0x0u != ((DDC_prevParams->darkFrameOffset)
                        & (Uint16)(DDC_PREV_32_ALIGNED_MASK)))
                || ((Uint32)0x0u != ((Uint32)(DDC_prevParams->darkFrameAddr)
                        & (Uint32)(DDC_PREV_32_ALIGNED_MASK))))
            {
                validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid dark frame");
                DDC_PREVIEWER_DEBUG_PRINT(" address/offset\n");
            }
        }

        /* white balance related */
        /* all white balance coefficients selection value should be between 0-3
         * */
        if (DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
        {
            validateParamsTempVar = 0;
            for (validateParamsXIndex = 0;
                validateParamsXIndex < PSP_PREVIEWER_WB_GAIN_MAX;
                validateParamsXIndex++)
            {
                for(validateParamsYIndex = 0;
                    validateParamsYIndex < PSP_PREVIEWER_WB_GAIN_MAX;
                    validateParamsYIndex++)
                {
                    validateParamsTempVar |= (DDC_prevParams->whiteBalanceParam)
                        .position[validateParamsXIndex][validateParamsYIndex];
                }
            }
            if ((Uint32)0 != (validateParamsTempVar
                    & ~(Uint32)(CSL_PREV_WBSEL_0_0_MASK)))
            {
                validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid white balance");
                DDC_PREVIEWER_DEBUG_PRINT(" coefficients\n");
            }
        }
        /* white balance digital gain should be of max 10 bits only */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && ((Uint32)0 != ((DDC_prevParams->whiteBalanceParam).wbDgain
                    & ~(Uint32)(CSL_PREV_WB_DGAIN_DGAIN_MASK))))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid white balance digital gain\n");
        }

        /* RGB blending related */
        /* blending values should be of max 12 bits only */
        if (DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
        {
            validateParamsTempVar = 0;
            for (validateParamsXIndex = 0;
                validateParamsXIndex < PSP_PREVIEWER_RGB_MAX;
                validateParamsXIndex++)
            {
                for(validateParamsYIndex = 0;
                    validateParamsYIndex < PSP_PREVIEWER_RGB_MAX;
                    validateParamsYIndex++)
                {
                    validateParamsTempVar |= (DDC_prevParams->rgbBlendingParam)
                        .blending[validateParamsXIndex][validateParamsYIndex];
                }
            }
            if ((Uint32)0 != (validateParamsTempVar
                    & ~(Uint32)(CSL_PREV_RGB_MAT1_MTX_RR_MASK)))
            {
                validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid RGB blending parameter\n");
            }
        }
        /* offset values should be of max 10 bits only */
        if (DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
        {
            validateParamsTempVar = 0;
            for (validateParamsXIndex = 0;
                validateParamsXIndex < PSP_PREVIEWER_RGB_MAX;
                validateParamsXIndex++)
            {
                validateParamsTempVar
                    |= (Uint32)((DDC_prevParams->rgbBlendingParam)
                        .offset[validateParamsXIndex]);
            }
            if ((Uint32)0 != (validateParamsTempVar
                    & ~(Uint32)(CSL_PREV_RGB_OFF1_MTX_OFFG_MASK)))
            {
                validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid RGB blending offset");
                DDC_PREVIEWER_DEBUG_PRINT(" value\n");
            }
        }

        /* RGB to ycbcrCoeffs coefficient related */
        /* coefficient values should be of max 10 bits */
        if (DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
        {
            validateParamsTempVar = 0;
            for (validateParamsXIndex = 0;
                validateParamsXIndex < PSP_PREVIEWER_RGB_MAX;
                validateParamsXIndex++)
            {
                for(validateParamsYIndex = 0;
                    validateParamsYIndex < PSP_PREVIEWER_RGB_MAX;
                    validateParamsYIndex++)
                {
                    validateParamsTempVar |= (DDC_prevParams->rgb2ycbcrParam)
                        .coeff[validateParamsXIndex][validateParamsYIndex];
                }
            }
            if ((Uint32)0 != (validateParamsTempVar
                    & ~(Uint32)(CSL_PREV_CSC0_CSCRY_MASK)))
            {
                validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid RGB to YCbCr");
                DDC_PREVIEWER_DEBUG_PRINT(" coefficients\n");
            }
        }


        if (DDC_PREVIEWER_ERROR_FOUND == validateParamsErrorFlag)
        {
            validateParamsReturnCode = DDC_PREV_INVALID_PARAM;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        else
        {
            validateParamsReturnCode = DDC_PREV_SOK;
        }
    }
    return validateParamsReturnCode;
}



/**
 *  \brief DDC_prevGetStatus
 *  It is used to get previewer hardware status.
 */
static DDC_prevResult DDC_prevGetStatus(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerStatus *prevStatus
    )
{
    DDC_prevResult getStatusReturnCode = DDC_PREV_NOT_SUPPORTED;
    CSL_Status getStatusCSLReturnCode = CSL_ESYS_FAIL;

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == prevStatus))
    {
        getStatusReturnCode = 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)
        {
            getStatusReturnCode = DDC_PREV_INVALID_STATE;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        else
        {
            /* get channel status by calling LLC_prevChannelStatus function */
            getStatusCSLReturnCode = LLC_prevChannelStatus(
                (Uint8*)(&(prevStatus->channelStatus)),
                ddcPrevDeviceObj.regs);
            if (CSL_SOK != getStatusCSLReturnCode)
            {
                getStatusReturnCode = DDC_PREV_E_FAIL;
            }
            else
            {
                getStatusReturnCode = DDC_PREV_SOK;
            }
        }
    }
    return getStatusReturnCode;
}


/**
 *  \brief DDC_prevGetDarkFrameStatus
 *  It is used to get dark frame subtract failure status.
 */
static DDC_prevResult DDC_prevGetDarkFrameStatus(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerDarkFrameStatus *prevDarkFrameStatus
    )
{
    DDC_prevResult getDarkFrameStatusReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result getDarkFrameStatusPalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;
    CSL_Status getDarkFrameStatusCSLReturnCode = CSL_ESYS_FAIL;

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == prevDarkFrameStatus))
    {
        getDarkFrameStatusReturnCode = 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 or
         * source is SDRAM as in case of CCDC only dark frame subtract feature
         * can be enabled */
        if (DDC_PREVIEWER_CHANNEL_CONFIGURED
            != ddcChannelHandle->configState)
        {
            getDarkFrameStatusReturnCode = DDC_PREV_INVALID_STATE;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        else
        {
            /* take channel semaphore */
            getDarkFrameStatusPalReturnCode = PAL_osSemTake(
                ddcChannelHandle->channelSem,
                PAL_OSSEM_NO_TIMEOUT);
            if (PAL_SOK != getDarkFrameStatusPalReturnCode)
            {
                getDarkFrameStatusReturnCode = DDC_PREV_RESOURCE_ERROR;
                DDC_PREVIEWER_DEBUG_PRINT("Resource Error\n");
                PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
            }
            else
            {
                /* get channel status by calling LLC_prevChannelStatus function,
                 * this function will clear dark frame status also */
                getDarkFrameStatusCSLReturnCode = LLC_prevDarkFrameStatus(
                    (Uint8*)(&(prevDarkFrameStatus->status)),
                    ddcPrevDeviceObj.regs);
                if (CSL_SOK != getDarkFrameStatusCSLReturnCode)
                {
                    getDarkFrameStatusReturnCode = DDC_PREV_E_FAIL;
                    PAL_osSemGive(ddcChannelHandle->channelSem);
                }
                else
                {
                    /* give channel semaphore */
                    getDarkFrameStatusPalReturnCode
                        = PAL_osSemGive(ddcChannelHandle->channelSem);
                    if (PAL_SOK != getDarkFrameStatusPalReturnCode)
                    {
                        getDarkFrameStatusReturnCode = DDC_PREV_RESOURCE_ERROR;
                        DDC_PREVIEWER_DEBUG_PRINT("Resource Error\n");
                        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                    }