spu_app.cpp

这是DVD中伺服部分的核心代码

    return (SPU_SUCCESS);
}

/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/
SPU_ERR SPUHighlightColorContrastInfo(SPU_HANDLE hSPDecoder, ULONG Colors, BYTE Refresh)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

    if (pSPU == NULL)
    {
        return (SPU_ERR_NULLPTR);
    }

    if (pSPU->ulState == SPU_STATE_UNREALIZED)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("\n!!!!!!! %s:%d - SPU_ERR_INVALID_STATE !!!!!!!!\n\n", __FILE__, __LINE__));
        return (SPU_ERR_INVALID_STATE);
    }

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPUHighlightColorContrastInfo(): ENTER\n"));

    /* take critical section */
    OS_SemTake(pSPU->critical_section, OS_WAIT_FOREVER);

    /* update the highlight info */
    if (Refresh)
    {
        memcpy(pSPU->HLI.HLIColors, pSPU->HLI.HLIBackup, 4 * sizeof(SPU_HLI_COLOR));        
    }
    else
    {
        /* make a backup of the new button color information */
        /* then setup the HLI color information with the same data */
        SPURenderSetHLIColorsDVD(pSPU, Colors, pSPU->HLI.HLIColors);
        memcpy(pSPU->HLI.HLIBackup,  pSPU->HLI.HLIColors, 4 * sizeof (SPU_HLI_COLOR));
    }

    /* give critical section */
    OS_SemGive(pSPU->critical_section);

    return (SPU_SUCCESS);
}

/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/
SPU_ERR SPUHighlightColorContrastInfo8Bit(SPU_HANDLE hSPDecoder, PVOID Colors, BYTE Refresh)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

    if (pSPU == NULL)
    {
        return (SPU_ERR_NULLPTR);
    }

    if (pSPU->ulState == SPU_STATE_UNREALIZED)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("\n!!!!!!! %s:%d - SPU_ERR_INVALID_STATE !!!!!!!!\n\n", __FILE__, __LINE__));
        return (SPU_ERR_INVALID_STATE);
    }

    /* take critical section */
    OS_SemTake(pSPU->critical_section, OS_WAIT_FOREVER);

    /* update the highlight info */
    if (Refresh)
    {
        memcpy(pSPU->HLI.HLIColors, pSPU->HLI.HLIBackup, 256 * sizeof(SPU_HLI_COLOR));
    }
    else
    {
        /* make a backup of the new button color information */
        /* then setup the HLI color information with the same data */
        if (NULL != Colors)
        {
            SPURenderSetHLIColorsHDDVD(pSPU, (BYTE *)Colors, pSPU->HLI.HLIColors);
            memcpy(pSPU->HLI.HLIBackup, pSPU->HLI.HLIColors, 256 * sizeof(SPU_HLI_COLOR));
        }
        else
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("SPUHighlightColorContrastInfo8Bit(): NULL Pointer!\n"));
            OS_SemGive(pSPU->critical_section);
            return (SPU_FAILURE);
        }
    }

    /* give critical section */
    OS_SemGive(pSPU->critical_section);

    return (SPU_SUCCESS);
}

