psl_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_interface.cpp
 *
 * $Revision: 1.11 $ 
 *
 * Public API to the project specific layer (PSL).
 * 
 */

#include <string.h>
#include "vdvd_types.h"
#include "psl_interface.h"
#include "psl_general.h"
#include "psl_types.h"
#include "psl_process_user_input.h"
#include "psl_process_status.h"
#include "psl_external_interface.h"
#include "psl_data_bank.h"
#include "psl_screen_layout.h"
#include "osapi.h"
#include "dbgprint.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif

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

/* Local constants */
#define PSL_MSG_QUEUE_DEPTH   5

/**
 * Possible message types that may be sent to the PSL thread.
 */
typedef enum tagPSL_MSG_TYPE
{
    PSL_MSG_INITIALIZE = 0,
    PSL_MSG_PROCESS_USER_INPUT,
    PSL_MSG_PROCESS_STATUS,
    PSL_MSG_ABORT,
    
    /* All new message types above this line */
    PSL_MSG_TYPE_MAX_COUNT
} PSL_MSG_TYPE;

/**
 * Message that is sent to the PSL thread
 */
typedef struct tagPSL_MESSAGE
{
    PSL_MSG_TYPE    tMsgType;
    PVOID           pvBuffer;
    ULONG           ulBufferLength;
    ULONG           ulData0;
    ULONG           ulData1;
    ULONG           ulData2;
    ULONG           ulSemID;
    ULONG           ulRetVal;
} PSL_MESSAGE;

/**
 * Local handle definition 
 */
typedef struct tagPSL_DATA
{
    PSL_HANDLE              *pPsl;
    BOOLEAN                 fInit;
    OS_MSG_Q_ID             msg_queue;
    ULONG                   ulTaskId;
    OS_SEM_ID               cmd_processing_sem;
    PSL_USER_INPUT_FUNC     ProcessUserInput[PSL_USER_INPUT_MAX];
    PSL_STATUS_FUNC         ProcessStatus[PSL_STATUS_MAX];
} PSL_DATA;

/**
 * Local variables 
 */
static PSL_DATA     *m_hPsl = NULL;

/**
 * Local functions
 */
static void         InitUserInputCommands(void);
static void         InitStatusEvents(void);
static ULONG        PslTask(PVOID pvParam);
static const char*  PslStatusName( PSL_STATUS_TYPE status );


/**
 * PslStatusName -- Return status as string
 *
 * @param
 *    status
 *
 * @retval
 *    status as a string
 */
const char*  PslStatusName( PSL_STATUS_TYPE status )
{
    switch ( status )
    {
        case PSL_STATUS_PROHIBITED:             return("PSL_STATUS_PROHIBITED");   break;
        case PSL_STATUS_PAUSE:                  return("PSL_STATUS_PAUSE");   break;
        case PSL_STATUS_PLAY:                   return("PSL_STATUS_PLAY");   break;
        case PSL_STATUS_STOP:                   return("PSL_STATUS_STOP");   break;
        case PSL_STATUS_FULLSTOP:               return("PSL_STATUS_FULLSTOP");   break;
        case PSL_STATUS_STILL:                  return("PSL_STATUS_STILL");   break;
        case PSL_STATUS_NO_RESUME:              return("PSL_STATUS_NO_RESUME");   break;
        case PSL_STATUS_OPEN:                   return("PSL_STATUS_OPEN");   break;
        case PSL_STATUS_CLOSE:                  return("PSL_STATUS_CLOSE");   break;
        case PSL_STATUS_SLOW_FWD:               return("PSL_STATUS_SLOW_FWD");   break;
        case PSL_STATUS_SLOW_RWD:               return("PSL_STATUS_SLOW_RWD");   break;
        case PSL_STATUS_FAST_FWD:               return("PSL_STATUS_FAST_FWD");   break;
        case PSL_STATUS_FAST_RWD:               return("PSL_STATUS_FAST_RWD");   break;
        case PSL_STATUS_CHAPTER_SKIP:           return("PSL_STATUS_CHAPTER_SKIP");   break;
        case PSL_STATUS_SKIP_NEXT:              return("PSL_STATUS_SKIP_NEXT");   break;
        case PSL_STATUS_SKIP_PREV:              return("PSL_STATUS_SKIP_PREV");   break;
        case PSL_STATUS_STEP_FWD:               return("PSL_STATUS_STEP_FWD");   break;
        case PSL_STATUS_STEP_BWD:               return("PSL_STATUS_STEP_BWD");   break;
        case PSL_STATUS_REPEAT:                 return("PSL_STATUS_REPEAT");   break;
        case PSL_STATUS_NO_DISC:                return("PSL_STATUS_NO_DISC");   break;
        case PSL_STATUS_DISC_TYPE:              return("PSL_STATUS_DISC_TYPE");   break;
        case PSL_STATUS_LOADING:                return("PSL_STATUS_LOADING");   break;
        case PSL_STATUS_LOAD_COMPLETE:          return("PSL_STATUS_LOAD_COMPLETE");   break;
        case PSL_STATUS_ANGLE_CHANGE:           return("PSL_STATUS_ANGLE_CHANGE");   break;
        case PSL_STATUS_AUDIO_CHANGE:           return("PSL_STATUS_AUDIO_CHANGE");   break;
        case PSL_STATUS_AUDIO_NOT_SUPPORTED:    return("PSL_STATUS_AUDIO_NOT_SUPPORTED");   break;
        case PSL_STATUS_INVALID_REGION:         return("PSL_STATUS_INVALID_REGION");   break;
        case PSL_STATUS_STANDBY:                return("PSL_STATUS_STANDBY");   break;
        case PSL_STATUS_SETTMPPML:              return("PSL_STATUS_SETTMPPML");   break;
        case PSL_STATUS_PARENTAL_PROHIBIT:      return("PSL_STATUS_PARENTAL_PROHIBIT");   break;
        case PSL_STATUS_UNKNOWN:                return("PSL_STATUS_UNKNOWN");   break;
        case PSL_STATUS_TIMER:                  return("PSL_STATUS_TIMER");   break;
        case PSL_STATUS_ICON_TIMEOUT:           return("PSL_STATUS_ICON_TIMEOUT");   break;
        case PSL_STATUS_MENU_TIMEOUT:           return("PSL_STATUS_MENU_TIMEOUT");   break;
        case PSL_STATUS_GENERIC_TIMEOUT:        return("PSL_STATUS_GENERIC_TIMEOUT");   break;
        case PSL_STATUS_ANGLE_ON:               return("PSL_STATUS_ANGLE_ON");   break;
        case PSL_STATUS_PLAYMARKER:             return("PSL_STATUS_PLAYMARKER");   break;
        case PSL_STATUS_CLEARMARKER:            return("PSL_STATUS_CLEARMARKER");   break;

        default:
            return ( "UNKNOWN PSL STATUS" );
        break;
    }

}


