vcd_app.cpp

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

 *      none
 *
 * @retval
 *      Current title number
 */
USHORT VcdAppGetCurrentTitle(void)
{
    DBGPRINT(DBG_ON(DBG_ERROR), ("VcdAppGetNumberOfTitles: stubbed\n"));
    return (0);
}

/**
 * VcdAppGetCurrentChapter -- Get current chapter number
 *
 * @param
 *      none
 *
 * @retval
 *      Current chapter number
 */
USHORT VcdAppGetCurrentChapter(void)
{
    DBGPRINT(DBG_ON(DBG_ERROR), ("VcdAppGetNumberOfTitles: stubbed\n"));
    return (0);
}



/**
 * VcdAppGetRepeatMode -- Return the repeat mode
 *
 * @param
 *      None
 *
 * @retval
 *      VDVD_INFO_REPEAT repeat mode
 */
USHORT  VcdAppGetRepeatMode(void)
{
    USHORT usVdvdRepeatMode = VDVD_INFO_REPEAT_OFF;

    /* map dvd g_repeat_mode to vdvd type */
    switch (g_repeat_mode)
    {
    case REPEAT_OFF:
        usVdvdRepeatMode = VDVD_INFO_REPEAT_OFF;
        break;
    case REPEAT_TT:
        usVdvdRepeatMode = VDVD_INFO_REPEAT_CHAPTER;
        break;
    case REPEAT_ALL:
        usVdvdRepeatMode = VDVD_INFO_REPEAT_TITLE;
        break;
    case REPEAT_A_B:
        /* map ab count to vdvd repeat a-b type */
        if (A_B_count == 1)
        {
            usVdvdRepeatMode = VDVD_INFO_REPEAT_A;
        }
        else
        {
            usVdvdRepeatMode = VDVD_INFO_REPEAT_AB;
        }
        break;
    default:
        break;
    }

    return (usVdvdRepeatMode);
}



/**
 * VcdAppGetPlayTime -- Get current play time
 *
 * @param
 *      bTimeMode - time mode (0 = Chapter, 1 = Chapter remain, 2 = Title, 3 = Title Remain)
 *
 * @retval
 *      Play time in seconds
 */
ULONG  VcdAppGetPlayTime(BYTE bTimeMode)
{
    ULONG ulTime;

    /*
     * Determine time mode we want to get
     */
    switch (bTimeMode)
    {
    case 0:
        time_info->display_mode = CHAP_UP;
        break;
    case 1:
        time_info->display_mode = CHAP_DOWN;
        break;
    case 2:
        time_info->display_mode = TITLE_UP;
        break;
    case 3:
        time_info->display_mode = TITLE_DOWN;
        break;
    default:
        DBGPRINT(DBG_ON(DBG_ERROR), ("DvdAppGetPlayTime: invalid time mode!\n"));
        time_info->display_mode = TITLE_UP;
        break;
    }

    /* Update time values for the time mode with the current time from navpack */
    update_timedisp_vcd();

    /* Get time in hour, min, seconds and convert to time in seconds. */
    ulTime  = 60 * 60 * time_info->hour;
    ulTime += 60 * time_info->min;
    ulTime += time_info->sec;

    return (ulTime);
}



/**
 * VcdAppGetLocationHandleSize -- Get size of vcd location handle
 *
 * @param
 *      none
 *
 * @retval
 *      size in bytes
 */
ULONG VcdAppGetLocationHandleSize(void)
{
    return (sizeof(NAV_VCD_LOCATION));
}

/**
 * DvdAppGetLocation -- Get location of dvd playback
 *
 * @param
 *      pvLocation - location handle
 *      ulSize -- size of buffer pointed to by location handle
 *
 * @retval
 *      DVDAPP_STATUS
 */