SPU_ERR SPUHighlightAreaInfo(SPU_HANDLE hSPDecoder, USHORT StartX, USHORT EndX, USHORT StartY, USHORT EndY)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPUHighlightAreaInfo: x=%d, y=%d, x2=%d, y2=%d\n", StartX, StartY, EndX, EndY));

    if (pSPU == NULL)
    {
        return (SPU_ERR_NULLPTR);
    }

    if (pSPU->ulState == SPU_STATE_UNREALIZED)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("\n!!!!!!! %s:%d - SPU_ERR_INVALID_STATE !!!!!!!!\n\n", __FILE__, __LINE__));
        return (SPU_ERR_INVALID_STATE);
    }

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPUHighlightAreaInfo(): ENTER\n"));

    if ( (StartX == 0) && (EndX == 0) && (StartY == 0) && (EndY == 0) )
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("\n!!!!!!! %s:%d - SPU_FAILURE !!!!!!!!\n\n", __FILE__, __LINE__));
        return (SPU_FAILURE);
    }

    /* take critical section */
    OS_SemTake(pSPU->critical_section, OS_WAIT_FOREVER);

    /* if invalid coordinates use current */
    if ( (StartX == 0xFFFF) || (EndX == 0xFFFF) || (StartY == 0xFFFF) || (EndY == 0xFFFF) )
    {
        StartX = pSPU->ButtonStartX;
        EndX   = pSPU->ButtonEndX;
        StartY = pSPU->ButtonStartY;
        EndY   = pSPU->ButtonEndY;
    }
    else
    {
        /* need to remember this */
        pSPU->ButtonStartX = StartX;
        pSPU->ButtonEndX   = EndX;
        pSPU->ButtonStartY = StartY;
        pSPU->ButtonEndY   = EndY;
    }

    /* update the highlight info */
    pSPU->HLI.StartX   = StartX;
    pSPU->HLI.EndX     = EndX;
    pSPU->HLI.StartY   = StartY;
    pSPU->HLI.EndY     = EndY;

    /* give critical section */
    OS_SemGive(pSPU->critical_section);

    return (SPU_SUCCESS);
}

SPU_ERR SPUHighlightEnable(SPU_HANDLE hSPDecoder)
{
    SPU_DECODER   *pSPU = (SPU_DECODER *)hSPDecoder;

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPDecoderHighlightEnable() ENTER\n"));

    if (pSPU == NULL)
    {
        return (SPU_ERR_NULLPTR);
    }

    if (pSPU->ulState == SPU_STATE_UNREALIZED)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("\n!!!!!!! %s:%d - SPU_ERR_INVALID_STATE !!!!!!!!\n\n", __FILE__, __LINE__));
        return (SPU_ERR_INVALID_STATE);
    }

    /* take critical section */
    OS_SemTake(pSPU->critical_section, OS_WAIT_FOREVER);

    /* enable highlight */
    pSPU->fHighlightEnabled = TRUE;

    /* refresh the bitmap */
    if (pSPU->fInserted != SP_NOT_INSERTED)
    {
        SPUDecoderProcessData(pSPU, FSTA_DSP);
    }

    /* give critical section */
    OS_SemGive(pSPU->critical_section);

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPDecoderHighlightEnable() EXIT\n"));

    return (SPU_SUCCESS);
}

SPU_ERR SPUHighlightDisable(SPU_HANDLE hSPDecoder)
{
    SPU_DECODER   *pSPU = (SPU_DECODER *)hSPDecoder;

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPDecoderHighlightDisable()\n"));

    if (pSPU == NULL)
    {
        return (SPU_ERR_NULLPTR);
    }

    if (pSPU->ulState == SPU_STATE_UNREALIZED)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("\n!!!!!!! %s:%d - SPU_ERR_INVALID_STATE !!!!!!!!\n\n", __FILE__, __LINE__));
        return (SPU_ERR_INVALID_STATE);
    }

    /* take critical section */
    OS_SemTake(pSPU->critical_section, OS_WAIT_FOREVER);

    /* disable highlight */
    pSPU->fHighlightEnabled = FALSE;

    /* give critical section */
    OS_SemGive(pSPU->critical_section);

    return (SPU_SUCCESS);
}

/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                           PRIVATE FUNCTIONS                             */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/

/**
 *
 */
