pbc.cpp

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

    Arguments:  none

    Returns:    default list offset

*************************************************/
USHORT pbc_default_check(void)
{
    SELECT_LIST slist;
    USHORT      offset;
    USHORT      sel_no;

    /* List Head Check */
    switch (*g_current_psd)
    {
    case SELECT_LIST_HD:      /* Selection List */
        pbcParseSelectList(&slist, g_current_psd);
        offset = slist.def_list_off;
        if ((offset == 0x0FFFE) || (offset == 0x0FFFD))
        {
            /* Multi Default Selection */
            sel_no = pbc_get_selection_no();
            if (sel_no < slist.nos)
            {
                offset = slist.bsn_off[sel_no];
            }
            else
            {
                offset = 0x0FFFF;
            }
        }
        break;

    case PLAY_LIST_HD:  /* Play List */
    case END_LIST_HD:   /* End List */
    default:
        offset = 0x0FFFF;
        break;
    }

    return (offset);
}

/*************************************************
    Function Name:  pbc_next_check

    Purpose:    VCD next list check.

    Theory:     In PBC, the selection lists can have
                a next list offset to jump to another
                menu or whatever.  This provides the list
                offset of the next item.

    Arguments:  none

    Returns:    Offset of the next item

*************************************************/
USHORT pbc_next_check(void)
{
    SELECT_LIST slist;
    PLAY_LIST   plist;
    USHORT      offset;

    /* List Head Check */
    switch (*g_current_psd)
    {
    case SELECT_LIST_HD:      /* Selection List */
        pbcParseSelectList(&slist, g_current_psd);
        offset = slist.next_list_off;
        break;

    case PLAY_LIST_HD:        /* Play List */
        pbcParsePlayList(&plist, g_current_psd);
        offset = plist.next_list_off;
        break;

    case END_LIST_HD: /* End List */
    default:
        offset = 0x0FFFF;
        break;
    }

    return (offset);
}

/*************************************************
    Function Name:  pbc_prev_check

    Purpose:    VCD previous list check.

    Theory:     In PBC, the selection lists can have
                a previous list offset to jump to another
                menu or whatever.  This provides the list
                offset of the previous item.

    Arguments:  none

    Returns:    Offset of the previous item

*************************************************/
USHORT pbc_prev_check(void)
{
    SELECT_LIST slist;
    PLAY_LIST   plist;
    USHORT      offset;

    /* List Head Check */
    switch (*g_current_psd)
    {
    case SELECT_LIST_HD:      /* Selection List */
        pbcParseSelectList(&slist, g_current_psd);
        offset = slist.pre_list_off;
        break;

    case PLAY_LIST_HD:        /* Play List */
        pbcParsePlayList(&plist, g_current_psd);
        offset = plist.pre_list_off;
        break;

    case END_LIST_HD: /* End List */
    default:
        offset = 0x0FFFF;
        break;
    }

    return (offset);
}

/*************************************************
    Function Name:  pbc_ret_check

    Purpose:    VCD return list check.

    Theory:     In PBC, the selection lists can have
                a return list offset to return from a
                currently playing item.  This returns
                the offset of the item to return to.

    Arguments:  none

    Returns:    Offset of the return item

*************************************************/
USHORT pbc_ret_check(void)
{
    SELECT_LIST slist;
    PLAY_LIST   plist;
    USHORT      offset;

    /* List Head Check */
    switch (*g_current_psd)
    {
    case SELECT_LIST_HD:      /* Selection List */
        pbcParseSelectList(&slist, g_current_psd);
        offset = slist.ret_list_off;
        break;

    case PLAY_LIST_HD:        /* Play List */
        pbcParsePlayList(&plist, g_current_psd);
        offset = plist.ret_list_off;
        break;

    case END_LIST_HD: /* End List */
    default:
        offset = 0x0FFFF;
        break;
    }

    return (offset);
}


UBYTE pbc_make_selection(UBYTE selection)
{
    SELECT_LIST slist;
    ULONG       offset;
    USHORT      base;


    DBGPRINT(DBG_ON(DBG_TRACE), ("pbc_make_selection: %u\n", selection));
    pbcParseSelectList(&slist, g_current_psd);

    base = slist.bsn - 1;


    /* check that numeric selection is valid */
    if (slist.def_list_off == 0xFFFD)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("pbc_make_selection - def_list_off is 0xfffd\n"));
        return(1);
    }

    /* check the input */
    if ( (selection == 0xFF)               || (selection == 0x00) ||
         (selection  > (base + slist.nos)) || (selection <= base)  )
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("pbc_make_selection - illegal selection value: %u\n", selection));
        return(1);
    }

    /* it's all good - get the offset */
    offset = slist.bsn_off[(selection - 1) - base];

    DBGPRINT(DBG_ON(DBG_TRACE), ("OFFSET: 0x%x\n", offset));

    /* check the offset */
    if (offset == 0xFFFF)
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("pbc_make_selection - offset doesn't exist\n"));
        return(1);
    }

    if ( (pbc_mode != PBC_MODE_PLAY) || (pbc_loop_jump_chk() == OS_OK) )
    {
        offset *= g_info_vcd.offset;

        if (pbc_list_play(offset))
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("pbc_make_selection - error playing list\n"));
            stop_on_error();
            return 1;
        }
    }
    else
    {
        DBGPRINT(DBG_ON(DBG_ERROR), ("pbc_make_selection - do selection after looparound.\n"));
        pbc_jump_num = offset;
        pbc_jump_key = KEY_NUMBER;
    }

    return(0);
}


