tmdlmbs2.c

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

    DBG_ASSERT2( instance != 0, ("tmdlMbsTaskDispatch: Instance = 0") );
    DBG_ASSERT2( pMbsInst->key == MBS_INSTANCE_KEY, 
                 ("tmdlMbsTaskDispatch: key 0x%X != 0x%X", pMbsInst->key, MBS_INSTANCE_KEY) );
    DBG_ASSERT2( pMbsInst->setupDone == True, ("tmdlMbsTaskDispatch: Setup not done") );

    pPrevDispatchTask = Null;
    pFirstDispatchTask = Null;
    index = taskCount - 1;
    do
    {
        updates = MBS_DISPATCH_UPDATE_NONE;

        taskIndex = (UInt32) pTaskDisp [index].taskHandle - 1;
        DBG_ASSERT2( taskIndex < pMbsInst->totalNrOfTasks, 
                     ("tmdlMbsTaskDispatch: Invalid task idx %d >= %d", taskIndex, pMbsInst->totalNrOfTasks) );

        pTask = &(pMbsInst->pTaskInfo [taskIndex]);
        DBG_ASSERT2( pMbsInst->pTaskInfo[taskIndex].empty == False,
                     ("tmdlMbsTaskDispatch: task info empty") );

        if ((pTask->taskStatus == tmdlMbsTaskPending)
            ||
            (pTask->taskStatus == tmdlMbsTaskInFifo))
        {
            //  trying to reuse a task which is still in use

            return TMDL_ERR_MBS_BUSY;
        }

        pTaskDescr = &(pTask->dlTaskDescr);

        //  update task descriptor with passed values

        if (pTaskDisp [index].pInputBuffer1 != Null)
        {
            pTaskDescr->inputBuffer.memBuf1 =
                *(pTaskDisp [index].pInputBuffer1);
            updates = MBS_DISPATCH_UPDATE_INBUF;
        }
        if (pTaskDisp [index].pInputBuffer2 != Null)
        {
            pTaskDescr->inputBuffer.memBuf2 =
                *(pTaskDisp [index].pInputBuffer2);
            updates = MBS_DISPATCH_UPDATE_INBUF;
        }

        if (pTaskDisp [index].pInputBuffer3 != Null)
        {
            pTaskDescr->inputBuffer.memBuf3 =
                *(pTaskDisp [index].pInputBuffer3);
            updates = MBS_DISPATCH_UPDATE_INBUF;
        }

        if (pTaskDisp [index].pOutputBuffer1 != Null)
        {
            pTaskDescr->outputBuffer.memBuf1 =
                *(pTaskDisp [index].pOutputBuffer1);
            updates |= MBS_DISPATCH_UPDATE_OUTBUF;
        }
        if (pTaskDisp [index].pOutputBuffer2 != Null)
        {
            pTaskDescr->outputBuffer.memBuf2 =
                *(pTaskDisp [index].pOutputBuffer2);
            updates |= MBS_DISPATCH_UPDATE_OUTBUF;
        }


        MbsSliceTask(pMbsInst, taskIndex, &nrOfSlices);

        pDispatchTask = &(pMbsInst->pTaskInfo [taskIndex + nrOfSlices - 1]);
        pPrevUpdateTask = pPrevDispatchTask;
        pUpdateTask = pTask;
        if ( pFirstDispatchTask == Null  && index == 0) pFirstDispatchTask = pDispatchTask;
        for (i = 0; i < nrOfSlices; i++)
            {
            pUpdateTask = &(pMbsInst->pTaskInfo [taskIndex + i]);
            if (pUpdateTask->updateFlags & tmdlMbsUpdateScaling)
            {
                status = MbsInitScaling (pMbsInst, pUpdateTask);
            }
            if (status == TM_OK)
            {
                //  now update the buffers if needed
                if (pUpdateTask->updateFlags & tmdlMbsUpdateBuffers)
                {
                    //  other changes require new buffer calculations
                    status = MbsUpdateBuffers (pMbsInst, pUpdateTask);
                }
                else
                {
                    //  no changes which require new buffer calculations, we
                    //  can just update the addresses
                    if (updates & MBS_DISPATCH_UPDATE_INBUF)
                    {
                        MbsUpdateSrcBufferRegs (pUpdateTask);
                    }
                    if (updates & MBS_DISPATCH_UPDATE_OUTBUF)
                    {
                        MbsUpdateDstBufferRegs (pUpdateTask);
                    }
                }
            }
            if (status == TM_OK)
            {
                pUpdateTask->taskStatus = tmdlMbsTaskIdle;
                pUpdateTask->abortTask = False;
                if (pUpdateTask != Null)
                {
                    //  link this task to the previous task in the list
                    pUpdateTask->pLinkedTask = pPrevUpdateTask;
                    MbsAppendTask (pUpdateTask, pPrevUpdateTask);
                    //  flush the main command regs from previous task
                    tmmlCacheFlush (pUpdateTask->pCtrlRegs, pUpdateTask->tlSize + 4);
            }
        }
            pPrevUpdateTask = pUpdateTask;
        }
        pPrevDispatchTask = pDispatchTask;
        index--;

    } while ((index >= 0) && (status == TM_OK));

    if (status == TM_OK)
    {
//        pUpdateTask->pLinkedTask = pPrevDispatchTask;  //  end linked list of tasks
//        MbsAppendTask (pUpdateTask, pPrevDispatchTask);

        //  now flush the main command regs portion of the task list

//        tmmlCacheFlush (pUpdateTask->pCtrlRegs, pUpdateTask->tlSize + 4);

        status = MbsTaskDispatch (  pMbsInst->unit,
                                    pFirstDispatchTask, 
                                    pMbsInst->streamMode);
    }

    return status;

}   //  tmdlMbsTaskDispatch