static ULONG SPDecoderProcessData(PVOID hSPDecoder)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

    /* verify  */
    DbgAssert(pSPU != NULL);

    while (pSPU->fKillThread == FALSE)
    {
        switch (pSPU->ulState)
        {
        case SPU_STATE_RUN:
            /* Get SPU to process
             * SPDecoderGetSPU will wait on the queue until a packet is available */
            if (SPUDecoderGetNextSPU(pSPU) == SPU_SUCCESS)
            {
                /* decode the data from the payload */
                if (SPUDecoderDecodeSPU(pSPU) != SPU_SUCCESS)
                {
                    DbgPrint(("SPDecoderProcessData() - Could not decode SPU\n"));
                }
            }
            break;

        case SPU_STATE_STOPPING:
        case SPU_STATE_FLUSHING:
            DBGPRINT(DBG_ON(DBG_TRACE), ("SPDecoderProcessData: SPU_STATE_STOPPING\n"));

            /* flush decoder stream */
            if (pSPU->pStreamDecode != NULL)
            {
                cSPUStreamMessage *pSPMessage = NULL;

                do
                {
                    pSPMessage = (cSPUStreamMessage*)pSPU->pStreamDecode->Remove();
                    if (pSPMessage != NULL) /* no messages */
                    {
                        /* see if there is a payload */
                        if (pSPMessage->payload != NULL)
                        {
                            /* delete the payload */
                            delete pSPMessage->payload;
                            pSPMessage->payload = NULL;
                        }

                        /* if notification of message done is requested give it now */
                        if (pSPMessage->semMsgDone)
                        {
                            OS_SemGive(pSPMessage->semMsgDone);
                        }

                        /* release the message */
                        pSPU->pStreamDecode->ReleaseMsg(pSPMessage);
                    }
                    else 
                    {
                        OS_TaskDelay(OS_WAIT_1S / 50);
                    }

                } while (pSPMessage != NULL);
            }

            /* take critical section */
            OS_SemTake(pSPU->critical_section, OS_WAIT_FOREVER);

            /* disable highlight */
            pSPU->fHighlightEnabled = FALSE;

            /* give critical section */
            OS_SemGive(pSPU->critical_section);

            /* set next state based on current state */
            if (pSPU->ulState == SPU_STATE_STOPPING)
            {
                pSPU->ulState = SPU_STATE_STOPPED;
            }
            else
            {
                /* Erase any subpics that might be showing */
                spuHide(hSPDecoder, TRUE);

                /* now go back to the run state */
                pSPU->ulState = SPU_STATE_RUN;
            }
            break;

        case SPU_STATE_REALIZED:
        case SPU_STATE_STOPPED:
        default:
            DBGPRINT(DBG_ON(DBG_VERBOSE), ("SPDecoderProcessData: SPU_STATE_STOPPED\n"));
            OS_TaskDelay( OS_GetTicksPerSecond() );
            break;
        }
    }

//err_out:

    /* kill the task */
    OS_TaskExit();

    return (SPU_SUCCESS);
}

static SPU_ERR spuHide(SPU_HANDLE hSPDecoder, BOOLEAN fEraceForcedSP)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

    /* take critical section */
    OS_SemTake(pSPU->critical_section, OS_WAIT_FOREVER);

    pSPU->fShowing = FALSE;

    if (fEraceForcedSP == TRUE)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("spuHide: fEraceForcedSP\n"));

        /* treat this as a permanent erase so that we don't see the forced subpic flash up again later */
        SPUDecoderProcessData(pSPU, STP_DSP);

        /* turn off the highlight on a forced erase */
        pSPU->fHighlightEnabled = FALSE;
    }
    else
    {
        /*
         * Hide subpic if it is showing.  If currently displayed subpic is a forced
         * subpic, only hide it if forced subpics have been disabled.
         */
        if ( (SP_INSERTED_AND_SHOWING == pSPU->fInserted) &&
             ( (FALSE == pSPU->fIsForcedSP) || (pSPU->fDisabled == TRUE) ) )
        {
            DBGPRINT(DBG_ON(DBG_TRACE), ("spuHide: SPURenderErase\n"));
            SPURenderErase(pSPU);
            pSPU->fInserted = SP_INSERTED_NOT_SHOWING;
        }
    }

    /* give critical section */
    OS_SemGive(pSPU->critical_section);

    return (SPU_SUCCESS);
}