psl_external_interface.cpp

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

/*****************************************************************************
******************************************************************************
**                                                                          **
**  Copyright (c) 2002 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 psl_external_interface.cpp
 *
 * $Revision: 1.15 $ 
 *
 * External Interface Module of the PSL.
 * 
 */

#include "vdvd_types.h"
#include "psl_external_interface.h"
#include "psl_interface.h"
#include "psl_general.h"
#include "psl_types.h"
#include "metanav.h"
#include "remote.h"
#include "dbgprint.h"

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

/**
 * Local variables 
 */
static cMetaNav *m_pMetaNav = NULL;   

/**
 * Local functions
 */
static void RemoteCommandCallback(PVOID pvContext, RC_KEY KeyCode, ULONG Repeat);
static void StatusEventCallback(ULONG *pulEvent, PVOID pvParam);
static const char*  PSLEventName ( PSL_USER_INPUT_TYPE pslUserInputType );



/**
 * PSLEventName -- return the name of an event
 *
 * @param
 *    pslUserInputType = event type
 *
 * @retval
 *    null terminated string containing event name
 */
static const char* PSLEventName ( PSL_USER_INPUT_TYPE pslUserInputType )
{
    switch ( pslUserInputType )
    {
        case PSL_USER_INPUT_UP:           return ( "PSL_USER_INPUT_UP" );
        case PSL_USER_INPUT_DOWN:         return ( "PSL_USER_INPUT_DOWN" );
        case PSL_USER_INPUT_LEFT:         return ( "PSL_USER_INPUT_LEFT" );
        case PSL_USER_INPUT_RIGHT:        return ( "PSL_USER_INPUT_RIGHT" );
        case PSL_USER_INPUT_SELECT:       return ( "PSL_USER_INPUT_SELECT" );
        case PSL_USER_INPUT_PAUSE:        return ( "PSL_USER_INPUT_PAUSE" );

        case PSL_USER_INPUT_POWER:        return ( "PSL_USER_INPUT_POWER" );
        case PSL_USER_INPUT_EXIT:         return ( "PSL_USER_INPUT_EXIT" );
        case PSL_USER_INPUT_SUBTITLE:     return ( "PSL_USER_INPUT_SUBTITLE" );
        case PSL_USER_INPUT_MENU:         return ( "PSL_USER_INPUT_MENU" );
        case PSL_USER_INPUT_TITLE:        return ( "PSL_USER_INPUT_TITLE" );
        case PSL_USER_INPUT_PLAY:         return ( "PSL_USER_INPUT_PLAY" );
        case PSL_USER_INPUT_STOP:         return ( "PSL_USER_INPUT_STOP" );
        case PSL_USER_INPUT_EJECT:        return ( "PSL_USER_INPUT_EJECT" );
        case PSL_USER_INPUT_SKIP_FWD:     return ( "PSL_USER_INPUT_SKIP_FWD" );
        case PSL_USER_INPUT_SKIP_BWD:     return ( "PSL_USER_INPUT_SKIP_BWD" );
        case PSL_USER_INPUT_FAST_FWD:     return ( "PSL_USER_INPUT_FAST_FWD" );
        case PSL_USER_INPUT_FAST_RWD:     return ( "PSL_USER_INPUT_FAST_RWD" );
        case PSL_USER_INPUT_SLOW_FWD:     return ( "PSL_USER_INPUT_SLOW_FWD" );
        case PSL_USER_INPUT_STEP_FWD:     return ( "PSL_USER_INPUT_STEP_FWD" );
        case PSL_USER_INPUT_SETUP:        return ( "PSL_USER_INPUT_SETUP" );
        case PSL_USER_INPUT_ANGLE:        return ( "PSL_USER_INPUT_ANGLE" );
        case PSL_USER_INPUT_REPEAT_AB:    return ( "PSL_USER_INPUT_REPEAT_AB" );
        case PSL_USER_INPUT_REPEAT:       return ( "PSL_USER_INPUT_REPEAT" );
        case PSL_USER_INPUT_AUDIO:        return ( "PSL_USER_INPUT_AUDIO" );
        case PSL_USER_INPUT_DISPLAY:      return ( "PSL_USER_INPUT_DISPLAY" );
        case PSL_USER_INPUT_SEARCH:       return ( "PSL_USER_INPUT_SEARCH" );
        case PSL_USER_INPUT_RETURN:       return ( "PSL_USER_INPUT_RETURN" );
        case PSL_USER_INPUT_ZOOM:         return ( "PSL_USER_INPUT_ZOOM" );
        case PSL_USER_INPUT_VOL_UP:       return ( "PSL_USER_INPUT_VOL_UP" );
        case PSL_USER_INPUT_VOL_DOWN:     return ( "PSL_USER_INPUT_VOL_DOWN" );
        case PSL_USER_INPUT_VOL_MUTE:     return ( "PSL_USER_INPUT_VOL_MUTE" );
        case PSL_USER_INPUT_DIGIT:        return ( "PSL_USER_INPUT_DIGIT" );
    }

    return ( "unknown" );
}