//-----------------------------------------------------------------------------
// FUNCTION:    tmdlMbsTaskUpdateFrequency:
//
// DESCRIPTION: Sets the MBS frequency for the given task
//
// RETURN:      tmErrorCode_t = resulting error condition or TM_OK
//
// NOTES:       
//-----------------------------------------------------------------------------
//
tmErrorCode_t
tmdlMbsTaskUpdateFrequency (
    tmInstance_t            instance,       //  I: instance
    tmdlMbsTaskHandle_t     taskHandle,     //  I: task handle
    tmdlMbs2_clockFreq_t    clockFreq       //  I: clock freq index
    )
{
    ptmdlMbsInstance_t  pMbsInst = (ptmdlMbsInstance_t) instance;
    UInt32              taskIndex = (UInt32) taskHandle - 1;

    ptmdlMbsTaskInfo_t  pTask;

    DBG_ASSERT2( instance != 0, ("tmdlMbsTaskUpdateFrequency: Instance = 0") );
    DBG_ASSERT2( pMbsInst->key == MBS_INSTANCE_KEY, 
                 ("tmdlMbsTaskUpdateFrequency: key 0x%X != 0x%X", pMbsInst->key, MBS_INSTANCE_KEY) );

    pTask = &(pMbsInst->pTaskInfo [taskIndex]);

    DBG_ASSERT2( pMbsInst->pTaskInfo[taskIndex].empty == False,
                 ("tmdlMbsTaskUpdateFrequency: task info empty") );
    
    if ((pTask->taskStatus == tmdlMbsTaskPending)
        ||
        (pTask->taskStatus == tmdlMbsTaskInFifo))
    {
        //  trying to reuse a task which is still in use
        
        return TMDL_ERR_MBS_BUSY;
    }
    else
    {
        pTask->clockFreqUpdate = True;
        pTask->clockFreq = clockFreq;
    }
    return TM_OK;

}   //  tmdlMbsTaskUpdateFrequency

//-----------------------------------------------------------------------------
// FUNCTION:    tmdlMbsTaskUpdateMsa3Control:
//
// DESCRIPTION: Sets the MSA3 control values for tmdlMbsDeInterModeMajority3dyn
//              and tmdlMbsDeInterModeMajority3dynEnh de-interlacing.
//
// RETURN:      tmErrorCode_t = resulting error condition or TM_OK
//
// NOTES:       The tmdlMbsMsa3Ctrl_t values MUST be set AFTER calling
//              tmdlMbsTaskUpdateDei.
//-----------------------------------------------------------------------------
//
tmErrorCode_t
tmdlMbsTaskUpdateMsa3Control (
    tmInstance_t            instance,       //  I: instance
    tmdlMbsTaskHandle_t     taskHandle,     //  I: task handle
    ptmdlMbsMsa3Ctrl_t      pMsa3Ctrl       //  I: ptr to control values
    )

