nltgen.c

有关OSD开发和ADI公司的几款ADC软件控制

                    SourceValueResolution,
                    RequiredValueResolution);



    Result->bLinearDownScalerRequired = False;
    if(usDeltaMin > (1 << 5))   /* NL Down Scale is requierd */
    {
        switch(Region)
        {
            case orVideo:
                Result->Scaler = vsVideoDownScaler;
            break;

            case orData:
                Result->Scaler = vsDataDownScaler;
            break;
        }
    }
    else
    {
        switch(Region)
        {
            case orVideo:
                Result->Scaler = vsVideoUpScaler;
            break;

            case orData:
                Result->Scaler = vsDataUpScaler;
            break;
        }

        if(usDeltaMax <= (1 << 5))   /* NL Up Scale is requierd without linear down scale*/
        {

        }
        else
        {
            /*
                Delta values are crossing 1 - illegal for NL Up or NL Down scale.
                Must activate linear down scaler to generate Tin' outputs (pixels/lines).
                Tin' = (Tin - 1) / (DeltaMax + 0.00001) - K
                                                            Where K = 4, safety factor.

            */
            Result->bLinearDownScalerRequired = True;

            /*
                The resolution of usTin is 11.0 bits
                The resolution of (usTin - 1) << 5 is 11.5 bits
                The result of FP_SerDiv is in format 16.16 bits
            */
            usTin = (unsigned short)(FP_SerDiv((usTin - 1) << 5, (usDeltaMax + 1)) >> 16) - 4;

            /* Recalculate IMV */
            SourceValueResolution.ucIntegerBits = FP_SERDIVINSIZE;
            SourceValueResolution.ucFractionBits = FP_SERDIVPRECISION;
            RequiredValueResolution.ucIntegerBits = 3;
            RequiredValueResolution.ucFractionBits = 8;
            usInputMagnifyValue = (unsigned short)VP_ConvertValueResolution(
                                                    FP_SerDiv((usTin - 1), (usTref_in - 1)),
                                                    SourceValueResolution,
                                                    RequiredValueResolution );
        }
    }
    Result->usRequiredTin = usTin;


    /*-*-*-* Step 2 - Generate NL position Table *-*-*-*/

    /*
        NLPositionTable[i] = IMV * (RefTable[Ki] + Kf*(RefTable[Ki+1] - RefTable[Ki]))

            Where:
                1. 0 <= i < Tout
                2. i/OMV = Ki.Kf    Ki - int value (9 bits)
                                    Kf - fraction value (7 bits)
                3. NLPositionTable must be calculated in resolution 11.7

    */

    SourceValueResolution.ucIntegerBits = FP_SERDIVINSIZE;
    SourceValueResolution.ucFractionBits = FP_SERDIVPRECISION;
    RequiredValueResolution.ucIntegerBits = 9;
    RequiredValueResolution.ucFractionBits = 16;
    ulInvOMV = VP_ConvertValueResolution( FP_SerDiv((usTref_out - 1), (usTout - 1)),
                                          SourceValueResolution,
                                          RequiredValueResolution );

    ulInvOMVSum = 0;
    if( (NLPositionTable = (unsigned long *)malloc(usTout * sizeof(unsigned long))) == NULL )
    {
        free(RefTable);
        return 2;
    }

    ulIntMask = (~0UL) >> (sizeof(ulIntMask) * 8 - 16);

    for(i=0; i<usTout; i++)
    {                                                                   /* The resolution of ulInvOMVSum is 9.16 */
        usKi = (unsigned short)(ulInvOMVSum >> 16);                     /* Ki = Int of ulInvOMVSum. 9.0 bits */
        usKf = (unsigned short)((ulInvOMVSum & ulIntMask) >> 9);        /* Kf = Fraction of ulInvOMVSum. 0.7 bits */

        /*
            (RefTable[usKi + 1] - RefTable[usKi]) is 9.7 bits resolution
            usKf is bits 0.7 resolution
            (RefTable[usKi + 1] - RefTable[usKi]) * usKf is 9.14 bits resolution
        */

        SourceValueResolution.ucIntegerBits = 9;
        SourceValueResolution.ucFractionBits = 14;
        RequiredValueResolution.ucIntegerBits = 9;
        RequiredValueResolution.ucFractionBits = 7;
        usTmpValue = (unsigned short)VP_ConvertValueResolution(
                (unsigned long)(RefTable[usKi + 1] - RefTable[usKi]) * (unsigned long)usKf,
                SourceValueResolution,
                RequiredValueResolution );

        /* now the (RefTable[usKi + 1] - RefTable[usKi]) * usKf is 9.7 bits resolution */

        /*
            (usTmpValue + RefTable[usKi]) is 9.7 bits resolution
            usInputMagnifyValue is bits 3.8 resolution
            (usTmpValue + RefTable[usKi]) * usInputMagnifyValue is 12.15 bits resolution
            The required resolution of NLPositionTable is 11.7 bits
        */

        SourceValueResolution.ucIntegerBits = 12;
        SourceValueResolution.ucFractionBits = 15;
        RequiredValueResolution.ucIntegerBits = 11;
        RequiredValueResolution.ucFractionBits = 7;
        NLPositionTable[i] = VP_ConvertValueResolution(
                (unsigned long)(usTmpValue + RefTable[usKi]) * (unsigned long)usInputMagnifyValue,
                SourceValueResolution,
                RequiredValueResolution );

        ulInvOMVSum += ulInvOMV;
    }

    usDeltaYiMax = 0;  /* resolution 11.0 */
    switch(Result->Scaler)
    {
        case vsVideoDownScaler:    /* if down scale is required */
        case vsDataDownScaler:
            for(i=0; i<usTout-1; i++)
            {
                usTmpValue =
                    (unsigned short)((NLPositionTable[i+1] >> 7) - (NLPositionTable[i] >> 7));

                if(usDeltaYiMax < usTmpValue )
                    usDeltaYiMax = usTmpValue;
            }
        break;
    }

    /*-*-*-* Step 3 - Generate NL Load Table *-*-*-*/
    if(ScaleAxis == saX)
        usTmpValue = GRP_NlX.Size;
    else
        usTmpValue = GRP_NlY.Size;

    if( (NLTable = (unsigned char *)malloc(usTmpValue)) == NULL )
    {
        free(RefTable);
        free(NLPositionTable);
        return 2;
    }

    /* The current resolution NLPositionTable[i] is 11.7 bits */
    ulIntMask = (~0UL) >> (sizeof(ulIntMask) * 8 - 7);

    switch(Result->Scaler)
    {
        case vsVideoDownScaler:     /* if down scale is required */
        case vsDataDownScaler:
            if(usDeltaYiMax > 3)    /* NL_Table_Format = 4.4 */
            {
                RequiredValueResolution.ucIntegerBits = 4;
                RequiredValueResolution.ucFractionBits = 4;
                REG_NlControl->NlYFormat = 1;
            }
            else                    /* NL_Table_Format = 2.6 */
            {
                RequiredValueResolution.ucIntegerBits = 2;
                RequiredValueResolution.ucFractionBits = 6;
                REG_NlControl->NlYFormat = 0;
            }
        break;
        case vsVideoUpScaler:       /* if up scale is required, NLTable format is 1.7 */
        case vsDataUpScaler:
            RequiredValueResolution.ucIntegerBits = 1;
            RequiredValueResolution.ucFractionBits = 7;
            //REG_NlControl->NlYFormat = ;
        break;

    }

    for(i=0; i<usTout-1; i++)
    {
        usKi = (unsigned short)((NLPositionTable[i+1] >> 7) - (NLPositionTable[i] >> 7));

        /* Take required MSBits form 7 fraction bits */
        usKf = (unsigned short)
            ((NLPositionTable[i+1] & ulIntMask) >> (7 - RequiredValueResolution.ucFractionBits));

        NLTable[i] =(unsigned char)((usKi << RequiredValueResolution.ucFractionBits) + usKf);
    }

    // Copy last line/pixel - safety factor
    for( ;i<usTmpValue; i++)
        NLTable[i] = 1 << RequiredValueResolution.ucFractionBits;



    /*-*-*-* Load NL Table *-*-*-*/
    if(ScaleAxis == saX)
        VDP1_SetGroup(GRP_NlX, NLTable);
    else
        VDP1_SetGroup(GRP_NlY, NLTable);


    free(RefTable);
    free(NLPositionTable);
    free(NLTable);
    return 0;
}