ddc_previewer.c

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

                    closeHandleReturnCode = DDC_PREV_SOK;
                }
            }
        }
    }
    return closeHandleReturnCode;
}



/**
 *  \brief DDC_prevDeviceDelete
 *  It deletes a given previewer device at DDC layer.
 */
DDC_prevResult DDC_prevDeviceDelete(PSP_Handle ddcDeviceHandle)
{
    DDC_prevResult devDeleteReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result devDeletePalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;

    /* parameter validation */
    if (NULL == ddcDeviceHandle)
    {
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        devDeleteReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
    }
    else
    {
        /* delete semaphore of ISR */
        devDeletePalReturnCode = PAL_osSemDelete(ddcPrevDeviceObj.semIsr);
        if (PAL_SOK != devDeletePalReturnCode)
        {
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
            devDeleteReturnCode = DDC_PREV_RESOURCE_ERROR;
            DDC_PREVIEWER_DEBUG_PRINT("Resource Error\n");
        }
        else
        {
            devDeleteReturnCode = DDC_PREV_SOK;
        }
        ddcPrevDeviceObj.semIsr = NULL;
        ddcPrevDeviceObj.regs = NULL;
    }
    return devDeleteReturnCode;
}



/**
 *  \brief DDC_prevPerformRegOverlaying
 *  It is previewer register overlaying function.
 */
static DDC_prevResult DDC_prevPerformRegOverlaying()
{
    DDC_prevResult regOverlayReturnCode = DDC_PREV_NOT_SUPPORTED;
    ddcPrevDeviceObj.regs = (Ptr)CSL_VPSS_PREV_0_REGS;
    regOverlayReturnCode = DDC_PREV_SOK;
    return (regOverlayReturnCode);
}



/**
 *  \brief DDC_prevSetParameters
 *  It is used to set previewer parameters.
 */
static DDC_prevResult DDC_prevSetParameters(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerParams *DDC_prevParams
    )
{
    DDC_prevResult setParamsReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result setParamsPalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;
    CSL_Status setParamsCSLReturnCode = CSL_ESYS_FAIL;
    Uint8 setParamsPreviewerStatus = 0;

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == DDC_prevParams))
    {
        setParamsReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        /* check previewer is in enable state or in disable state
         * - if it is enabled, raise an error */
        setParamsCSLReturnCode = LLC_prevPreviewerStatus(
            (Uint8*)&setParamsPreviewerStatus, ddcPrevDeviceObj.regs);
        if (CSL_SOK != setParamsCSLReturnCode)
        {
            setParamsReturnCode = DDC_PREV_E_FAIL;
        }
        else
        {
            /* if previewer is already enabled */
            if (CSL_PREV_PCR_ENABLE_PREV_ENABLE == setParamsPreviewerStatus)
            {
                setParamsReturnCode = DDC_PREV_INVALID_STATE;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
                PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
            }
            else /* if channel status is free */
            {
                setParamsReturnCode = DDC_PREV_SOK;
                /* validate passed previewer parameters by calling
                 * DDC_prevValidateParameters */
                setParamsReturnCode = DDC_prevValidateParameters(
                    ddcChannelHandle, DDC_prevParams);
                /* if parameter strcture is valid... */
                if (DDC_PREV_SOK == setParamsReturnCode)
                {
                    /* take channel semaphore */
                    setParamsPalReturnCode = PAL_osSemTake(
                        ddcChannelHandle->channelSem,
                        PAL_OSSEM_NO_TIMEOUT);
                    if (PAL_SOK != setParamsPalReturnCode)
                    {
                        setParamsReturnCode = DDC_PREV_RESOURCE_ERROR;
                        DDC_PREVIEWER_DEBUG_PRINT("Resource Error\n");
                        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                    }
                    else
                    {
                        /* copy these values into channel structure */
                        setParamsPalReturnCode = PAL_osMemCopy(
                            (Ptr)(&(ddcChannelHandle->DDC_prevParams)),
                            (Ptr)(DDC_prevParams), sizeof(PSP_previewerParams));
                        if (PAL_SOK != setParamsPalReturnCode)
                        {
                            setParamsReturnCode = DDC_PREV_MEMORY_ERROR;
                            DDC_PREVIEWER_DEBUG_PRINT("Memory Error\n");
                            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                        }
                        else
                        {
                            setParamsCSLReturnCode
                                = LLC_prevHardwareSetup(
                                    (PSP_previewerChannelCreateMode*)
                                    (&(ddcChannelHandle->channelMode)),
                                    DDC_prevParams,
                                    ddcPrevDeviceObj.regs);
                            if (CSL_SOK != setParamsCSLReturnCode)
                            {
                                setParamsReturnCode = DDC_PREV_E_FAIL;
                            }
                            else
                            {
                                /* fill dark frame capture structure in channel
                                 * object */
                                (ddcChannelHandle->DFCState).darkFrameState
                                    = PSP_PREVIEWER_DARK_FRAME_CAPTURE_DISABLE;
                                (ddcChannelHandle->DFCState).outPitch
                                    = (ddcChannelHandle
                                        ->DDC_prevParams).sizeParam.outPitch;

                                /* update the channel state to configured */
                                ddcChannelHandle->configState
                                    = DDC_PREVIEWER_CHANNEL_CONFIGURED;
                            }
                        }
                        /* give channel semaphore */
                        setParamsPalReturnCode
                            = PAL_osSemGive(ddcChannelHandle->channelSem);
                        if (PAL_SOK != setParamsPalReturnCode)
                        {
                            setParamsReturnCode = DDC_PREV_RESOURCE_ERROR;
                            DDC_PREVIEWER_DEBUG_PRINT("Resource Error\n");
                            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                        }
                    }
                }
            }
        }
    }
    return setParamsReturnCode;
}