{
    ptmdlMbsInstance_t  pMbsInst = (ptmdlMbsInstance_t) instance;
    UInt32              taskIndex = (UInt32) taskHandle - 1;

    ptmdlMbsTaskInfo_t  pTask;

    union _mbsMsa3dynamicCtrl  msa3Control;

    DBG_ASSERT2( instance != 0, ("tmdlMbsTaskUpdateMsa3Control: Instance = 0") );
    DBG_ASSERT2( pMbsInst->key == MBS_INSTANCE_KEY, 
                 ("tmdlMbsTaskUpdateMsa3Control: key 0x%X != 0x%X", pMbsInst->key, MBS_INSTANCE_KEY) );

    MBS2_ERR_CHECK(((pMbsInst->features & tmdlMbsFeatureDeint) != 0),
                   TMDL_ERR_MBS_NOT_SUPPORTED,
                   "tmdlMbsTaskUpdateMsa3Control: Deinterlacing not supported!");

    MBS2_ERR_CHECK(((pMbsInst->features & tmdlMbsFeatureDynMsa3) != 0),
                   TMDL_ERR_MBS_NOT_SUPPORTED,
                   "tmdlMbsTaskUpdateMsa3Control: Mode not supported!");

    pTask = &(pMbsInst->pTaskInfo [taskIndex]);

    DBG_ASSERT2( pMbsInst->pTaskInfo[taskIndex].empty == False,
                 ("tmdlMbsTaskUpdateMsa3Control: task info empty") );
    
    DBG_ASSERT2((pMsa3Ctrl->t1 <= MBS_MSA3_CTRL_T1_MAX),
                ("tmdlMbsTaskUpdateMsa3Control: t1 %d > %d", pMsa3Ctrl->t1, MBS_MSA3_CTRL_T1_MAX));
    DBG_ASSERT2((pMsa3Ctrl->t2 <= MBS_MSA3_CTRL_T2_MAX),
                ("tmdlMbsTaskUpdateMsa3Control: t2 %d > %d", pMsa3Ctrl->t2, MBS_MSA3_CTRL_T2_MAX));

    msa3Control.u32 = 0;    //  clear unused bits
    msa3Control.bits.t1 = pMsa3Ctrl->t1;
    msa3Control.bits.t2 = pMsa3Ctrl->t2;

    pTask->pCtrlRegs [tlMsa3Ctrl] = msa3Control.u32;

    return TM_OK;

}   //  tmdlMbsTaskUpdateMsa3Control


//-----------------------------------------------------------------------------
// FUNCTION:    tmdlMbsTaskUpdateRects:
//
// DESCRIPTION: Updates the buffer rectangles and recalculates the offsets
//              into the buffers.  If a rectangle buffer is Null, no change
//              is made.
//
// RETURN:      tmErrorCode_t = resulting error condition or TM_OK
//
// NOTES:       DO NOT call tmdlMbsTaskUpdateRects until the task status has
//              changed to tmdlMbsTaskCompleted (or tmdlMbsTaskIdle).
//
//              pSliceRect is ignored if the task was not created with the
//              tmdlMbsFlagSlicingEn task flag set.
//-----------------------------------------------------------------------------
//
tmErrorCode_t
tmdlMbsTaskUpdateRects (
    tmInstance_t            instance,       //  I: instance
    tmdlMbsTaskHandle_t     taskHandle,     //  I: task handle
    ptmRect_t               pSrcRect,       //  I: new src rectangle
    ptmRect_t               pDstRect,       //  I: new dst rectangle
    ptmRect_t               pSliceRect      //  I: new slice rectangle
    )

