pbc_register.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_register.cpp
 *
 * API to the Playback Control Engine player registers.
 * This API is intended to be private and used by other Playback
 * Control Engine modules only.
 *
 * $Id: pbc_register.cpp,v 1.18 2006/10/25 23:50:09 rbehe Exp $
 */

#include "vdvd_types.h"
#include "pbc_register.h"
#include "playctrl.h"
#include "pbc_types.h"
#include "dbgprint.h"

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


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

/**
 * Local variables
 */
static ULONG PSR[PSR_TOTAL_NUMBER];
static ULONG GPR[GPR_TOTAL_NUMBER];

/**
 * PbcRegInitialize -- Set "Playback Status Registers" to their initial values,
 *                     as defined in the BD-ROM spec.
 *
 * @param
 *      none
 *
 * @retval
 *      none
 */
void  PbcRegInitialize(void)
{
    PSR[PLAYCTRL_PSR_IG_STN]          = PSR_IG_STN_DEFAULT;
    PSR[PLAYCTRL_PSR_AUDIO_STN]       = PSR_AUDIO_STN_DEFAULT;
    PSR[PLAYCTRL_PSR_PG_AND_ST_STN]   = PSR_PG_AND_ST_STN_DEFAULT;
    PSR[PLAYCTRL_PSR_ANGLE]           = PSR_ANGLE_DEFAULT;
    PSR[PLAYCTRL_PSR_TITLE]           = PSR_TITLE_DEFAULT;
    PSR[PLAYCTRL_PSR_CHAPTER]         = PSR_CHAPTER_DEFAULT;
    PSR[PLAYCTRL_PSR_PLAYLIST]        = PSR_PLAYLIST_DEFAULT;
    PSR[PLAYCTRL_PSR_PLAYITEM]        = PSR_PLAYITEM_DEFAULT;
    PSR[PLAYCTRL_PSR_PRES_TIME]       = PSR_PRES_TIME_DEFAULT;
    PSR[PLAYCTRL_PSR_NVTIMER]         = PSR_NVTIMER_DEFAULT;
    PSR[PLAYCTRL_PSR_SEL_BUTTON]      = PSR_SEL_BUTTON_DEFAULT;
    PSR[PLAYCTRL_PSR_MENU_PAGE]       = PSR_MENU_PAGE_DEFAULT;
    PSR[PLAYCTRL_PSR_SEL_STYLE]       = PSR_SEL_STYLE_DEFAULT;
    PSR[PLAYCTRL_PSR_SEC_AUD_VID_STN] = PSR_SEC_AUD_VID_STN_DEFAULT;
#ifdef DRM_BDPLUS_SUPPORT
    PSR[PLAYCTRL_PSR_APP_LAYER_0] = PSR_APP_LAYER_0_DEFAULT;
    PSR[PLAYCTRL_PSR_APP_LAYER_1] = PSR_APP_LAYER_1_DEFAULT;
    PSR[PLAYCTRL_PSR_APP_LAYER_2] = PSR_APP_LAYER_2_DEFAULT;
#endif

    PbcRegResetBackup();
}