VCDAPP_STATUS VcdAppGetLocation(PVOID pvLocation, ULONG ulSize)
{
    if (pvLocation == NULL)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("VcdAppGetLocation: NULL pointer!\n"));
        return (VCDAPP_NULL_PTR);
    }

    if (ulSize < sizeof(NAV_VCD_LOCATION) )
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("VcdAppGetLocation: Invalid size!\n"));
        return (VCDAPP_INVALID_PARAM);
    }

    if (PBC_MODE_LOAD == pbc_mode)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("VcdAppGetLocation: vcd nav not started!\n"));
        return (VCDAPP_FAILURE);
    }

    /*
     * Setting a bookmark is prohibited in the following cases
     *  1. Current playback point is in an access restricted block.
     *  2. Current title is a random or multi-title pgc.
     *  3. Current PGC type is menu.
     *  4. Full-stop state.
     */
    if (0)// (c_pbi[next_cell - 1].c_cat[1] & 0x20) ||
      //   (tt_srp[get_sprm(SPRM_TTN_TT_DOM) - 1].tt_pb_ty & 0x40) ||
      //   (pgc_domain == VMGM_PGC) || (pgc_domain == VTSM_PGC) ||
      //   (DvdAppGetPlayState() == VDVD_STATUS_FULLSTOP) )
    {
        return (VCDAPP_PROHIBITED);
    }

    /* set location handle size */
    ((NAV_VCD_LOCATION *)pvLocation)->ulSize = ulSize;


    /* record needed information in location handle */
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.pbc_mode         = pbc_mode;
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.g_pbc_on         = g_pbc_on;
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.g_track          = g_track;
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.g_scene          = g_scene;
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.pbc_play_time[0] = pbc_play_time[0];
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.pbc_play_time[1] = pbc_play_time[1];
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.pbc_play_time[2] = pbc_play_time[2];
    ((NAV_VCD_LOCATION *)pvLocation)->rsm.pbc_play_time[3] = pbc_play_time[3];

    return (VCDAPP_SUCCESS);
}





/*
 * PRIVATE FUNCTIONS
 *****************************************************************************/

/**
 * Kill the application threads, delete queues, events, and semaphores, and release all allocations.
 */
static void VcdAppStopNav(void)
{
    ULONG msg[4];

    fVCDAppStarted = FALSE;

    /* release wait states */
    msg[0] = MSG_PBC_TASK_EXIT;
    OS_MsgQSend(queue_vcd, (char *)&msg[0], VCD_MSG_SIZE, OS_NO_WAIT, OS_MSG_PRI_URGENT);

    /* wait for threads to exit */
    if (ulVcdTaskID != 0)
    {
        OS_TaskJoin(ulVcdTaskID);
        OS_TaskDelete(ulVcdTaskID);
        ulVcdTaskID = 0;
    }

    /* delete message queues */
    OS_MsgQDelete(queue_vcd);
}

/**
 * Receives event callbacks from the PE.
 *
 * @param event - enumerated event code (see pe_app.h)
 */
