llc_previewer.c

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

        switch(prevConfigParams->outPixelOrderParam)
        {
            case PSP_PREVIEWER_PIXELORDER_YCBYCR:
                tempVar = (Uint32)CSL_PREV_PCR_YCPOS_YCBYCR;
                break;
            case PSP_PREVIEWER_PIXELORDER_YCRYCB:
                tempVar = (Uint32)CSL_PREV_PCR_YCPOS_YCRYCB;
                break;
            case PSP_PREVIEWER_PIXELORDER_CBYCRY:
                tempVar = (Uint32)CSL_PREV_PCR_YCPOS_CBYCRY;
                break;
            case PSP_PREVIEWER_PIXELORDER_CRYCBY:
                tempVar = (Uint32)CSL_PREV_PCR_YCPOS_CRYCBY;
                break;
            default:
                break;
        }
        CSL_FINS(prevRegs->PCR, PREV_PCR_YCPOS,
            tempVar);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->PCR, PREV_PCR_YCPOS);
        if (tempVar != x)
        {
            llcPrevDebugErrorStatus = 17;
        }
#endif /* PREVIEWER_DEBUG */


        /* configure averager */
        CSL_FINS(prevRegs->AVE, PREV_AVE_ODDDIST,
            (Uint32)CSL_PREV_AVE_ODDDIST_2PIXELS);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->AVE, PREV_AVE_ODDDIST);
        if ((Uint32)CSL_PREV_AVE_ODDDIST_2PIXELS != x)
        {
            llcPrevDebugErrorStatus = 18;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->AVE, PREV_AVE_EVENDIST,
            (Uint32)CSL_PREV_AVE_EVENDIST_2PIXELS);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->AVE, PREV_AVE_EVENDIST);
        if ((Uint32)CSL_PREV_AVE_EVENDIST_2PIXELS != x)
        {
            llcPrevDebugErrorStatus = 19;
        }
#endif /* PREVIEWER_DEBUG */
        switch(prevConfigParams->downSampleRate)
        {
            case PSP_PREVIEWER_DOWN_SAMPLE_RATE1:
                tempVar = CSL_PREV_AVE_COUNT_NOAVERAGING;
                break;
            case PSP_PREVIEWER_DOWN_SAMPLE_RATE2:
                tempVar = CSL_PREV_AVE_COUNT_2PIXEL_AVG;
                break;
            case PSP_PREVIEWER_DOWN_SAMPLE_RATE4:
                tempVar = CSL_PREV_AVE_COUNT_4PIXEL_AVG;
                break;
            case PSP_PREVIEWER_DOWN_SAMPLE_RATE8:
                tempVar = CSL_PREV_AVE_COUNT_8PIXEL_AVG;
                break;
            default:
                tempVar = CSL_PREV_AVE_COUNT_NOAVERAGING;
                break;
        }
        CSL_FINS(prevRegs->AVE, PREV_AVE_COUNT,
            (Uint32)tempVar);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->AVE, PREV_AVE_COUNT);
        if ((Uint32)tempVar != x)
        {
            llcPrevDebugErrorStatus = 20;
        }
#endif /* PREVIEWER_DEBUG */


        /* Enable Inverse A-Law if it is enabled in configuration */
        if ((Uint32)0 != (prevConfigParams->features
                & PSP_PREVIEWER_INVERSE_ALAW))
        {
            CSL_FINS(prevRegs->PCR, PREV_PCR_INVALAW,
                (Uint32)CSL_PREV_PCR_INVALAW_ENABLE);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_INVALAW);
            if ((Uint32)CSL_PREV_PCR_INVALAW_ENABLE != x)
            {
                llcPrevDebugErrorStatus = 22;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* enable dark frame subtract if it is enabled in configuration */
        if ((Uint32)0 != (prevConfigParams->features
                & PSP_PREVIEWER_DARK_FRAME_SUBTRACT))
        {
            /* enable dark frame subtract in PCR */
            CSL_FINS(prevRegs->PCR, PREV_PCR_DRKFEN,
                (Uint32)CSL_PREV_PCR_DRKFEN_ENABLE);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_DRKFEN);
            if ((Uint32)CSL_PREV_PCR_DRKFEN_ENABLE != x)
            {
                llcPrevDebugErrorStatus = 23;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* enable lens shading if it is enabled in configuration */
        if ((Uint32)0 != (prevConfigParams->features
                & PSP_PREVIEWER_LENS_SHADING))
        {
            /* enable lens shading in PCR */
            CSL_FINS(prevRegs->PCR, PREV_PCR_SHADE_COMP,
                (Uint32)CSL_PREV_PCR_SHADE_COMP_ENABLE);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_SHADE_COMP);
            if ((Uint32)CSL_PREV_PCR_SHADE_COMP_ENABLE != x)
            {
                llcPrevDebugErrorStatus = 24;
            }
#endif /* PREVIEWER_DEBUG */
            /* set lens shading shift parameter */
            CSL_FINS(prevRegs->PCR, PREV_PCR_SHADE_SFT,
                (Uint32)prevConfigParams->lensShadingShift);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_SHADE_SFT);
            if ((Uint32)prevConfigParams->lensShadingShift != x)
            {
                llcPrevDebugErrorStatus = 25;
            }
#endif /* PREVIEWER_DEBUG */
            /* enable dark frame subtract in PCR */
            CSL_FINS(prevRegs->PCR, PREV_PCR_DRKFEN,
                (Uint32)CSL_PREV_PCR_DRKFEN_ENABLE);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_DRKFEN);
            if ((Uint32)CSL_PREV_PCR_DRKFEN_ENABLE != x)
            {
                llcPrevDebugErrorStatus = 26;
            }