/**
 * PbcRegSetPSR -- Set player status register
 *
 * @param
 *      register_number -- PSR register number
 *      value -- value to set PSR to
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegSetPSR(uint32 register_number, uint32 uiValue)
{
    /* Check that register number is valid */
    if (register_number >= PSR_TOTAL_NUMBER)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegSetPSR: invalid register number!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* set register value */
    PSR[register_number] = uiValue;

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcRegGetPSR -- Get player status register value
 *
 * @param
 *      register_number -- PSR register number
 *      pValue -- pointer to variable that gets set to PSR's value
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegGetPSR(uint32 register_number, uint32 *puiValue)
{
    /* Check that register number is valid */
    if (register_number >= PSR_TOTAL_NUMBER)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegGetPSR: invalid register number!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* Check for valid pointer */
    if (puiValue == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegGetPSR: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    /* get register value */
    *puiValue = PSR[register_number];

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcRegSetGPR -- Set general purpose register
 *
 * @param
 *      register_number -- GPR register number
 *      value -- value to set GPR to
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegSetGPR(uint32 register_number, uint32 uiValue)
{
    /* Check that register number is valid */
    if (register_number >= GPR_TOTAL_NUMBER)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegSetGPR: invalid register number!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* set register value */
    GPR[register_number] = uiValue;

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcRegGetGPR -- Get general purpose register value
 *
 * @param
 *      register_number -- GPR register number
 *      pValue -- pointer to variable that gets set to GPR's value
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegGetGPR(uint32 register_number, uint32 *puiValue)
{
    /* Check that register number is valid */
    if (register_number >= GPR_TOTAL_NUMBER)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegGetGPR: invalid register number!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* Check for valid pointer */
    if (puiValue == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegGetGPR: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    /* get register value */
    *puiValue = GPR[register_number];

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcRegStoreBackup -- Store the current PSR's values into "Backup Registers".
 *
 * @param
 *      none
 *
 * @retval
 *      none
 */
void  PbcRegStoreBackup(void)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("PbcRegStoreBackup: ENTER\n"));

    PSR[36] = PSR[PLAYCTRL_PSR_TITLE];
    PSR[37] = PSR[PLAYCTRL_PSR_CHAPTER];
    PSR[38] = PSR[PLAYCTRL_PSR_PLAYLIST];
    PSR[39] = PSR[PLAYCTRL_PSR_PLAYITEM];
    PSR[40] = PSR[PLAYCTRL_PSR_PRES_TIME];
    PSR[42] = PSR[PLAYCTRL_PSR_SEL_BUTTON];
    PSR[43] = PSR[PLAYCTRL_PSR_MENU_PAGE];
    PSR[44] = PSR[PLAYCTRL_PSR_SEL_STYLE];
}

/**
 * PbcRegLoadBackup -- Load the current PSR's values from the "Backup Registers".
 *
 * @param
 *      none
 *
 * @retval
 *      none
 */
void  PbcRegLoadBackup(void)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("PbcRegLoadBackup: ENTER\n"));

    /* load backup registers */
    PSR[PLAYCTRL_PSR_TITLE]      = PSR[36];
    PSR[PLAYCTRL_PSR_CHAPTER]    = PSR[37];
    PSR[PLAYCTRL_PSR_PLAYLIST]   = PSR[38];
    PSR[PLAYCTRL_PSR_PLAYITEM]   = PSR[39];
    PSR[PLAYCTRL_PSR_PRES_TIME]  = PSR[40];
    PSR[PLAYCTRL_PSR_SEL_BUTTON] = PSR[42];
    PSR[PLAYCTRL_PSR_MENU_PAGE]  = PSR[43];
    PSR[PLAYCTRL_PSR_SEL_STYLE]  = PSR[44];

    /* intialize backup registers */
    PbcRegResetBackup();
}

/**
 * PbcRegResetBackup -- Reset the backup registers to their initial values.
 *
 * @param
 *      none
 *
 * @retval
 *      none
 */
void  PbcRegResetBackup(void)
{
    PSR[36] = PSR_TITLE_DEFAULT;
    PSR[37] = PSR_CHAPTER_DEFAULT;
    PSR[38] = PSR_PLAYLIST_DEFAULT;
    PSR[39] = PSR_PLAYITEM_DEFAULT;
    PSR[40] = PSR_PRES_TIME_DEFAULT;
    PSR[42] = PSR_SEL_BUTTON_DEFAULT;
    PSR[43] = PSR_MENU_PAGE_DEFAULT;
    PSR[44] = PSR_SEL_STYLE_DEFAULT;
}

/**
 * PbcRegCopyGPR -- Copy all GPR register values into a buffer.
 *
 * @param
 *      pBuffer - buffer to copy values into
 *      size - size of buffer
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegCopyGPR(uint32 *pBuffer, uint32 size)
{
    if (pBuffer == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegCopyGPR: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    if (size < (sizeof(uint32) * GPR_TOTAL_NUMBER) )
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegCopyGPR: invalid buffer size!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* copy all GPR's into buffer */
    memcpy(pBuffer, GPR, (sizeof(uint32) * GPR_TOTAL_NUMBER));

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcRegCopyPSR -- Copy all PSR register values into a buffer.
 *
 * @param
 *      pBuffer - buffer to copy values into
 *      size - size of buffer
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegCopyPSR(uint32 *pBuffer, uint32 size)
{
    if (pBuffer == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegCopyPSR: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    if (size < (sizeof(uint32) * PSR_TOTAL_NUMBER) )
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegCopyPSR: invalid buffer size!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* copy all PSR's into buffer */
    memcpy(pBuffer, PSR, (sizeof(uint32) * PSR_TOTAL_NUMBER));

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcRegLoadGPR -- Load all register values from a buffer into the GPR's.
 *
 * @param
 *      pBuffer - buffer to copy values from
 *      size - size of buffer
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegLoadGPR(uint32 *pBuffer, uint32 size)
{
    if (pBuffer == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegLoadGPR: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    if (size < (sizeof(uint32) * GPR_TOTAL_NUMBER) )
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegLoadGPR: invalid buffer size!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* load all values from buffer into GPR's */
    memcpy(GPR, pBuffer, (sizeof(uint32) * GPR_TOTAL_NUMBER));

    return (PLAYCTRL_SUCCESS);
}

/**
 * PbcRegLoadPSR -- Load all register values from a buffer into the PSR's.
 *
 * @param
 *      pBuffer - buffer to copy values from
 *      size - size of buffer
 *
 * @retval
 *      PLAYCTRL_STATUS
 */
PLAYCTRL_STATUS PbcRegLoadPSR(uint32 *pBuffer, uint32 size)
{
    if (pBuffer == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegLoadPSR: NULL pointer!\n"));
        return (PLAYCTRL_NULL_POINTER);
    }

    if (size < (sizeof(uint32) * PSR_TOTAL_NUMBER) )
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PbcRegLoadPSR: invalid buffer size!\n"));
        return (PLAYCTRL_FAILURE);
    }

    /* load all values from buffer into PSR's */
    memcpy(PSR, pBuffer, (sizeof(uint32) * PSR_TOTAL_NUMBER));

    return (PLAYCTRL_SUCCESS);
}