/**
 * PslExternalInitialize -- Initialize external modules that are used by the PSL.
 *
 * @param
 *    none.
 *
 * @retval
 *    PSL_SUCCESS if successful
 *    PSL_FAILURE if not successful
 */
PSL_STATUS  PslExternalInitialize(PSL_HANDLE *pPSL)
{ 
    /* Check for valid PSL handle */
    if (pPSL == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalInitialize: NULL handle!\n"));
        return (PSL_NULL_POINTER);
    }
    
    /* Initialize remote control api */
    if (Remote_Initialize() != RC_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalInitialize: Failure initializing remote api!\n"));
        goto errout;
    }

    /* Register callback with remote control api */
    if (Remote_RegisterCallback(RemoteCommandCallback, NULL) != RC_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalInitialize: Failure registering remote callback!\n"));
        goto errout;
    }                           

    /* Create the Metanav */    
    m_pMetaNav = new cMetaNav;
    if (m_pMetaNav == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalInitialize: Failure creating metanav!\n"));
        goto errout;
    }

    /* Initialize metanav */
    if (m_pMetaNav->Initialize(&pPSL->user_config) != METANAV_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalInitialize: Failure initializing metanav!\n"));
        goto errout;
    }

    /* Register for status events from the metanav */
    if (m_pMetaNav->RegisterCallback(StatusEventCallback, NULL) != METANAV_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalInitialize: Failure registering for status events\n"));
        goto errout;
    }
    
    /* Start the media specific nav */
    if (m_pMetaNav->FindMediaFormats(TRUE) != METANAV_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalInitialize: Failure starting media specific nav!\n"));
    }

    return (PSL_SUCCESS);

errout:

    if (m_pMetaNav != NULL)
    {
        /* Remove callback */
        m_pMetaNav->RemoveCallback(StatusEventCallback);

        /* Delete the metanav */
        delete m_pMetaNav;
    }

    if (Remote_IsInitialized() == TRUE)
    {
        /* Remove callback from remote api */
        Remote_RemoveCallback(RemoteCommandCallback);

        /* Uninitialize the remote api */
        Remote_Uninitialize();
    }

    return (PSL_FAILURE);
}

/**
 * PslExternalInitialize -- Uninitialize external modules that are used by the PSL.
 *
 * @param
 *    none.
 *
 * @retval
 *    PSL_SUCCESS if successful
 *    PSL_FAILURE if not successful
 */
PSL_STATUS  PslExternalUninitialize(void)
{
    if (m_pMetaNav != NULL)
    {
        /* Remove callback */
        m_pMetaNav->RemoveCallback(StatusEventCallback);

        /* Delete the metanav */
        delete m_pMetaNav;
    }

    if (Remote_IsInitialized() == TRUE)
    {
        /* Remove callback from remote api */
        Remote_RemoveCallback(RemoteCommandCallback);

        /* Uninitialize the remote api */
        Remote_Uninitialize();
    }

    return (PSL_SUCCESS);
}

/**
 * PslExternalSendNavCommand -- Send user input to the nav for processing
 *
 * @param
 *      tUserCmd    -- User command to send to the nav
 *      ulInfo      -- Info param with the user command
 *
 * @retval
 *    PSL_SUCCESS if successful
 *    PSL_FAILURE if not successful
 */
