{
    if (pPSL != NULL)
    {
        /* update navigator configuration setting through metanav */
        m_pMetaNav->UpdateParentalLevel();
    }
    else
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalUpdateParentalLevel: NULL handle!\n"));
    }
}

/**
 * PslExternalUpdateCountryStandard -- update country standard configuration setting
 *
 * @param
 *      pPSL - handle to internal psl data
 *
 * @retval
 *    none
 */
void  PslExternalUpdateCountryStandard(PSL_HANDLE *pPSL)
{
    if (pPSL != NULL)
    {
        /* update navigator configuration setting through metanav */
        m_pMetaNav->UpdateCountryCode();
    }
    else
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalUpdateCountryStandard: NULL handle!\n"));
    }
}

/**
 * PslExternalUpdateLanguageSubtitle -- update aspect ratio configuration setting
 *
 * @param
 *      pPSL - handle to internal psl data
 *
 * @retval
 *    none
 */
void  PslExternalUpdateTvAspectRatio(PSL_HANDLE *pPSL)
{
    if (pPSL != NULL)
    {
        /* update navigator configuration setting through metanav */
        m_pMetaNav->UpdateTvType();
    }
    else
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalUpdateTvAspectRatio: NULL handle!\n"));
    }
}

/**
 * PslExternalUpdateLanguageSubtitle -- update video format configuration setting
 *
 * @param
 *      pPSL - handle to internal psl data
 *
 * @retval
 *    none
 */
void  PslExternalUpdateVideoFormat(PSL_HANDLE *pPSL)
{
    if (pPSL != NULL)
    {
        /* update navigator configuration setting through metanav */
        m_pMetaNav->UpdateVideoFormat();
    }
    else
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalUpdateVideoFormat: NULL handle!\n"));
    }
}
   
/**
 * PslExternalUpdateLanguageSubtitle -- update spdif configuration setting
 *
 * @param
 *      pPSL - handle to internal psl data
 *
 * @retval
 *    none
 */
void  PslExternalUpdateSPDIF(PSL_HANDLE *pPSL)
{
    if (pPSL != NULL)
    {
        /* update navigator configuration setting through metanav */
        m_pMetaNav->UpdateSPDIF();
    }
    else
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("PslExternalUpdateSPDIF: NULL handle!\n"));
    }
}    
 
/**
 * RemoteCommandCallback -- Receives callbacks from remote api
 *
 * @param
 *      pvContext   -- PVOID param
 *      KeyCode     -- remote key code 
 *      Repeat      -- repeat flag
 *
 * @retval
 *    none.
 */
