pbc_avpres.cpp

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

/*****************************************************************************
******************************************************************************
**                                                                          **
**  Copyright (c) 2005-2006 Videon Central, Inc.                            **
**  All rights reserved.                                                    **
**                                                                          **
**  The computer program contained herein contains proprietary information  **
**  which is the property of Videon Central, Inc.  The program may be used  **
**  and/or copied only with the written permission of Videon Central, Inc.  **
**  or in accordance with the terms and conditions stipulated in the        **
**  agreement/contract under which the programs have been supplied.         **
**                                                                          **
******************************************************************************
*****************************************************************************/
/**
 * @file pbc_avpres.cpp
 *
 * AV presentation module of the playback control engine.
 * This API is intended to be private and used by other Playback
 * Control Engine modules only.
 *
 * $Id: pbc_avpres.cpp,v 1.95 2007/01/26 22:33:19 rbehe Exp $
 */

#include "vdvd_types.h"
#include "pbc_avpres.h"
#include "playctrl.h"
#include "pbc_types.h"
#include "pbc_register.h"
#include "pbc_stnselect.h"
#include "../mvplaylistdb.h"
#include "dbgprint.h"
#include "pbc_engine.h"
#include "pbc_plcontrol.h"

#ifdef DMALLOC
#include "dmalloc.h"
#endif


/* Debug macros */
#define DBG_PBCAVPRES   DBG_ERROR
#define DBG_ON(x)       (DBG_PBCAVPRES >= x)



/* local functions */
static PLAYCTRL_STATUS pbcAvPresPlay(PBC_HANDLE *hPBC, BOOLEAN fReverse, ULONG ulNewSpeed);


/**
 * PbcAvPresPauseOn -- Suspend playback and keep suspended playback displayed.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      data1 -- not used
 *      data2 -- not used
 *      data3 -- not used
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcAvPresPauseOn(PBC_HANDLE *hPBC, ULONG data1, ULONG data2, ULONG data3)
{
    PLAYCTRL_STATUS status = PLAYCTRL_SUCCESS;

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

    if (hPBC->tState == PLAYCTRL_STATE_STOP)
    {
        status = PLAYCTRL_FAILURE;
        goto errout;
    }

    if (hPBC->ulPlayRate != 1000)
    {
        if (PbcAvPresForwardPlay(hPBC, 0, 0, 0) != PLAYCTRL_SUCCESS)
        {
            status = PLAYCTRL_FAILURE;
            goto errout;
        }
    }
    else
    {
        /* Pause the PE */
        if (PEiStreamCtrlPause(hPBC->hPE) != PE_SUCCESS)
        {
            status = PLAYCTRL_FAILURE;
            goto errout;
        }
    }

    /* Enter the pause state */
    hPBC->tState = PLAYCTRL_STATE_PAUSE;

errout:
    return (status);
}

/**
 * PbcAvPresPauseOff -- Release suspended playback.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      data1 -- not used
 *      data2 -- not used
 *      data3 -- not used
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcAvPresPauseOff(PBC_HANDLE *hPBC, ULONG data1, ULONG data2, ULONG data3)
{
    PLAYCTRL_STATUS status;

    DBGPRINT(DBG_ON(DBG_TRACE), ("PbcAvPresPauseOff()\n"));
    if (hPBC->tState != PLAYCTRL_STATE_PAUSE)
    {
        status = PLAYCTRL_FAILURE;
        goto errout;
    }

    /* Unpause the PE */
    if (PEiStreamCtrlResume(hPBC->hPE) != PE_SUCCESS)
    {
        status = PLAYCTRL_FAILURE;
    }
    else
    {
        /* Enter the play state */
        hPBC->tState = PLAYCTRL_STATE_PLAY;
        hPBC->ulPlayRate = 1000;
        hPBC->fReverse   = 0;
        status = PLAYCTRL_SUCCESS;
    }

errout:
    return (status);
}