/**
 *  \brief DDC_prevGetParameters
 *  It is used to get previewer parameters.
 */
static DDC_prevResult DDC_prevGetParameters(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerParams *DDC_prevParams
    )
{
    DDC_prevResult getParamsReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result getParamsPalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == DDC_prevParams))
    {
        getParamsReturnCode = 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)
        {
            getParamsReturnCode = DDC_PREV_INVALID_STATE;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        else
        {
            /* copy these values into channel structure */
            getParamsPalReturnCode = PAL_osMemCopy(
                (Ptr)(DDC_prevParams),
                (Ptr)(&(ddcChannelHandle->DDC_prevParams)),
                sizeof(PSP_previewerParams));
            if (PAL_SOK != getParamsPalReturnCode)
            {
                getParamsReturnCode = DDC_PREV_MEMORY_ERROR;
                DDC_PREVIEWER_DEBUG_PRINT("Memory Error\n");
                PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
            }
            else
            {
                getParamsReturnCode = DDC_PREV_SOK;
            }
        }
    }
    return getParamsReturnCode;
}



/**
 *  \brief DDC_prevValidateParameters
 *  It is used to validate previewer parameters.
 */
static DDC_prevResult DDC_prevValidateParameters(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerParams *DDC_prevParams
    )
{
    DDC_prevResult validateParamsReturnCode = DDC_PREV_NOT_SUPPORTED;
    Uint32 validateParamsErrorFlag = 0;
    Uint32 validateParamsBytesPerPixel = 0;
    Uint32 validateParamsTempVar = 0;
    Uint32 validateParamsXIndex = 0, validateParamsYIndex = 0;
    Uint32 validateParamsHSize = 0;

    /* parameter validation */
    if ((NULL == ddcChannelHandle) || (NULL == DDC_prevParams))
    {
        validateParamsReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        validateParamsErrorFlag = DDC_PREVIEWER_ERROR_NOT_FOUND;
        /* check whether down sampling rate is one of the supported */
        if ((((PSP_PREVIEWER_DOWN_SAMPLE_RATE1
                        != DDC_prevParams->downSampleRate)
                    && (PSP_PREVIEWER_DOWN_SAMPLE_RATE2
                        != DDC_prevParams->downSampleRate))
                && ((PSP_PREVIEWER_DOWN_SAMPLE_RATE4
                        != DDC_prevParams->downSampleRate)
                    && (PSP_PREVIEWER_DOWN_SAMPLE_RATE8
                        != DDC_prevParams->downSampleRate))))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid down sample rate\n");
        }

        /* check for valid values of pixel size */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && ((PSP_PREVIEWER_INWIDTH_8BIT
                    != (DDC_prevParams->sizeParam).pixelSize)
                && (PSP_PREVIEWER_INWIDTH_10BIT
                    != (DDC_prevParams->sizeParam).pixelSize)))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid pixel size\n");
        }

        /* if inverse A law feature is enable then pixel width should be 8 bit
         * only */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (((Uint32)(0u) != (DDC_prevParams->features
                        & PSP_PREVIEWER_INVERSE_ALAW))
                && (PSP_PREVIEWER_INWIDTH_8BIT
                    != ((DDC_prevParams->sizeParam).pixelSize))))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid pixel size for inverse A law\n");
        }

        /* check horizontal info is proper or not - in case of CCDC both sph
         * and eph should be greater then equal to 2 */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (PSP_PREVIEWER_CHANNEL_CCDC
                == (ddcChannelHandle->channelMode).chanSource.source))
        {
            if (((Uint16)(2u) > (Uint32)(DDC_prevParams->sizeParam).sph)
                || ((Uint16)(2u) > (Uint32)(DDC_prevParams->sizeParam).eph))
            {
                validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
                DDC_PREVIEWER_DEBUG_PRINT("Invalid start/end pixel horizontal");
                DDC_PREVIEWER_DEBUG_PRINT(" value for CCDC source\n");
            }
        }
        /* check horizontal size is proper or not - input width should be
         * in multiple of sampling rate */
        if ((DDC_PREVIEWER_ERROR_NOT_FOUND == validateParamsErrorFlag)
            && (((((Uint32)((DDC_prevParams->sizeParam).eph)
                            - (Uint32)((DDC_prevParams->sizeParam).sph))
                        + (Uint32)(1u))
                    % (Uint32)(DDC_prevParams->downSampleRate))
                != (Uint32)(0u)))
        {
            validateParamsErrorFlag = DDC_PREVIEWER_ERROR_FOUND;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid horizontal size with");
            DDC_PREVIEWER_DEBUG_PRINT(" respect to down sample rate\n");
        }

        /* check that output width is even or not */
        validateParamsHSize = ((((Uint32)((DDC_prevParams->sizeParam).eph)
                    - (Uint32)((DDC_prevParams->sizeParam).sph)) + (Uint32)(1u))
            / (Uint32)(DDC_prevParams->downSampleRate));