static void RemoteCommandCallback(PVOID pvContext, RC_KEY KeyCode, ULONG Repeat)
{
    PSL_USER_INPUT_TYPE tUserInput;
    ULONG               ulInfo              = 0;
    BOOLEAN             fDispatchCommand    = TRUE;

    /*
     * Map the remote control key code to a PSL user input type
     */
    switch (KeyCode)
    {
    case RC_BTN_EXIT:
        tUserInput = PSL_USER_INPUT_EXIT;
        break;
    case RC_BTN_RETURN:
        tUserInput = PSL_USER_INPUT_RETURN;
        break;
    case RC_BTN_PLAY:
        tUserInput = PSL_USER_INPUT_PLAY;
        break;
    case RC_BTN_PAUSE:
        tUserInput = PSL_USER_INPUT_PAUSE;
        break;
    case RC_BTN_INFO:
        tUserInput = PSL_USER_INPUT_INFO;
        break;
    case RC_BTN_SKIP_FWD:
        tUserInput = PSL_USER_INPUT_SKIP_FWD;
        break;
    case RC_BTN_SKIP_BWD:
        tUserInput = PSL_USER_INPUT_SKIP_BWD;
        break;
    case RC_BTN_FAST_FWD:
        tUserInput = PSL_USER_INPUT_FAST_FWD;
        break;
    case RC_BTN_FAST_RWD:
        tUserInput = PSL_USER_INPUT_FAST_RWD;
        break;
    case RC_BTN_SLOW_FWD:
        tUserInput = PSL_USER_INPUT_SLOW_FWD;
        break;
    case RC_BTN_SLOW_RWD:
        tUserInput = PSL_USER_INPUT_SLOW_RWD;
        break;
    case RC_BTN_STEP_FWD:
        tUserInput = PSL_USER_INPUT_STEP_FWD;
        break;
    case RC_BTN_ANGLE:
        tUserInput = PSL_USER_INPUT_ANGLE;
        break;
    case RC_BTN_REPEAT_AB:
        tUserInput = PSL_USER_INPUT_REPEAT_AB;
        break;
    case RC_BTN_REPEAT:
        tUserInput = PSL_USER_INPUT_REPEAT;
        break;
    case RC_BTN_AUDIO_SELECT:
        tUserInput = PSL_USER_INPUT_AUDIO;
        break;
    case RC_BTN_VOL_UP:
        tUserInput = PSL_USER_INPUT_VOL_UP;
        break;
    case RC_BTN_VOL_DOWN:
        tUserInput = PSL_USER_INPUT_VOL_DOWN;
        break;
    case RC_BTN_VOL_MUTE:
        tUserInput = PSL_USER_INPUT_VOL_MUTE;
        break;
    case RC_BTN_ZOOM:
        tUserInput = PSL_USER_INPUT_ZOOM;
        break;
    case RC_BTN_UP:
        tUserInput = PSL_USER_INPUT_UP;
        break;
    case RC_BTN_DOWN:
        tUserInput = PSL_USER_INPUT_DOWN;
        break;
    case RC_BTN_LEFT:
        tUserInput = PSL_USER_INPUT_LEFT;
        break;
    case RC_BTN_RIGHT:
        tUserInput = PSL_USER_INPUT_RIGHT;
        break;
    case RC_BTN_ENTER:
        tUserInput = PSL_USER_INPUT_SELECT;
        break;
    case RC_BTN_STOP:
        tUserInput = PSL_USER_INPUT_STOP;
        break;
    case RC_BTN_POWER:
        tUserInput = PSL_USER_INPUT_POWER;
        break;
    case RC_BTN_EJECT:
        tUserInput = PSL_USER_INPUT_EJECT;
        break;
    case RC_BTN_MENU:
        tUserInput = PSL_USER_INPUT_MENU;
        break;
    case RC_BTN_TITLE:
        tUserInput = PSL_USER_INPUT_TITLE;
        break;
    case RC_BTN_0:
    case RC_BTN_1:
    case RC_BTN_2:
    case RC_BTN_3:
    case RC_BTN_4:
    case RC_BTN_5:
    case RC_BTN_6:
    case RC_BTN_7:
    case RC_BTN_8:
    case RC_BTN_9:
        tUserInput  = PSL_USER_INPUT_DIGIT;
        ulInfo      = KeyCode - RC_BTN_0;
        break;
    case RC_BTN_SETUP:
        tUserInput = PSL_USER_INPUT_SETUP;
        break;
    case RC_BTN_SUB_TITLES:
        tUserInput = PSL_USER_INPUT_SUBTITLE;
        break;
    case RC_BTN_DISPLAY:
        tUserInput = PSL_USER_INPUT_DISPLAY;
        break;
    case RC_BTN_SEARCH:
        tUserInput = PSL_USER_INPUT_SEARCH;
        break;
    default:
        DBGPRINT(DBG_ON(DBG_TRACE), ("RemoteCommandCallback: Unsupported command type\n"));
        fDispatchCommand = FALSE;
        break;
    }       

    /* If command is valid, then send it to the PSL thread */
    if (fDispatchCommand == TRUE)
    {
        if (PslSendProcessUserInput(tUserInput, ulInfo, 0) != PSL_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("RemoteCommandCallback: Failure sending user input!\n"));
        }
    }
}

/**
 * StatusEventCallback -- Receives callbacks from navigator
 *
 * @param
 *      pulEvent    -- pointer to unsolicted status event
 *      pvParam     -- pointer to param that was registered with callback
 *
 * @retval
 *      none.
 */