/**
 * PslCreate -- Create the PSL thread and message queue.
 *
 * @param
 *    none.
 *
 * @retval
 *    PSL_SUCCESS if successful
 *    PSL_FAILURE if not successful
 */
PSL_STATUS  PslCreate(void)
{
    ULONG i;

    if (m_hPsl != NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslCreate: Already created!\n"));
        goto errout;
    }

    /* Create the local handle */
    m_hPsl = (PSL_DATA *)OS_MemAlloc(sizeof(PSL_DATA) );
    if (m_hPsl == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslCreate: Failure creating local PSL handle!\n"));
        goto errout;
    }

    /* Initialize parameters */
    m_hPsl->pPsl                = NULL;
    m_hPsl->fInit               = FALSE;
    m_hPsl->msg_queue           = 0;
    m_hPsl->ulTaskId            = 0;

    /* process user input functions */
    for (i = 0; i < PSL_USER_INPUT_MAX; i++)
    {
        m_hPsl->ProcessUserInput[i] = NULL;
    }

    /* process status functions */
    for (i = 0; i < PSL_STATUS_MAX; i++)
    {
        m_hPsl->ProcessStatus[i] = NULL;
    }

    /* Create the PSL handle to be shared by all PSL modules */
    m_hPsl->pPsl = (PSL_HANDLE *)OS_MemAlloc(sizeof(PSL_HANDLE) );
    if (m_hPsl->pPsl == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslCreate: Failure creating PSL handle!\n"));
        goto errout;
    }
    m_hPsl->pPsl->powerState = FALSE;
    m_hPsl->pPsl->sem_synch  = 0;
    
    /* Create the command processing semaphore */
    m_hPsl->cmd_processing_sem = OS_SemBCreate(OS_SEM_Q_FIFO, OS_SEM_FULL);
    if (0 == m_hPsl->cmd_processing_sem)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslCreate: Failure creating command processing sem!\n"));
        goto errout;
    }

    /* Create the psl message queue */
    m_hPsl->msg_queue = OS_MsgQCreate(PSL_MSG_QUEUE_DEPTH, sizeof(PSL_MESSAGE), OS_MSG_Q_FIFO);
    if (m_hPsl->msg_queue == 0)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslCreate: Failure creating remote cmd msg queue!\n"));
        goto errout;
    }

    /* Create a task to receive and process psl messages */
    m_hPsl->ulTaskId = OS_TaskSpawnParam("PslTask", OS_TASK_HIGH_PRIORITY, 4096, PslTask, NULL, NULL);
    if (m_hPsl->ulTaskId == (ULONG)OS_FAILURE)
    {
        m_hPsl->ulTaskId = 0;
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslCreate: Failure spawning psl task!\n"));
        goto errout;
    }
    
    DBGPRINT(DBG_ON(DBG_TRACE), ("PslCreate: PSL created\n"));

    return (PSL_SUCCESS);

errout:

    if (m_hPsl != NULL)
    {
        if (m_hPsl->ulTaskId != 0)
        {
            PSL_MESSAGE msg;

            /* Send an abort message to the PSL task */
            msg.tMsgType        = PSL_MSG_ABORT;
            msg.pvBuffer        = NULL;
            msg.ulBufferLength  = 0;
            msg.ulData0         = 0;
            msg.ulData1         = 0;
            msg.ulData2         = 0;
            msg.ulSemID         = 0;
            OS_MsgQSend(m_hPsl->msg_queue, (char *)&msg, sizeof(PSL_MESSAGE), OS_NO_WAIT, OS_MSG_PRI_NORMAL);

            /* Wait for Psl task to exit then delete the task */
            OS_TaskJoin(m_hPsl->ulTaskId);
            OS_TaskDelete(m_hPsl->ulTaskId);
            m_hPsl->ulTaskId = 0;
        }

        if (m_hPsl->msg_queue != 0)
        {
            /* Delete the PSL msg queue */
            OS_MsgQDelete(m_hPsl->msg_queue);
            m_hPsl->msg_queue = 0;
        }

        if (0 != m_hPsl->cmd_processing_sem)
        {
            OS_SemDelete(m_hPsl->cmd_processing_sem);
            m_hPsl->cmd_processing_sem = 0;
        }