spu_app.cpp

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

    }

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

    /* verify state */
    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);
    }

    /* Wake up */
    pSPU->ulState = SPU_STATE_RUN;

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPUStart: EXIT\n"));

    return (SPU_SUCCESS);
}

/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/
SPU_ERR SPUStop(SPU_HANDLE hSPDecoder)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

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

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

    if (pSPU->ulState > SPU_STATE_STOPPING)
    {
        cSPUStreamMessage *pSPMessage = NULL;

        /* tell decoder to stop */
        pSPU->ulState = SPU_STATE_STOPPING;

        /* If the decode task is blocked waiting on a message this will release it. */
        pSPMessage = (cSPUStreamMessage*)pSPU->pStreamDecode->GetMsg(OS_NO_WAIT);
        if (pSPMessage != NULL)
        {
            pSPMessage->payload = NULL;
            pSPU->pStreamDecode->Write((PVOID)pSPMessage);
        }
    }

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPUStop: EXIT\n"));

    return (SPU_SUCCESS);
}


/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/
SPU_ERR SPUFlush(SPU_HANDLE hSPDecoder)
{
    SPU_DECODER            *pSPU       = (SPU_DECODER *)hSPDecoder;
    cSPUStreamMessage      *pSPMessage = NULL;

    /* release any packets queued in either stream */
    if (pSPU == NULL)
    {
        DbgPrint(("SPUFlush: Invalid decoder handle\n"));
        return( SPU_ERR_NULLPTR );
    }

    if ( (pSPU->ulState == SPU_STATE_UNREALIZED) || (pSPU->ulState == SPU_STATE_REALIZING) )
    {
        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), ("SPUFlush: ENTER, state = %d\n", pSPU->ulState));

    /* flush decoder stream */
    if (pSPU->ulState == SPU_STATE_RUN)
    {
        pSPU->ulState = SPU_STATE_FLUSHING;

        /* release wait states */
        pSPMessage = (cSPUStreamMessage*)pSPU->pStreamDecode->GetMsg(OS_NO_WAIT);
        if (pSPMessage != NULL)
        {
            pSPMessage->payload = NULL;
            pSPU->pStreamDecode->Write((PVOID)pSPMessage);
        }
    }
    else
    {
        /* if we're not in the run state we don't need to flush the stream queue
         * just flush the hardware and don't change the state */

        /* Erase any subpics that might be showing */
        spuHide(hSPDecoder, TRUE);

        /* Invalidate the color contrast info */
        SPURenderSetPixelControlData(pSPU, NULL, 0);
    }

    return (SPU_SUCCESS);
}

/**
 * Get Status.  Get the sub-picture status.  This include the status of the
 *              sub-pic decoder and the status of the sub-pic render.
 *
 * @param  hSPRender -- handle to subpic render
 *         pulStatus -- pointer to the bit-mask of the sub-picture status
 *
 * @return
 *     SPU_ERR_NULLPTR if handle is null
 *     SPU_SUCCESS     on success
 */
SPU_ERR SPUGetStatus(SPU_HANDLE hSPDecoder, ULONG *pulStatus)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

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

    /*
     * Fill in the sub-pic decoder status info
     */
    *pulStatus = pSPU->ulState & SPU_STATE_MASK;

    /*
     * Check if hilight is enabled
     */
    if (pSPU->fHighlightEnabled == TRUE)
    {
        *pulStatus |= SPU_DISPLAY_HILIGHT_ENABLED;
    }

    /*
     * Are sub-pictures being displayed?
     */
    if (pSPU->fShowing)
    {
        *pulStatus |= SPU_DISPLAY_ON;
    }

    /*
     * Are forced sub-pics disabled?
     */
    if (pSPU->fDisabled)
    {
        *pulStatus |= SPU_DISPLAY_FORCE_DISABLED;
    }

    /*
     * Is there valid subpicture data?
     */
    if (pSPU->fInserted != SP_NOT_INSERTED)
    {
        *pulStatus |= SPU_DISPLAY_DATA_VALID;
    }

    return (SPU_SUCCESS);
}


/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/
SPU_ERR SPUShow( SPU_HANDLE hSPDecoder )
{
    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), ("SPUShow(): ENTER\n"));

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

    pSPU->fShowing = TRUE;

    /* if we should be showing a subpic draw it */
    if (pSPU->fInserted == SP_INSERTED_NOT_SHOWING)
    {
        SPUDecoderProcessData(pSPU, STA_DSP);
    }

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

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPUShow(): EXIT\n"));

    return (SPU_SUCCESS);
}

/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/
SPU_ERR SPUHide(SPU_HANDLE hSPDecoder)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

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

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

    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);
    }

    return ( spuHide(hSPDecoder, FALSE) );
}

/**
 * Enable force display.  When disabled, forced sub-pics will not be displayed.
 *
 * @param  hSPRender -- handle to subpic render
 *
 * @return
 *     SPU_ERR_NULLPTR if handle is null
 *     SPU_SUCCESS     on success
 */
SPU_ERR SPUEnableForced(SPU_HANDLE hSPDecoder)
{
    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), ("SPUEnableForced(): ENTER\n"));

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

    pSPU->fDisabled = FALSE;

    /* if we should be showing a subpic draw it */
    if ( (SP_INSERTED_NOT_SHOWING == pSPU->fInserted) && (TRUE == pSPU->fIsForcedSP) )
    {
        SPUDecoderProcessData(pSPU, STA_DSP);
    }

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

    DBGPRINT(DBG_ON(DBG_TRACE), ("SPUEnableForced(): EXIT\n"));

    return (SPU_SUCCESS);
}

/**
 * Disable force display.  When disabled, forced sub-pics will not be displayed.
 *
 * @param  hSPRender -- handle to subpic render
 *
 * @return
 *     SPU_ERR_NULLPTR if handle is null
 *     SPU_SUCCESS     on success
 */
SPU_ERR SPUDisableForced(SPU_HANDLE hSPDecoder)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

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

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

    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);

    pSPU->fDisabled = TRUE;

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

    return (SPU_SUCCESS);
}

/***************************************************************************/
/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*                                                                         */
/***************************************************************************/
/***************************************************************************/
SPU_ERR SPUSetPalette(SPU_HANDLE hSPDecoder, UCHAR *palette, ULONG Size)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;
    SPU_ERR err;

    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);

    /* length of palette in bytes is passed in when setting the palette */
    err = SPURenderSetPalette(pSPU, palette, Size);

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

    return (err);
}

SPU_ERR SPUSetDCSQTimeout(SPU_HANDLE hSPDecoder, ULONG ulTimeout)
{
    SPU_DECODER *pSPU = (SPU_DECODER *)hSPDecoder;

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

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

    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);
    }

    pSPU->dcsq_timeout = ulTimeout;