pbc.cpp

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

    Returns:    nothing

*************************************************/
void pbc_key_proc(ULONG *msg)
{
    BOOLEAN fDone = TRUE;

    /* Check for valid state */
    if (PBC_MODE_LOAD == pbc_mode)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc: KEY ERROR! PBC_MODE_LOAD\n"));
        uop_prohibited_msg();
        return;
    }


    /* Check for mode independent commands */
    switch ((NAV_COMMAND) msg[1])
    {
    case KEY_PLAY_LOCATION:
        DBGPRINT(DBG_ON(DBG_TRACE), ("case KEY_PLAY_LOCATION\n"));
        if (msg[2] && ( ((NAV_VCD_LOCATION *)msg[2])->ulSize >= sizeof(NAV_VCD_LOCATION)) )
        {
            play_location((NAV_VCD_LOCATION *)msg[2]);
        }
        else
        {
            DbgPrint(("Invalid location handle or size, %s, %d\n", __FILE__, __LINE__));
        }
        break;

    default:
        fDone = FALSE;
        break;
    }

    if (fDone)
    {
        return;
    }



    /* mode dependent commands get sorted here */
    switch (pbc_mode)
    {
    case PBC_MODE_STOP:
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc: PBC_MODE_STOP\n"));
        pbc_key_proc_stop((NAV_COMMAND) msg[1], msg[2], msg[3]);
        break;

    case PBC_MODE_PLAY:
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc: PBC_MODE_PLAY\n"));
        pbc_key_proc_play((NAV_COMMAND) msg[1], msg[2], msg[3]);
        break;

    case PBC_MODE_END:
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc: PBC_MODE_END\n"));
        pbc_key_proc_end((NAV_COMMAND) msg[1], msg[2], msg[3]);
        break;

    case PBC_MODE_HALT:
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc: PBC_MODE_HALT\n"));
        pbc_key_proc_halt((NAV_COMMAND) msg[1], msg[2], msg[3]);
        break;

    default:
        DbgPrint(("pbc_key_proc: UNKNOWN!!!!!\n"));
        break;
    }
}

/*************************************************
    Function Name:  pbc_key_proc_stop

    Purpose:    Handle key input in stop state.

    Theory:     Processes key command for the stop
                state.

    Arguments:  key command, parameter from OSD task

    Returns:    nothing

*************************************************/
void pbc_key_proc_stop(NAV_COMMAND key, ULONG osd_param1, ULONG osd_param2)
{
    ULONG msg[4]={0,0,0,0};

    switch (key)
    {

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

        pbc_mode = PBC_MODE_PLAY;

        if (g_pbc_on == PBC_OFF)
        {
            /* No PBC - just track play */
            if (g_random_mode != PMODE_RANDOM)
            {
                g_track = cd_start_tno_get(KEY_PLAY);
            }
            g_time[0]    = 0;
            g_time[1]    = 0;
            g_play_kind  = PKIND_PLAY;
            ulPlaySpeed  = 1000;

            pbc_track_play(g_track, PLY_TIM_EOF);
        }
        else
        {
            if (pbc_scene_play())
            {
                stop_on_error();
                return;
            }
        }
        break;

    case KEY_TITLE_PLAY:

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

        g_pbc_on = PBC_OFF;

        osd_param1++;

        g_track = (UBYTE)(osd_param1);

        pbc_track_play( (USHORT)(osd_param1) , PLY_TIM_EOF);

        break;

    case KEY_PBC:
        if ((g_info_vcd.ver == 0x0200) || (g_tracks_svd.ver == 0x0100) || (g_tracks_svd.ver == 0x7420))
        {
            g_random_mode = PMODE_NORMAL;

            if (g_pbc_on == PBC_OFF)
            {
                g_pbc_on = PBC_ON;
            }
            else
            {
                g_pbc_on = PBC_OFF;
            }
        }
        else
        {
            uop_prohibited_msg();
        }
        break;

    case KEY_SHUFFLE_PLAY:
        if (g_pbc_on == PBC_ON)
        {
            uop_prohibited_msg();
        }
        else
        {
            pbc_shuffle();
        }
        break;

    case KEY_STOP:
        OS_MsgQReset(queue_vcd);
        break;

    default:
        uop_prohibited_msg();
        break;
    }
}