/*************************************************
    Function Name:  pbc_list_play

    Purpose:    VCD list play process.

    Theory:     Checks the current PSD pointer and
                prepares the system for playing that
                type of list.

    Arguments:  none

    Returns:    nothing

*************************************************/
UBYTE pbc_list_play(ULONG offset)
{
    UBYTE *addr, error; /* PSD Addr. */
    ULONG msg[4];

    error = 0;

    addr = (UBYTE *)g_psd_addr;
    addr += offset; /* PSD Addr. Set */

    DbgPrint(("PSD offset = 0x%X\n", offset));

    /* List Head Check */
    switch (*addr)
    {
    case PLAY_LIST_HD:        /* Play List */
        g_previous_psd = g_current_psd;
        g_current_psd = addr;   /* Current PSD Addr. Set */

        if (pbc_play_list())
        {
            g_current_psd = g_previous_psd;
        }
        break;

    case SELECT_LIST_HD:      /* Selection List */
        g_current_psd = addr;   /* Current PSD Addr. Set */
        g_previous_psd = g_current_psd;

        if (pbc_selection_list())
        {
            g_current_psd = g_previous_psd;
        }
        break;

    case END_LIST_HD: /* End List */
    default:
        g_current_psd = g_psd_addr;     /* Reset PSD pointer to ID 1 */

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

    return 0;
}

/*************************************************
    Function Name:  pbc_play_list

    Purpose:    Play play list.

    Theory:     Gets and processes the play item number
                of the play list and then issues
                the play command.

    Arguments:  none

    Returns:    return status from play command

*************************************************/
USHORT pbc_play_list(void)
{
    PLAY_LIST plist;
    USHORT    pin;         /* Play Item Number */
    USHORT    ret;         /* Play Item Number */
    ULONG     msg[4];

    pbcParsePlayList(&plist, g_current_psd);


    /* if first playitem */
    /* guard against discs that have no play item in the first list */
    if ((g_scene == 1) && (plist.item_no == 0))
    {
        pbc_mode = PBC_MODE_END;

        if (plist.next_list_off != 0xFFFF)
        {
            msg[1] = KEY_NEXT_PG;
        }
        else if (plist.pre_list_off != 0xFFFF)
        {
            msg[1] = KEY_PREV_PG;
        }
        else if (plist.ret_list_off != 0xFFFF)
        {
            msg[1] = KEY_RETURN;
        }
        else
        {
            msg[1] = KEY_STOP;
        }

        msg[0] = MSG_KEY;
        OS_MsgQSend(queue_vcd, (char *)&msg[0], VCD_MSG_SIZE, OS_NO_WAIT, OS_MSG_PRI_NORMAL);
        return (0xFFFF);
    }


    pbc_play_item_num = 0;
    pin = plist.pin[pbc_play_item_num];        /* Get PIN */

    /* Auto Pause Set */
    pbc_apause_tim = pbc_get_waite_time(plist.pause_wait_time);

    ret = pbc_play_item(pin, plist.play_time); /* ITEM Play */

    g_scene = plist.list_id;   /* SCENE Set */

    DbgPrint(("playlist\ng_scene = 0x%X\n", g_scene));

    return (ret);
}

/*************************************************
    Function Name:  pbc_list_selection

    Purpose:    Play selection list.

    Theory:     Gets and processes the play item number
                of the selection list and then issues
                the play command.

    Arguments:  none

    Returns:    return status from play command

*************************************************/
USHORT pbc_selection_list(void)
{
    SELECT_LIST slist;
    USHORT pin;         /* Play Item Number */
    USHORT ret;         /* Play Item Number */

    DbgPrint(("CALLED %s\n", __FUNCTION__ ));

    pbcParseSelectList(&slist, g_current_psd);

    pbc_loop_count = (slist.loop_jump & 0x7F); /* Loop Count Set */
    pbc_jump_key = 0x00;        /* Jump Timing Key */

    pbc_apause_tim = 0x00;      /* Auto Pause Clear */

    pin = slist.pin;   /* Get PIN */

    DbgPrint(("pin = 0x%X\n", pin));

    ret = pbc_play_item(pin, PLY_TIM_EOF);      /* ITEM Play */

    g_scene = slist.list_id;   /* SCENE Set */

    DbgPrint(("selectionlist\ng_scene = 0x%X\n", g_scene));

    return (ret);
}

/*************************************************
    Function Name:  pbc_play_item

    Purpose:    Determine the right play mode.

    Theory:     Takes the play item number and determines
                what type of navigation is necessary.

    Arguments:  play item number, play time

    Returns:    return code from play command

*************************************************/
USHORT pbc_play_item(USHORT pin, USHORT ptime)
{
    USHORT ret = OS_OK;
    ULONG  msg[4];

    DbgPrint(("pin=%i, ptime=%i\n", pin, ptime));

    cdda_track = 0;

    if ((1 < pin) && (pin < 100))
    {   /* Track Play */
        g_track = (UBYTE)(pin);
        ret = pbc_track_play(pin, ptime);
    }
    else if ((99 < pin) && (pin < 600))
    {   /* Entry Play */
        ret = pbc_entry_play(pin - 99, ptime);
    }
    else if ((999 < pin) && (pin < 2980))
    {
        /* Segment Play */
        pbc_seg_play(pin - 999);
    }
    else if ((pin == 0) || (pin == 1))
    {
        /* Play Nothing */
        if (pbc_end_flag == 0)
        {
            pbc_mode = PBC_MODE_PLAY;
            msg[0] = MSG_PLAY_END;
            OS_MsgQSend(queue_vcd, (char *)&msg[0], VCD_MSG_SIZE, OS_NO_WAIT, OS_MSG_PRI_NORMAL);
            ret = 0;
            pbc_end_flag = 1;