{
    tmErrorCode_t       status = TM_OK;
    ptmdlMbsInstance_t  pMbsInst = (ptmdlMbsInstance_t) instance;
    UInt32              taskIndex = (UInt32) taskHandle - 1;

    Bool                updateRects = False;

    ptmdlMbsTaskDescriptor_t    pTaskDescr;
    ptmdlMbsTaskInfo_t          pTask;

    // make sure we have a valid instance

    DBG_ASSERT2( instance != 0, ("tmdlMbsTaskUpdateRects: Instance = 0") );
    DBG_ASSERT2( pMbsInst->key == MBS_INSTANCE_KEY, 
                 ("tmdlMbsTaskUpdateRects: key 0x%X != 0x%X", pMbsInst->key, MBS_INSTANCE_KEY) );
    DBG_ASSERT2( taskIndex < pMbsInst->totalNrOfTasks, 
                 ("tmdlMbsTaskUpdateRects: Invalid task idx %d >= %d", taskIndex, pMbsInst->totalNrOfTasks) );
    DBG_ASSERT2( pMbsInst->pTaskInfo[taskIndex].empty == False, 
                 ("tmdlMbsTaskUpdateRects: task info empty" ) );

    pTask = &(pMbsInst->pTaskInfo [taskIndex]);

    if ((pTask->taskStatus == tmdlMbsTaskPending)
        ||
        (pTask->taskStatus == tmdlMbsTaskInFifo))
    {
        //  trying to reuse a task which is still in use

        status = TMDL_ERR_MBS_BUSY;
    }
    else
    {
        pTaskDescr = &(pTask->dlTaskDescr);

        if (pSrcRect)
        {
            if (pSrcRect->lr.x - pSrcRect->ul.x !=
                pTaskDescr->inputBuffer.rect.lr.x -
                pTaskDescr->inputBuffer.rect.ul.x)
            {
                pTask->updateFlags |= tmdlMbsUpdateScaling;
            }
            else if (pSrcRect->lr.y - pSrcRect->ul.y !=
                     pTaskDescr->inputBuffer.rect.lr.y -
                     pTaskDescr->inputBuffer.rect.ul.y)
            {
                pTask->updateFlags |= tmdlMbsUpdateScaling;
            }
            pTaskDescr->inputBuffer.rect = *pSrcRect;
            updateRects = True;
        }

        if (pDstRect)
        {
            if (pDstRect->lr.x - pDstRect->ul.x !=
                pTaskDescr->outputBuffer.rect.lr.x -
                pTaskDescr->outputBuffer.rect.ul.x)
            {
                pTask->updateFlags |= tmdlMbsUpdateScaling;
            }
            else if (pDstRect->lr.y - pDstRect->ul.y !=
                     pTaskDescr->outputBuffer.rect.lr.y -
                     pTaskDescr->outputBuffer.rect.ul.y)
            {
                pTask->updateFlags |= tmdlMbsUpdateScaling;
            }
            pTaskDescr->outputBuffer.rect = *pDstRect;
            updateRects = True;
        }

        if (pTaskDescr->taskFlags & tmdlMbsFlagSlicingEn)
        {
            if (pSliceRect)
            {
                pTaskDescr->sliceRect = *pSliceRect;
                updateRects = True;
                if ((pTaskDescr->taskFlags & tmdlMbsFlagMirrorEn) 
                                          &&
                    ( pSliceRect->lr.x != pTaskDescr->outputBuffer.rect.lr.x 
                                           ||
                      pSliceRect->ul.x != pTaskDescr->outputBuffer.rect.ul.x ))
                {
                    // cannot mirror and slice horizontally
                    updateRects = False;
                    status = TMDL_ERR_MBS_BAD_PARAMETER;
                    
                }
            }
        }

        if (updateRects)
        {
            pTask->updateFlags |= tmdlMbsUpdateBuffers;
            status = MbsValidateBufferRects (pMbsInst, pTask);
        }
    }

    return status;

}   //  tmdlMbsTaskUpdateRects


//-----------------------------------------------------------------------------
// FUNCTION:    tmdlMbsTaskUpdateSrcPosition:
//
// DESCRIPTION: Updates the position of the source rectangle