/*************************************************
    Function Name:  pbc_key_proc_play

    Purpose:    Handle key input in play state.

    Theory:     Processes key command for the play
                state.

    Arguments:  key command, OSD parameter

    Returns:    nothing

*************************************************/
void pbc_key_proc_play(NAV_COMMAND key, ULONG osd_param1, ULONG osd_param2)
{
    ULONG                   offset;
    USHORT                  pin;
    UBYTE                   do_next_prev;
    PLAY_LIST               plist;
    ULONG                   msg[4];
    ULONG                   begin;
    UBYTE                   error=0;
    UBYTE                   temp=0;
    PE_ISTREAMCTRL_PLAYRATE PlayRate;
    static UBYTE            a_b_resume[3];        /* A B repeat resume address */

    DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc_play() -- ENTER, g_play_kind=%d, key=%d\n", g_play_kind, key));

    error = 0;
    do_next_prev = 0;
    switch (key)
    {
    case KEY_STOP:
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc_play: KEY_STOP\n"));


        /* display background color */
        PEiConfigureSetVideoMute(tPE, VIDEO_MUTE_BLACK_SCREEN);
        PEiStreamCtrlPause(tPE);

        g_play_kind = PKIND_STOP;
        pbc_mode = PBC_MODE_HALT;

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

        break;

    case KEY_PLAY:
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc_play: KEY_PLAY\n"));

        g_track_prev = 0;

        if (pbc_end_flag == 0)
        {
            pbc_key_proc_play_play();
        }
        break;

    case KEY_STEP:
        if (ulPlaySpeed != 0)
        {
            /* if not paused, just pause */
            PEiStreamCtrlPause(tPE);
            ulPlaySpeed = 0;
            g_play_kind = PKIND_PAUSE;
        }
        else
        {
            /* if paused, then step */
            PEiStreamCtrlStep(tPE);
        }

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


    case KEY_PAUSE_ON:
        PEiStreamCtrlPause(tPE);
        ulPlaySpeed = 0;
        g_play_kind = PKIND_PAUSE;

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

    case KEY_PAUSE_OFF:
        PEiStreamCtrlResume(tPE);
        ulPlaySpeed = 1000;
        g_play_kind = PKIND_PLAY;

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

    case KEY_FWD_PLAY:
        if (PEiStreamCtrlConfigPlayRateParam(tPE, osd_param1, PE_ISTREAMCTRL_DIRECTION_FORWARD, &PlayRate) == PE_SUCCESS)
        {
            if (PlayRate.discontiguous == 0)
            {
                PEiStreamCtrlSetRate(tPE, &PlayRate);
                ulPlaySpeed = osd_param1;
                g_play_kind = PKIND_FF;

                msg[0] = VDVD_STATUS_FAST_F;
                if (UsrEventHandler(msg) != USR_SUCCESS)
                {
                    DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
                }
            }
            else
            {
                DbgPrint(("\nThe rate of %u is not supported in VCD!\n\n", osd_param1));
                msg[0] = VDVD_STATUS_NOT_IMPLEMENTED;
                if (UsrEventHandler(msg) != USR_SUCCESS)
                {
                    DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
                }
            }
        }
        break;

    case KEY_NEXT_PG:
        DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_key_proc_play: KEY_NEXT_PG\n"));

        if (pbc_end_flag)
        {
            break;
        }

        /* clear the A-B repeat */
        if (A_B_count == 1)
        {
            A_B_count = 0;
            g_repeat_mode = REPEAT_OFF;
            msg[0] = VDVD_STATUS_REPEAT;
            msg[1] = VDVD_INFO_REPEAT_OFF;
            if (UsrEventHandler(msg) != USR_SUCCESS)
            {
                DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
            }
        }

        if (g_pbc_on == PBC_ON)
        {
            if (g_repeat_mode == REPEAT_A_B)
            {
                g_repeat_mode = REPEAT_OFF;
                A_B_count = 0;
                msg[0] = VDVD_STATUS_REPEAT;
                msg[1] = VDVD_INFO_REPEAT_OFF;
                if (UsrEventHandler(msg) != USR_SUCCESS)
                {
                    DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
                }
            }
            if (g_repeat_mode != REPEAT_OFF)
            {
                g_repeat_mode = REPEAT_OFF;
                A_B_count = 0;
                msg[0] = VDVD_STATUS_REPEAT;
                msg[1] = VDVD_INFO_REPEAT_OFF;
                if (UsrEventHandler(msg) != USR_SUCCESS)
                {
                    DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
                }
            }
            if (pbc_loop_jump_chk() == OS_OK)
            {
                if (*g_current_psd == PLAY_LIST_HD)
                {
                    /* Play List */
                    pbcParsePlayList(&plist, g_current_psd);

                    if ((pbc_play_item_num + 1) == plist.item_no)
                    {
                        do_next_prev = 1;
                    }
                    else
                    {
                        ++pbc_play_item_num;
                        pin = plist.pin[pbc_play_item_num];    /* Get PIN */
                        pbc_play_item(pin, plist.play_time);   /* ITEM Play */
                        msg[0] = VDVD_STATUS_CHAPTER_SKIP;
                        msg[1] = g_scene;
                        msg[2] = 1;
                        if (UsrEventHandler(msg) != USR_SUCCESS)
                        {
                            DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
                        }
                    }
                }
                else
                {
                    do_next_prev = 1;
                }

                if (do_next_prev)
                {
                    offset = pbc_next_check();
                    if (offset != 0x0FFFF)
                    {
                        offset *= g_info_vcd.offset;
                        error = pbc_list_play(offset);
                        msg[0] = VDVD_STATUS_CHAPTER_SKIP;
                        msg[1] = g_scene;
                        msg[2] = 1;
                        if (UsrEventHandler(msg) != USR_SUCCESS)
                        {
                            DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
                        }
                        if (error)
                        {
                            stop_on_error();
                            return;
                        }
                    }
                    else
                    {
                        uop_prohibited_msg();
                    }
                }
            }
            else
            {
                pbc_jump_key = KEY_NEXT_PG;
            }
        }
        else
        {
            UBYTE tno;

            if (g_repeat_mode == REPEAT_A_B)
            {
                g_repeat_mode = REPEAT_OFF;
                A_B_count = 0;
                msg[0] = VDVD_STATUS_REPEAT;
                msg[1] = VDVD_INFO_REPEAT_OFF;
                if (UsrEventHandler(msg) != USR_SUCCESS)
                {
                    DbgPrint(("\nUsrEventHandler FAILURE, %s, %d\n\n", __FILE__, __LINE__));
                }
            }
            temp = 1;

            tno = cd_next_tno_get();

            if (tno == 0xFF)
            {
                tno = cd_start_tno_get(KEY_NEXT_PG);
            }

            msg[0] = VDVD_STATUS_CHAPTER_SKIP;
            msg[1] = tno - 1;
            msg[2] = 1;
            if