PSL_STATUS  PslExternalSendNavCommand(PSL_USER_CMD tUserCmd, ULONG ulInfo)
{
    VDVD_COMMAND    command;
    BOOLEAN         fValidCmd   = TRUE;

    /* Check that metanav is created */
    if (m_pMetaNav == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalSendNavCommand: Metanav not created!\n"));
        return (PSL_FAILURE);
    }

    /* Map PSL user input to a VDVD command type */
    switch (tUserCmd) 
    {
    case PSL_USER_CMD_POWER:
        command = VDVD_COMMAND_STANDBY;
        break;
    case PSL_USER_CMD_PLAY:
        command = VDVD_COMMAND_PLAY;
        break;
    case PSL_USER_CMD_STOP:
        command = VDVD_COMMAND_STOP;
        break;
    case PSL_USER_CMD_PAUSE_ON:
        command = VDVD_COMMAND_PAUSE_ON;
        break;
    case PSL_USER_CMD_PAUSE_OFF:
        command = VDVD_COMMAND_PAUSE_OFF;
        break;
    case PSL_USER_CMD_EJECT:
        command = VDVD_COMMAND_EJECT;
        break;
    case PSL_USER_CMD_DIGIT:
        command = VDVD_COMMAND_NUMBER;
        break;
    case PSL_USER_CMD_UP:
        command = VDVD_COMMAND_UP;
        break;
    case PSL_USER_CMD_DOWN:
        command = VDVD_COMMAND_DOWN;
        break;
    case PSL_USER_CMD_LEFT:
        command = VDVD_COMMAND_LEFT;
        break;
    case PSL_USER_CMD_RIGHT:
        command = VDVD_COMMAND_RIGHT;
        break;
    case PSL_USER_CMD_SELECT:
        command = VDVD_COMMAND_ENTER;
        break;
    case PSL_USER_CMD_SKIP_NEXT:
        command = VDVD_COMMAND_NEXT_CHAPTER;
        break;
    case PSL_USER_CMD_SKIP_PREV:
        command = VDVD_COMMAND_PREV_CHAPTER;
        break;
    case PSL_USER_CMD_FWD_PLAY:
        command = VDVD_COMMAND_FWD_PLAY;
        break;
    case PSL_USER_CMD_BWD_PLAY:
        command = VDVD_COMMAND_BWD_PLAY;
        break;
    case PSL_USER_CMD_STEP_FWD:
        command = VDVD_COMMAND_STEP_FWD;
        break;
    case PSL_USER_CMD_VOL_UP:
        command = VDVD_COMMAND_VOL_UP;
        break;
    case PSL_USER_CMD_VOL_DOWN:
        command = VDVD_COMMAND_VOL_DOWN;
        break;
    case PSL_USER_CMD_VOL_MUTE:
        command = VDVD_COMMAND_VOL_MUTE;
        break;
    case PSL_USER_CMD_REPEAT:
        command = VDVD_COMMAND_REPEAT;
        break;
    case PSL_USER_CMD_ANGLE:
        command = VDVD_COMMAND_ANGLE;
        break;
    case PSL_USER_CMD_MENU:
        command = VDVD_COMMAND_MENU;
        break;
    case PSL_USER_CMD_TITLE:
        command = VDVD_COMMAND_TITLE;
        break;
    case PSL_USER_CMD_AUDIO:
        command = VDVD_COMMAND_AUDIO_SELECT;
        break;
    case PSL_USER_CMD_CHAPTER_SEARCH:
        command = VDVD_COMMAND_GOTO_CHAPTER;
        break;
    case PSL_USER_CMD_TITLE_SEARCH:
        command = VDVD_COMMAND_GOTO_TITLE;
        break;
    case PSL_USER_CMD_TIME_SEARCH:
        command = VDVD_COMMAND_GOTO_TIME;
        break;
    case PSL_USER_CMD_SUBTITLE:
        command = VDVD_COMMAND_SUBTITLE_ON_OFF;
        break;
    case PSL_USER_CMD_PARENTAL_PLAY:
        command = VDVD_COMMAND_PARENTAL_PLAY;
        break;
    case PSL_USER_CMD_STILL_OFF:
        command = VDVD_COMMAND_STILL_OFF;
        break;
    default:
        DBGPRINT(DBG_ON(DBG_TRACE), ("PslExternalSendNavCommand: Unsupported command type\n"));
        fValidCmd = FALSE;
        break;
    }

    /* Send command to the metanav to be processed */
    if (fValidCmd == TRUE)
    {
        if (m_pMetaNav->CommandHandler(command, ulInfo) != METANAV_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalSendNavCommand: Failure sending command!\n"));
            return (PSL_FAILURE);
        }
    }

    return (PSL_SUCCESS);
}

/**
 * PslExternalGetNavStatus -- Get the current state of the navigator
 *
 * @param
 *      none.
 *
 * @retval
 *    PSL_STATUS_TYPE
 */
ULONG  PslExternalGetNavStatus(void)
{
    ULONG           ulNavState;
    PSL_STATUS_TYPE tState  = PSL_STATUS_UNKNOWN;

    /* Check that metanav is created */
    if (m_pMetaNav == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalGetNavStatus: Metanav not created!\n"));
        return (tState);
    }

    /* Query the metanav for the current navigator state */
    ulNavState = m_pMetaNav->GetNavState();

    /* Map VDVD status type to a PSL status type */
    switch (ulNavState)
    {
    case VDVD_STATUS_STANDBY_ON:
        tState = PSL_STATUS_STANDBY;
        break;
    case VDVD_STATUS_OPEN:
        tState = PSL_STATUS_OPEN;
        break;
    case VDVD_STATUS_NO_DISC:
        tState = PSL_STATUS_NO_DISC;
        break;
    case VDVD_STATUS_STOP:
        tState = PSL_STATUS_STOP;
        break;
    case VDVD_STATUS_FULLSTOP:
        tState = PSL_STATUS_FULLSTOP;
        break;
    case VDVD_STATUS_PLAY:
        tState = PSL_STATUS_PLAY;
        break;
    case VDVD_STATUS_SLOW_F:
        tState = PSL_STATUS_SLOW_FWD;
        break;
    case VDVD_STATUS_FAST_F:
        tState = PSL_STATUS_FAST_FWD;
        break;
    case VDVD_STATUS_PAUSE:
        tState = PSL_STATUS_PAUSE;
        break;
    case VDVD_STATUS_FAST_B:
        tState = PSL_STATUS_FAST_RWD;
        break;
    case VDVD_STATUS_STILL:
        tState = PSL_STATUS_STILL;
        break;
    case VDVD_STATUS_UNKNOWN:
        tState = PSL_STATUS_UNKNOWN;
    default:
        break;
    }
    
    return ( (ULONG)tState);
}