tmdlmbs2_support.c

PNX1500上做视频缩放MBS的源代码

                    ||
                    (pTask->horzOutputShift != 0)
                    ||
                    (((pdlTaskDescr->taskFlags & tmdlMbsFlagSlicingEn)
                      ||
                      (pTask->internallySliced))
                     &&
                     ((pTask->dffMode != MBS_DM_BYPASS)
                      ||
                      (pTask->iffMode != MBS_IM_BYPASS))))
                {
                    needDevLibCoeff = True;
                }
                else
                {
                    //  don't need filters enabled

                    needDevLibCoeff = False;

                    //  use default descriptor values

                    pdlTaskDescr->horzSetup.coeffDescr = horzDefaultDescr;
                }
            }

            if (needDevLibCoeff)
            {
                coefOutputWidth = outputWidth;
                if ((outputWidth < inputWidth)
                    &&
                    (outputWidth + MBS_TRANS_TAPS >= inputWidth))
                {
                    //  downscaling, but transposed will not work

                    coefOutputWidth = inputWidth;
                }

                status = MbsGetHorzCoeff (  
                    inputWidth,
                    coefOutputWidth,
                    bufferWidth,
                    pTask->hFilterSetup.picContent,
                    pTask->hFilterSetup.bandpassLevel,
                    pTask->hFilterSetup.peakingLevel,
                    panoramicMode,
                    pTask->dynamicZoom,
                    pTask->dstFormatInfo.bits.comps,
                    pLoadCoeff,
                    &shift,
                    &(pdlTaskDescr->horzSetup.coeffDescr));

                if (status == TM_OK)
                {
                    if (pdlTaskDescr->horzSetup.coeffDescr.phaseMode !=
                        tmdlMbsPhasesInterpolate)
                    {
                        MbsSetLoadCoeffCmd (
                            pLoadCmd,
                            tmdlMbsHorCoeff,
                            pdlTaskDescr->horzSetup.coeffDescr.phaseMode);

                        MbsFlushCoeffLoad (
                            pLoadCmd,
                            pdlTaskDescr->horzSetup.coeffDescr.phaseMode);

                        pTask->pNextCmd = pLoadCoeff + 2 * 
                            gPhases [pdlTaskDescr->horzSetup.coeffDescr.phaseMode];
                    }
                }
            }
        }

        pHorzCoeffDescr = &(pdlTaskDescr->horzSetup.coeffDescr);

        // setup HW task based on the selected module

        status = tmdlMbsGetScaleFactor2((UInt32) inputWidth,
                                        (UInt32) outputWidth,
                                        bufferWidth,
                                        pHorzCoeffDescr->filterType,
                                        pHorzCoeffDescr->phaseMode,
                                        pTask->dynamicZoom,
                                        &horzScale,
                                        &modifiedLeftBorder,
                                        &modifiedRightBorder,
                                        &modifiedLeftBorderPhase);
    
        if ((pHorzCoeffDescr->filterType == tmdlMbsFilterDirect) 
            ||
            (pHorzCoeffDescr->filterType == tmdlMbsFilterBypass))
        {
            multBase  = 0x100;  // * 0.5
            multShift = 1;      // * 2 => total multiply with 1.0
            multSign  = pHorzCoeffDescr->negative ? 1 : 0;
        }
        else
        {
            UInt32  base = 512;

            // transposed polyphase
            // NOTE: calculation works only for downscaling !!!
            //       (upscaling in transposed mode is not supported anyway)

            multBase  = (base * horzScale) / MBS_HSP_SCALE_UNITY;
            multShift = 0;     // no divide
            multSign  = pHorzCoeffDescr->negative ? 1 : 0;

            // check the range on the multbase

            while (multBase < 0x100)
            {
                base *= 2;
                multShift -= 1;
                multBase  = (base * horzScale) / MBS_HSP_SCALE_UNITY;
            }

            if (multShift < -4)
            {
                //  can't handle scaling factor!

                status = TMDL_ERR_MBS_BAD_PARAMETER;
            }
        }
    }                

    if (pTask->horzOutputShift == 0)
    {
        //  assume AntiAging is disabled

        startPhase = 0;
        pTask->bBumpX = False;
        pTask->horzShift = 0;
    }
    else    //  need to add a phase shift for AntiAging
    {
        //  add an additional pixel on the right edge to give smooth scrolling

        pTask->bBumpX = True;

        if (pHorzCoeffDescr->filterType == tmdlMbsFilterTransposed)
        {
            //  NOTE:   in transposed mode, adding a starting phase shift
            //          tends to move the image to the left, not the right.
            //          We need to shift the starting address and use
            //          phasePerInputPixel - startPhase to get the correct
            //          shift to the right.
            //
            //  phasePerInputPixel is the phase needed to consume 1 input pixel
            //
            Int32   phasePerInputPixel;

            phasePerInputPixel = 1024 * outputWidth / inputWidth;

            startPhase = pTask->horzOutputShift * 16;
            pTask->horzShift = startPhase / phasePerInputPixel;
            startPhase = startPhase % phasePerInputPixel;

            if (startPhase < 0)
            {
                startPhase = -startPhase;
            }
            else if (startPhase > 0)
            {
                ++pTask->horzShift;
                startPhase = phasePerInputPixel - startPhase;
            }
        }
        else    //  else normal polyphase filter or in bypass mode
        {
            startPhase = pTask->horzOutputShift * 16 * inputWidth / outputWidth;

            pTask->horzShift = startPhase / 1024;
            startPhase  = startPhase % 1024;
            if (startPhase < 0)
            {
                startPhase += 1024;
                --pTask->horzShift;
            }
        }
    }

    if (pHorzCoeffDescr->filterType == tmdlMbsFilterTransposed)
    {
        // A transposed filter has a run-in error on the left side and a scale-
        // factor rounding error on the right side. This code will shift the
        // image so the errors are of equal size on both sides. A negative shift
        // is not implemented, because not enough source pixels are available, which
        // means that the run-in cannot be compensated.
        int shift = modifiedLeftBorder - leftBorder;

        if (modifiedRightBorder - rightBorder - shift > 0)
        {
            pTask->transSrcSizeShift = modifiedRightBorder - rightBorder - shift;
        }
        else
        {
            pTask->transSrcSizeShift = 0;
        }

        pTask->transSrcHorzShift = shift;
        pTask->transSrcPhaseShift = modifiedLeftBorderPhase;
    }
    else
    {
        pTask->transSrcSizeShift = 0;
        pTask->transSrcHorzShift = 0;
        pTask->transSrcPhaseShift = 0;
    }

    if ((status == TM_OK) && scaling)
    {
        //  horizontal scaling, assume linear scaling

        horzInitialZoom.bits.scaleFactor = horzScale;

        if (pdlTaskDescr->horzSetup.panoramaEnable)
        {
            UInt32      zoom;
            Int32       dzoom, ddzoom;

            if (pHorzCoeffDescr->filterType != tmdlMbsFilterDirect)
            {
                status = TMDL_ERR_MBS_BAD_PARAMETER;
            }
            else
            {
                status = MbsPanoramicScaling (  
                    inputWidth, 
                    outputWidth, 
                    pdlTaskDescr->horzSetup.panCenterScale,
                    &zoom, 
                    &dzoom, 
                    &ddzoom);

                horzInitialZoom.bits.scaleFactor = zoom;
                pTask->pCtrlRegs [tlHorzScaleZoomDelta] = dzoom;
                pTask->pCtrlRegs [tlHorzScaleZoomChange] = ddzoom;
            }
        }

        switch (pHorzCoeffDescr->filterType)
        {
        case tmdlMbsFilterBypass:
            horzPhaseCtrl.bits.dtoOffset = 0;
            modeControl.bits.horzProcessingMode = MBS_HPM_BYPASS;
            break;

        case tmdlMbsFilterDirect:
            modeControl.bits.horzProcessingMode = MBS_HPM_NORMAL;
            if (pHorzCoeffDescr->phaseMode == tmdlMbsPhasesInterpolate)
            {
                horzPhaseCtrl.bits.dtoOffset = 0x400 + (UInt32) startPhase;
            }
            else
            {
                horzPhaseCtrl.bits.dtoOffset = 0x200 * 
                    pHorzCoeffDescr->nrOfTaps + 
                    (UInt32) startPhase;
            }
            break;

        case tmdlMbsFilterTransposed:
            horzPhaseCtrl.bits.dtoOffset = startPhase;

            if (horzScale >= MBS_HSP_SCALE_UNITY)
            {
                //  if the tweaks have created a scale factor larger than
                //  unity, transposed will not work; 

                if (pdlTaskDescr->horzSetup.userCoeffs)
                {
                    status = TMDL_ERR_MBS_BAD_PARAMETER;
                }
                else
                {
                    //  by setting panoramicMode == True, we will use normal
                    //  polyphase filtering

                    panoramicMode = True;
                    goto MbsInitHorzScaling_restart;
                }
            }
            else
            {
                modeControl.bits.horzProcessingMode = MBS_HPM_TRANSPOSED;
            }
            break;

        default:
            status = TMDL_ERR_MBS_BAD_PARAMETER;
            break;
        }

        horzInitialZoom.bits.phaseMode  = pHorzCoeffDescr->phaseMode;
        horzPhaseCtrl.bits.quantShift   = multShift + shift;
        horzPhaseCtrl.bits.multiplyBase = multBase;
        horzPhaseCtrl.bits.multiplySign = multSign;

        pTask->pCtrlRegs [tlModeControl] = modeControl.u32;
        pTask->pCtrlRegs [tlHorzScaleZoom] = horzInitialZoom.u32;
        pTask->pCtrlRegs [tlHorzScaleControl] = horzPhaseCtrl.u32;

        //  save initial scaling info

        pTask->horzScaleInfo.bits.dto_offset = horzPhaseCtrl.bits.dtoOffset;
        pTask->horzScaleInfo.bits.nr_taps = pHorzCoeffDescr->nrOfTaps;
    }

    return status;

}   //  MbsInitHorzScaling