#endif /* PREVIEWER_DEBUG */
        }
        if (((Uint32)0 != (prevConfigParams->features
                    & PSP_PREVIEWER_DARK_FRAME_SUBTRACT))
            || ((Uint32)0 != (prevConfigParams->features
                    & PSP_PREVIEWER_LENS_SHADING)))
        {
            /* set the dark frame address and line offset */
            CSL_FINS(prevRegs->DSDR_ADDR, PREV_DSDR_ADDR_DRKF,
                (Uint32)prevConfigParams->darkFrameAddr);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->DSDR_ADDR, PREV_DSDR_ADDR_DRKF);
            if ((Uint32)prevConfigParams->darkFrameAddr != x)
            {
                llcPrevDebugErrorStatus = 27;
            }
#endif /* PREVIEWER_DEBUG */
            CSL_FINS(prevRegs->DRKF_OFFSET, PREV_DRKF_OFFSET_OFFSET,
                (Uint32)prevConfigParams->darkFrameOffset);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->DRKF_OFFSET, PREV_DRKF_OFFSET_OFFSET);
            if ((Uint32)prevConfigParams->darkFrameOffset != x)
            {
                llcPrevDebugErrorStatus = 28;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* Enable HMF and set its threshold if it is enabled in
         * configuration */
        if ((Uint32)0 != (prevConfigParams->features
                & PSP_PREVIEWER_HMF))
        {
            CSL_FINS(prevRegs->PCR, PREV_PCR_HMEDEN,
                (Uint32)CSL_PREV_PCR_HMEDEN_ENABLE);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_HMEDEN);
            if ((Uint32)CSL_PREV_PCR_HMEDEN_ENABLE != x)
            {
                llcPrevDebugErrorStatus = 29;
            }
#endif /* PREVIEWER_DEBUG */
            CSL_FINS(prevRegs->HMED, PREV_HMED_ODDDIST,
                (Uint32)CSL_PREV_HMED_ODDDIST_2PIXELS);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->HMED, PREV_HMED_ODDDIST);
            if ((Uint32)CSL_PREV_HMED_ODDDIST_2PIXELS != x)
            {
                llcPrevDebugErrorStatus = 30;
            }
#endif /* PREVIEWER_DEBUG */
            CSL_FINS(prevRegs->HMED, PREV_HMED_EVENDIST,
                (Uint32)CSL_PREV_HMED_EVENDIST_2PIXELS);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->HMED, PREV_HMED_EVENDIST);
            if ((Uint32)CSL_PREV_HMED_EVENDIST_2PIXELS != x)
            {
                llcPrevDebugErrorStatus = 31;
            }
#endif /* PREVIEWER_DEBUG */
            CSL_FINS(prevRegs->HMED, PREV_HMED_THRESHOLD,
                (Uint32)prevConfigParams->hmfThreshold);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->HMED, PREV_HMED_THRESHOLD);
            if ((Uint32)prevConfigParams->hmfThreshold != x)
            {
                llcPrevDebugErrorStatus = 32;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* Enable Noise filter and set its coefficients if it is enabled in
         * configuration */
        if ((Uint32)0 != (prevConfigParams->features
                & PSP_PREVIEWER_NOISE_FILTER))
        {
            CSL_FINS(prevRegs->PCR, PREV_PCR_NFEN,
                (Uint32)CSL_PREV_PCR_NFEN_ENABLE);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->PCR, PREV_PCR_NFEN);
            if ((Uint32)CSL_PREV_PCR_NFEN_ENABLE != x)
            {
                llcPrevDebugErrorStatus = 33;
            }
#endif /* PREVIEWER_DEBUG */
            /* Set coefficients of NF */
            /* Set table address */
            CSL_FINS(prevRegs->SET_TBL_ADDRESS, PREV_SET_TBL_ADDRESS_ADDR,
                (Uint32)LLC_PREVIEWER_NOISE_FILTER_START_ADDR);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->SET_TBL_ADDRESS,
                PREV_SET_TBL_ADDRESS_ADDR);
            if ((Uint32)LLC_PREVIEWER_NOISE_FILTER_START_ADDR != x)
            {
                llcPrevDebugErrorStatus = 34;
            }