static void StatusEventCallback(ULONG *pulEvent, PVOID pvParam)
{
    PSL_STATUS_TYPE tStatusEvent;
    BOOLEAN         fDispatchStatus = TRUE;
    ULONG           ulData1         = 0;
    ULONG           ulData2         = 0;
    PVOID           pvBuffer        = NULL;
    ULONG           ulBufferSize    = 0;

    if (pulEvent == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("StatusEventCallback: NULL pointer!\n"));
    }

    /*
     * Map the VDVD status event to a PSL status event type.
     */
    switch (pulEvent[0])
    {
    case VDVD_STATUS_PROHIBITED:
        if (pulEvent[1] == VDVD_INFO_PROH_NO_RESUME)
        {
            tStatusEvent = PSL_STATUS_NO_RESUME;
        }
        else
        {
            tStatusEvent = PSL_STATUS_PROHIBITED;
        }
        break;
    case VDVD_STATUS_PAUSE:    
        tStatusEvent    = PSL_STATUS_PAUSE;
        break; 
    case VDVD_STATUS_PLAY:      
        tStatusEvent    = PSL_STATUS_PLAY;
        break;
    case VDVD_STATUS_STOP:     
        if (pulEvent[1] == 0)
        { 
            tStatusEvent = PSL_STATUS_STOP;
        }
        else
        {
            tStatusEvent = PSL_STATUS_FULLSTOP;
        }
        break;
    case VDVD_STATUS_OPEN:      
        tStatusEvent    = PSL_STATUS_OPEN;
        break;
    case VDVD_STATUS_CLOSE:     
        tStatusEvent    = PSL_STATUS_CLOSE;
        break;
    case VDVD_STATUS_SLOW_F:    
        tStatusEvent    = PSL_STATUS_SLOW_FWD;
        break;
    case VDVD_STATUS_SLOW_B:  
        tStatusEvent    = PSL_STATUS_SLOW_RWD;
        break;
    case VDVD_STATUS_FAST_F:      
        tStatusEvent    = PSL_STATUS_FAST_FWD;
        break;
    case VDVD_STATUS_FAST_B:      
        tStatusEvent    = PSL_STATUS_FAST_RWD;
        break;
    case VDVD_STATUS_CHAPTER_SKIP:
        tStatusEvent = PSL_STATUS_CHAPTER_SKIP;
        ulData1      = pulEvent[1];
        break;
    case VDVD_STATUS_STEP:        
        tStatusEvent    = PSL_STATUS_STEP_FWD;
        break;
    case VDVD_STATUS_REPEAT:   
        tStatusEvent    = PSL_STATUS_REPEAT;
        ulData1         = pulEvent[1];
        break;   
    case VDVD_STATUS_A_B:         
        tStatusEvent    = PSL_STATUS_REPEAT;
        if (pulEvent[1] == 1)
        {
            ulData1 = VDVD_INFO_REPEAT_A;
        }
        else
        {
            ulData1 = VDVD_INFO_REPEAT_AB;
        }
        break;
    case VDVD_STATUS_NO_DISC:     
        tStatusEvent    = PSL_STATUS_NO_DISC;
        break;
    case VDVD_STATUS_DISC_TYPE:   
        tStatusEvent = PSL_STATUS_DISC_TYPE;
        switch (pulEvent[1])
        {
        case MEDIA_FORMAT_DVD_A:
        case MEDIA_FORMAT_DVD_V:
            ulData1 = VDVD_INFO_DISCTYPE_DVD;
            break;
        case MEDIA_FORMAT_BDROM:
            ulData1 = VDVD_INFO_DISCTYPE_BDROM;
            break;
        case MEDIA_FORMAT_MP3:
            ulData1 = VDVD_INFO_DISCTYPE_MP3;
            break;
        case MEDIA_FORMAT_CDDA:
            ulData1 = VDVD_INFO_DISCTYPE_CDDA;
            break;
        case MEDIA_FORMAT_VCD:
            ulData1 = VDVD_INFO_DISCTYPE_VCD;
            break;
        case MEDIA_FORMAT_UNKNOWN:
        default:
            ulData1 = VDVD_INFO_DISCTYPE_UNKNOWN;
            break;
        }
        break;
    case VDVD_STATUS_LOADING:     
        tStatusEvent    = PSL_STATUS_LOADING;
        break;
    case VDVD_STATUS_LOAD_COMPLETE:
        tStatusEvent    = PSL_STATUS_LOAD_COMPLETE;
        break;
    case VDVD_STATUS_ANGLE_CHG:
        tStatusEvent    = PSL_STATUS_ANGLE_CHANGE;
        ulData1         = pulEvent[1];
        break;
    case VDVD_STATUS_AUDIO_CHG:
        tStatusEvent    = PSL_STATUS_AUDIO_CHANGE;
        ulData1         = pulEvent[1];
        ulData2         = pulEvent[2];
        pvBuffer        = (PVOID)&pulEvent[3];
        ulBufferSize    = sizeof(ULONG) * 2;
        break;
    case VDVD_STATUS_INVALID_REGION:
        tStatusEvent    = PSL_STATUS_INVALID_REGION;
        ulData1         = pulEvent[1];
        break;
    case VDVD_STATUS_STANDBY_ON:
    case VDVD_STATUS_STANDBY_OFF:
        tStatusEvent    = PSL_STATUS_STANDBY;
        break;
    case VDVD_STATUS_SETTMPPML:
        tStatusEvent    = PSL_STATUS_SETTMPPML;
        break;
    case VDVD_STATUS_PARENTAL_PROHIBIT:
        tStatusEvent    = PSL_STATUS_PARENTAL_PROHIBIT;
        break;
    case VDVD_STATUS_AUDIO_NOT_SUPPORTED:
        tStatusEvent    = PSL_STATUS_AUDIO_NOT_SUPPORTED;
        ulData1         = pulEvent[1];
        break;
    default:
        DBGPRINT(DBG_ON(DBG_TRACE), ("StatusEventCallback: Unsupported status event type = %d\n", pulEvent[0]));
        fDispatchStatus = FALSE;
        break;
    }

    /* If status event is valid, then send it to the PSL thread */
    if (fDispatchStatus == TRUE)
    {
        if (PslSendProcessStatus(tStatusEvent, ulData1, ulData2, pvBuffer, ulBufferSize, 0) != PSL_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("StatusEventCallback: Failure sending status event!\n"));
        }
    }
}