/**
 * PbcAvPresStep -- Step forward one frame.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      data1 -- not used
 *      data2 -- not used
 *      data3 -- not used
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcAvPresStep(PBC_HANDLE *hPBC, ULONG data1, ULONG data2, ULONG data3)
{
    PLAYCTRL_STATUS status = PLAYCTRL_SUCCESS;

    DBGPRINT(DBG_ON(DBG_TRACE), ("PbcAvPresStep()\n"));
    if (hPBC->tState == PLAYCTRL_STATE_STOP)
    {
        status = PLAYCTRL_FAILURE;
        goto errout;
    }

    /* if not paused, just pause */
    if (hPBC->tState != PLAYCTRL_STATE_PAUSE)
    {
        if (PbcAvPresPauseOn(hPBC, 0, 0, 0) != PLAYCTRL_SUCCESS)
        {
            status = PLAYCTRL_FAILURE;
            goto errout;
        }
    }
    else  /* if paused, then step */
    {
        if (PEiStreamCtrlStep(hPBC->hPE) != PE_SUCCESS)
        {
            status = PLAYCTRL_FAILURE;
            goto errout;
        }
    }

    /* Enter the pause state */
    hPBC->tState = PLAYCTRL_STATE_PAUSE;

errout:
    return (status);
}




/**
 * PbcAvPresStillOn -- Freeze playback of presentation.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      data1 -- not used
 *      data2 -- not used
 *      data3 -- not used
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcAvPresStillOn(PBC_HANDLE *hPBC, ULONG data1, ULONG data2, ULONG data3)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("PbcAvPresStillOn: ENTER\n"));

    if (hPBC == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcAvPresStillOn: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    /* Tell PE to still */
    if (PEiStreamCtrlStillOn(hPBC->hPE) != PE_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcAvPresStillOn: PE failed to still\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* Set still state to infinite still */
    hPBC->ulStillTime = 0xffffffff;

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcAvPresStillOff -- Release frozen playback.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      data1 -- not used
 *      data2 -- not used
 *      data3 -- not used
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcAvPresStillOff(PBC_HANDLE *hPBC, ULONG data1, ULONG data2, ULONG data3)
{
    BOOLEAN fAllPrefillComplete = TRUE;

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

    if (hPBC == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcAvPresStillOff: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    /* Set still time to 0 to indicate still off */
    hPBC->ulStillTime = 0;

    /* Check if playlist is complete after this still */
    if (hPBC->fPLCompletePending == TRUE)
    {
        /* playlist complete */
        PbcPLCtrlPlaylistComplete(hPBC, FALSE);
    }
    else
    {
        /* Check for any PE input pins waiting for prefill */
        for (int i = 0; i < MAX_PE_INPUTS; i++)
        {
            if (hPBC->fWaitingPrefill[i] == TRUE)
            {
                fAllPrefillComplete = FALSE;
                break;
            }
        }

        /* If all PE input pins are done waiting for prefill, then start decode */
        if (fAllPrefillComplete == TRUE)
        {
            if (PEiStreamCtrlStillOff(hPBC->hPE) != PE_SUCCESS)
            {
                DBGPRINT(DBG_ON(DBG_ERROR), ("PbcAvPresStillOff: PEiStreamCtrlStillOff() FAILED!\n"));
                return (PLAYCTRL_FAILURE);
            }
        }
    }

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcAvPresForwardPlay -- Change playback to specified speed in forward direction.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      data1 -- playback speed
 *      data2 -- not used
 *      data3 -- not used
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcAvPresForwardPlay(PBC_HANDLE *hPBC, ULONG data1, ULONG data2, ULONG data3)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("%s: speed = %d\n", __FUNCTION__, data1));

    return (pbcAvPresPlay(hPBC, 0, (ULONG)data1));
}

/**
 * PbcAvPresBackwardPlay -- Change playback to specified speed in backward direction.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      data1 -- playback speed
 *      data2 -- not used
 *      data3 -- not used
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcAvPresBackwardPlay(PBC_HANDLE *hPBC, ULONG data1, ULONG data2, ULONG data3)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("%s: speed = %d\n", __FUNCTION__, data1));

    return (pbcAvPresPlay(hPBC, 1, (ULONG)data1));
}

/**
 * pbcAvPresPlay -- Change playback to specified speed in specified direction.
 *
 * @param
 *      hPBC -- handle to playback control engine private data
 *      fDirection -- direction
 *      ulSpeed -- speed
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS pbcAvPresPlay(PBC_HANDLE *hPBC, BOOLEAN fReverse, ULONG ulNewSpeed)
{
    PLAYCTRL_STATUS         status              = PLAYCTRL_SUCCESS;
    uint32                  uiPlaylistID;
    PLAYITEM                *pPlayItem          = NULL;
    PBC_PLAYITEM_CONTEXT    *pPIContext         = NULL;

    DBGPRINT(DBG_ON(DBG_TRACE), ("pbcAvPresPlay: speed = %d\n", ulNewSpeed));