#endif /* PREVIEWER_DEBUG */
            /* set data */
            for(i=0; i <= (LLC_PREVIEWER_NOISE_FILTER_END_ADDR
                    - LLC_PREVIEWER_NOISE_FILTER_START_ADDR); i++)
            {
                prevRegs->SET_TBL_DATA = (Uint32)prevConfigParams
                    ->noiseFilterCoeffsParam.noise[i];
                /* Address is auto incremented */
            }
#ifdef PREVIEWER_DEBUG
            CSL_FINS(prevRegs->SET_TBL_ADDRESS, PREV_SET_TBL_ADDRESS_ADDR,
                (Uint32)LLC_PREVIEWER_NOISE_FILTER_START_ADDR);
            /* get data */
            for(i=0; i <= (LLC_PREVIEWER_NOISE_FILTER_END_ADDR
                    - LLC_PREVIEWER_NOISE_FILTER_START_ADDR); i++)
            {
                x = prevRegs->SET_TBL_DATA;
                if ((Uint8)prevConfigParams->noiseFilterCoeffsParam.noise[i]
                    != x)
                {
                    llcPrevDebugErrorStatus = 35;
                }
                /* Address is auto incremented */
            }
#endif /* PREVIEWER_DEBUG */

            /* write the strength of the weighted average */
            CSL_FINS(prevRegs->NF, PREV_NF_STRNGTH,
                (Uint32)prevConfigParams->noiseFilterCoeffsParam.strength);
#ifdef PREVIEWER_DEBUG
            x = CSL_FEXT(prevRegs->NF, PREV_NF_STRNGTH);
            if ((Uint32)prevConfigParams->noiseFilterCoeffsParam.strength
                != x)
            {
                llcPrevDebugErrorStatus = 36;
            }
#endif /* PREVIEWER_DEBUG */
        }

        /* Setting white balancing parameters */
        /* Set the common gain for white balancing in register */
        CSL_FINS(prevRegs->WB_DGAIN, PREV_WB_DGAIN_DGAIN,
            (Uint32)((prevConfigParams->whiteBalanceParam).wbDgain));
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WB_DGAIN, PREV_WB_DGAIN_DGAIN);
        if ((Uint32)((prevConfigParams->whiteBalanceParam).wbDgain) != x)
        {
            llcPrevDebugErrorStatus = 37;
        }
#endif /* PREVIEWER_DEBUG */
        /* Set individual color gains in register for white balancing */
        CSL_FINS(prevRegs->WBGAIN, PREV_WBGAIN_COEF0,
            (Uint32)prevConfigParams->whiteBalanceParam.wbGain[0]);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WBGAIN, PREV_WBGAIN_COEF0);
        if ((Uint32)prevConfigParams->whiteBalanceParam.wbGain[0] != x)
        {
            llcPrevDebugErrorStatus = 38;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->WBGAIN, PREV_WBGAIN_COEF1,
            (Uint32)prevConfigParams->whiteBalanceParam.wbGain[1]);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WBGAIN, PREV_WBGAIN_COEF1);
        if ((Uint32)prevConfigParams->whiteBalanceParam.wbGain[1] != x)
        {
            llcPrevDebugErrorStatus = 39;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->WBGAIN, PREV_WBGAIN_COEF2,
            (Uint32)prevConfigParams->whiteBalanceParam.wbGain[2]);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WBGAIN, PREV_WBGAIN_COEF2);
        if ((Uint32)prevConfigParams->whiteBalanceParam.wbGain[2] != x)
        {
            llcPrevDebugErrorStatus = 40;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->WBGAIN, PREV_WBGAIN_COEF3,
            (Uint32)prevConfigParams->whiteBalanceParam.wbGain[3]);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WBGAIN, PREV_WBGAIN_COEF3);
        if ((Uint32)prevConfigParams->whiteBalanceParam.wbGain[3] != x)
        {
            llcPrevDebugErrorStatus = 41;
        }
#endif /* PREVIEWER_DEBUG */
        /* Setting position of the colors in 4x4 grid */
        CSL_FINS(prevRegs->WBSEL, PREV_WBSEL_0_0,
            (Uint32)prevConfigParams->whiteBalanceParam.position[0][0]);
#ifdef PREVIEWER_DEBUG
        x = CSL_FEXT(prevRegs->WBSEL, PREV_WBSEL_0_0);
        if ((Uint32)prevConfigParams->whiteBalanceParam.position[0][0] != x)
        {
            llcPrevDebugErrorStatus = 42;
        }
#endif /* PREVIEWER_DEBUG */
        CSL_FINS(prevRegs->WBSEL, PREV_WBSEL_0_1,
            (Uint32)prevConfigParams->whiteBalanceParam.position[0][1]);
#ifdef PREVIEWER_DEBUG