//-----------------------------------------------------------------------------
// FUNCTION:    MbsInitRegDefaults:
//
// DESCRIPTION: Initializes the task's register values to the defaults.
//
// RETURN:      None
//
// NOTES:       None
//-----------------------------------------------------------------------------
//
void
MbsInitRegDefaults (void)

{

    mbsRegDefaults [tlModeControlLoad]  = MBS_TASK_LOAD_REGS
        + MBS_REGOFFSET_MODE_CTRL
        + ((1 - 1) << MBS_OPCODE_COUNT_SHIFT);             
    // nr of register to load minus one         
    
    // mode control registers

    mbsRegDefaults [tlModeControl] = MBS_MODE_CTRL_DEFAULT;

    // input format control registers

    mbsRegDefaults [tlInputFormatLoad] = MBS_TASK_LOAD_REGS              
        + MBS_REGOFFSET_INPUT_FORMAT
        + ((3 - 1) << MBS_OPCODE_COUNT_SHIFT);       

    mbsRegDefaults [tlInputFormat] = MBS_INPUT_FORMAT_DEFAULT;
    mbsRegDefaults [tlInputSize] = MBS_WINDOW_SIZE_DEFAULT;
    mbsRegDefaults [tlInputVarFormat] = MBS_VARIABLE_FORMAT_DEFAULT;
    
    // video input address generation control registers

    mbsRegDefaults [tlInputBuffersLoad] = MBS_TASK_LOAD_REGS              
        + MBS_REGOFFSET_SRC_ADDR
        + ((8 - 1) << MBS_OPCODE_COUNT_SHIFT);       

    mbsRegDefaults [tlInputBuf1] = 0;
    mbsRegDefaults [tlInputBuf1Pitch] = MBS_LINE_PITCH1_DEFAULT;
    mbsRegDefaults [tlInputBuf2] = 0;
    mbsRegDefaults [tlInputBuf2Pitch] = MBS_LINE_PITCH2_DEFAULT;
    mbsRegDefaults [tlInputBuf3] = 0;
    mbsRegDefaults [tlInputBuf4] = 0;
    mbsRegDefaults [tlInputBuf5] = 0;
    mbsRegDefaults [tlInputBuf6] = 0;   
 
    // horizontal video processing control registers

    mbsRegDefaults [tlHorzScaleLoad] =  MBS_TASK_LOAD_REGS              
        + MBS_REGOFFSET_HORZ_ZOOM
        + ((4 - 1) << MBS_OPCODE_COUNT_SHIFT);       

    mbsRegDefaults [tlHorzScaleZoom] = MBS_HORZ_ZOOM_DEFAULT;
    mbsRegDefaults [tlHorzScaleControl] = MBS_HORZ_PHASE_DEFAULT;
    mbsRegDefaults [tlHorzScaleZoomDelta] = MBS_ZOOM_DELTA_DEFAULT;
    mbsRegDefaults [tlHorzScaleZoomChange] = MBS_ZOOM_CHANGE_DEFAULT;

    // color space matrix registers

    mbsRegDefaults [tlColorSpaceMatrixLoad] = MBS_TASK_LOAD_REGS              
        + MBS_REGOFFSET_CSM
        + ((5 - 1) << MBS_OPCODE_COUNT_SHIFT);

    mbsRegDefaults [tlCscC00C01C02] = MBS_COEFF0_DEFAULT;
    mbsRegDefaults [tlCscC10C11C12] = MBS_COEFF1_DEFAULT;
    mbsRegDefaults [tlCscC20C21C22] = MBS_COEFF2_DEFAULT;
    mbsRegDefaults [tlCscD0D1D2] = MBS_INPUT_OFFSETS_DEFAULT;
    mbsRegDefaults [tlCscE0E1E2] = MBS_OUTPUT_OFFSETS_DEFAULT;

    // vertical video processing control registers

    mbsRegDefaults [tlVertScaleLoad] = MBS_TASK_LOAD_REGS              
        + MBS_REGOFFSET_VERT_ZOOM
        + ((4 - 1) << MBS_OPCODE_COUNT_SHIFT); 
                     
    mbsRegDefaults [tlVertScaleZoom] = MBS_VERT_ZOOM_DEFAULT;
    mbsRegDefaults [tlVertScaleControl] = MBS_VERT_PHASE_DEFAULT;
    mbsRegDefaults [tlVertScaleZoomDelta] = MBS_ZOOM_DELTA_DEFAULT;
    mbsRegDefaults [tlVertScaleZoomChange] = MBS_ZOOM_CHANGE_DEFAULT;

    // EDDI control registers

    mbsRegDefaults [tlEddiLoad] = MBS_TASK_LOAD_REGS              
        + MBS_REGOFFSET_EDDI
        + ((2 - 1) << MBS_OPCODE_COUNT_SHIFT); 

    mbsRegDefaults [tlEddiControl1] = MBS_EDDI_CONTROL1_DEFAULT;
    mbsRegDefaults [tlEddiControl2] = MBS_EDDI_CONTROL2_DEFAULT;

    // color