static PE_STATUS vcdappPEEventCallback(PVOID pContext, PE_EVENT_CODE event, PVOID pEventInfo)
{
    PE_STATUS                status    = PE_SUCCESS;
    ULONG                    msg[4];
    PE_ICONFIGURE_VIDEO_MUTE mute;
    uint32                   uiDRStatus;

    if (event >= PE_EVENT_CODE_INVALID)
    {
        DbgPrint(("vcdappPEEventCallback: Invalid event code ID\n"));
        return (PE_FAILURE);
    }


    switch (event)
    {
    case PE_EVENT_AUTO_PAUSE:
        DBGPRINT(DBG_ON(DBG_TRACE), ("vcdappPEEventCallback(): PE_EVENT_AUTO_PAUSE\n"));

        g_play_kind  = PKIND_PAUSE;

        PEiStreamCtrlPause(tPE);

        msg[0] = VDVD_STATUS_PAUSE;
        if (UsrEventHandler(msg) != USR_SUCCESS)
        {
            DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
        }

        if (pbc_apause_tim != 0x0FFFFFFFF)
        {
            pbc_waite_time_req(TIM_CONT_START, pbc_apause_tim);
        }

        break;

    case PE_EVENT_POSITION:
        DBGPRINT(DBG_ON(DBG_VERBOSE), ("vcdappPEEventCallback(): PE_EVENT_POSITION - 0x%x\n", *((ULONG*)pEventInfo)));

        msg[0] = MSG_FE_LBA;
        msg[1] = 0x02;
        msg[2] = *((ULONG*)pEventInfo);
        msg[3] = 0;
        OS_MsgQSend(queue_vcd, (char *)&msg[0], VCD_MSG_SIZE, OS_WAIT_FOREVER, OS_MSG_PRI_NORMAL);

        break;

    case PE_EVENT_BEG_OF_STREAM:
        DBGPRINT(DBG_ON(DBG_TRACE), ("vcdappPEEventCallback(): PE_EVENT_BEG_OF_STREAM\n"));

        /* hide the splash screen if it is being displayed */
        /*PEiSplashScreenHide(tPE);*/
        logo_on = 0;

        PEiConfigureGetVideoMute(tPE, &mute);

        if ( (mute != VIDEO_MUTE_OFF) && (pbc_mode != PBC_MODE_HALT) )
        {
            /* if video not on, turn on */
            PEiConfigureSetVideoMute(tPE, VIDEO_MUTE_OFF);
        }
        break;

    case PE_EVENT_END_OF_STREAM:
        DBGPRINT(DBG_ON(DBG_TRACE), ("vcdappPEEventCallback(): PE_EVENT_END_OF_STREAM\n"));

        /* get the current DR status */
        DRGetStatus(tDR, DR_STREAM_MAIN, DR_STATCMD_BUFFERS, &uiDRStatus);

        /* if the dr is idle send a track buffer empty message to the nav */
        if ( (uiDRStatus & DR_STATUS_TRACK_BUFFER_EMPTY) &&
            ((uiDRStatus & DR_STATUS_QUEUE_BUFFER) == 0) )
        {
            pbc_end_flag = 1;
            msg[0] = MSG_PLAY_END;

            /* @todo - fix this once the api for EOS notification is available */
            OS_TaskDelay(OS_WAIT_2S);

            OS_MsgQSend(queue_vcd, (char *)&msg[0], VCD_MSG_SIZE, OS_NO_WAIT, OS_MSG_PRI_NORMAL);
            status = PE_EVNT_VCD_PUSH;
        }
        break;

    case PE_EVENT_DISCONTINUITY:
        DBGPRINT(DBG_ON(DBG_TRACE), ("vcdappPEEventCallback(): PE_EVENT_DISCONTINUITY\n"));
        break;

    case PE_EVENT_ASYNC_PREFILL:
        DBGPRINT(DBG_ON(DBG_TRACE), ("vcdappPEEventCallback(): PE_EVENT_ASYNC_PREFILL\n"));

        /* Put the PE in the Run state. */
        PEiStreamCtrlRun(tPE);
        break;

    default:
        DBGPRINT(VCDAPP_DEBUG, ("vcdappPEEventCallback: Unknown PE event = %d\n", event));
        status = PE_FAILURE;
        break;
    }

    return (status);
}

/**
 * Receives event callbacks from the DR.
 *
 * @param pContext - context pointer registered with the dr when the event handler is attached.
 * @param event - enumerated event code (see dr_app.h)
 * @param pEventInfo - pointer to buffer that can contain additional info depending on the event received.
 */
static DR_ERROR vcdappDrEventCallback(PVOID pContext, DR_EVENT_CODE event, PVOID pEventInfo)
{
    if (event >= DR_EVENT_CODE_INVALID)
    {
        DbgPrint(("DrEventCallback: Invalid event code ID\n"));
        return (DR_FAILURE);
    }

    switch (event)
    {
    case DR_EVENT_BUFFER_EMPTY:
        DBGPRINT(DBG_ON(DBG_TRACE), ("DrEventCallback(): DR_EVENT_BUFFER_EMPTY\n"));
        break;

    case DR_EVENT_COMMAND_BUFFER_EMPTY:
        DBGPRINT(DBG_ON(DBG_TRACE), ("DrEventCallback(): DR_EVENT_COMMAND_BUFFER_EMPTY\n"));
        break;

    case DR_EVENT_ERROR:
        DBGPRINT(DBG_ON(DBG_TRACE), ("DrEventCallback(): DR_EVENT_ERROR\n"));
        break;

    case DR_EVENT_COMMAND_ERROR:
        DBGPRINT(DBG_ON(DBG_TRACE), ("DrEventCallback(): DR_EVENT_COMMAND_ERROR\n"));
        break;

    default:
        DBGPRINT(VCDAPP_DEBUG, ("DrEventCallback: Unknown DR event = %d\n", event));
        return (DR_FAILURE);
    }

    return (DR_SUCCESS);
}