pgc_play.cpp

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

        case PGC_LOOP_COUNT:
#if DBG_ON(DBG_VERBOSE)
            DbgPrint(("pgc_play() - case PGC_LOOP_COUNT\n"));
#endif
            /* Since button command may be executed in last VOBU of the */
            /* last cell of PGC, change_hl_forbidden should be cleared  */
            change_hl_forbidden = 0;

            if (pg_repeat_count--)
            {
                if (playback_mode == PG_RANDOM)
                {
                    /* request new program */
                    next_pgn = 1 + rand() % (pgc_gi.pgc_cnt[2] & 0x7f);
                    next_cell = pgc_pgmap[next_pgn - 1];

                    reset_scr_flag = 0x05;

                    vob_init();
                    cell_play(1);
                }
                else
                {
                    UBYTE temp_pgn;
                    USHORT k;

                    /* Request new program */

                    temp_pgn = next_pgn;

                    /* Random select a program which has not been presented */
                    do
                    {
                        temp_pgn = 1 + rand() % (pgc_gi.pgc_cnt[2] & 0x7f);
                        for (k = 0; k < num_of_sh_stored; k++)
                        {
                            if (temp_pgn == shuffle_list[k])
                            {
                                break;
                            }
                        }

                    } while (k != num_of_sh_stored);

                    shuffle_list[num_of_sh_stored++] = temp_pgn;
                    next_pgn = temp_pgn;
                    next_cell = pgc_pgmap[next_pgn - 1];

                    reset_scr_flag = 0x05;

                    cell_play(1);
                    if ((pgc_gi.pgc_cnt[2] & 0x7f) == num_of_sh_stored)
                    {
                        for (i = 0; i < num_of_sh_stored; i++)
                        {
                            shuffle_list[i] = 0;
                        }
                        num_of_sh_stored = 0;
                    }
                }
                return;
            }
            else
            {
                pgc_mode = PGC_POST_CMD;
                break;
            }

          case PGC_STILL:
#if DBG_ON(DBG_VERBOSE)
            DbgPrint(("pgc_play() - case PGC_STILL\n"));
#endif
            if (pgc_gi.pgc_nv_ctl.still_time_value != 255)
            {
                /* set navigation time to resume and go to PGC_POST_CMD phase */
            }
            return;

        case PGC_POST_CMD:
#if DBG_ON(DBG_VERBOSE)
            DbgPrint(("pgc_play() - case PGC_POST_CMD\n"));
#endif
            /* Since button command may be executed in last VOBU of the */
            /* last cell of PGC, change_hl_forbidden should be cleared  */
            change_hl_forbidden = 0;

            /* execute any cmds at the end of PGC after cell presentation */
            pgc_mode = PGC_NXT_LNK;     /* next unless jump */

            if (nav_suspend_flag)
            {
                nav_suspend_flag = FALSE;
                cmd_index = resume_cmd_index;
            }
            else
            {
                cmd_index = 0;
            }

            while (cmd_index < pgc_cmdti.post_cmd_n)
            {
                if (fKillNavTasks == TRUE)
                {
                    return;
                }

                if (OS_MsgQNumMsgs(queue_nav) == 80)
                {
                    OS_MsgQReset(queue_nav);
                }

                nav_cmd = dvd_cmd((UBYTE *) & post_cmd_buff[cmd_index++][0], POST_CMD);

#if DBG_ON(DBG_VERBOSE)
                DbgPrint(("pgc_play() - after call nav_cmd\n"));
#endif

                if ((nav_cmd & 0xff00) == NAV_STOP)
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play.cpp, Line %d, Set pgc_mode to PGC_STOP\n", __LINE__));
#endif
                    pgc_mode = PGC_STOP;
                    break;
                }

                if ((nav_cmd & 0xff00) == NAV_PRE_CMD)
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- pgc_mode = PGC_PRE_CMD\n"));
#endif
                    pgc_mode = PGC_PRE_CMD;
                    break;
                }

                if ((nav_cmd & 0xff00) == NAV_POST_CMD)
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- pgc_mode = PGC_POST_CMD\n"));
#endif
                    pgc_mode = PGC_POST_CMD;
                    break;
                }

                if ((nav_cmd & 0xff00) == NAV_BRANCH)   /* execute new program chain */
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- pgc_init\n"));
#endif
                    pgc_init();
                    break;
                }

                if ((nav_cmd & 0xff00) == NAV_BREAK)
                {
                    /* terminate post-command phase and proceed with next link phase */
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- NAV_BREAK\n"));
#endif
                    break;
                }

                if ((nav_cmd & 0xff00) == NAV_LOOP_COUNT)
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- pgc_mode = PGC_LOOP_COUNT\n"));
#endif
                    pgc_mode = PGC_LOOP_COUNT;
                    break;
                }

                if (((nav_cmd & 0xff00) == NAV_PGC_PT_INIT) || ((nav_cmd & 0xff00) == NAV_CELL_PLAY))
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- pgc_mode = PGC_PT_INIT\n"));
#endif
                    pgc_mode = PGC_PT_INIT;
                    break;
                }

                if ((nav_cmd & 0xff00) == NAV_GOTO)
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- NAV_GOTO\n"));
#endif
                    cmd_index = (nav_cmd & 0xff) - 1;
                }

                if ((nav_cmd & 0xff00) == NAV_SUSPEND)
                {
#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play() -- NAV_SUSPEND\n"));
#endif
                    nav_suspend_flag = TRUE;
                    pgc_mode = PGC_POST_CMD;
                    suspending_cmd_index = cmd_index;
                    return;
                }
            }
            break;

          case PGC_NXT_LNK:
#if DBG_ON(DBG_VERBOSE)
              DbgPrint(("pgc_play() - case PGC_NXT_LNK\n"));
#endif
            if (pgc_gi.pgc_nv_ctl.next_pgcn)
            {
                USHORT tt;
                UBYTE vts_ttn, ttn;

                next_pgcn = pgc_gi.pgc_nv_ctl.next_pgcn;

                /* pgc_domain = TT_PGC; */
                retval = parse_pgci(&next_pgcn);
                if (retval)
                {
#if LOADER_ERROR_RECOVER == TRUE
                    if ((0xff != retval) && !parental_prohibit)
                    {
                        disc_error_flag = 1;
                    }
#endif

#if DBG_ON(DBG_VERBOSE)
                    DbgPrint(("pgc_play.cpp, Line %d, Set pgc_mode to PGC_STOP\n", __LINE__));
#endif
                    pgc_mode = PGC_STOP;
                    break;
                }

                vts_ttn = (vts_pgci_srp[next_pgcn - 1].vts_pgc_cat[0] & 0x7f);

                /* Get ttn for NEXT_PGCN */
                for (tt = 0; tt < tt_srpti.tt_srp_n; tt++)
                {
                    if (tt_srp[tt].vts_ttn == vts_ttn && tt_srp[tt].vtsn == next_vtsn)
                    {
                        break;
                    }
                }

                ttn = tt + 1;

                next_pgn = ptt_srp[vts_ttn - 1][0].pgn;
                next_cell = pgc_pgmap[next_pgn - 1];

                set_sprm(SPRM_TTN_TT_DOM, ttn);
                set_sprm(SPRM_TT_PGCN_TT_DOM, next_pgcn);
                set_sprm(SPRM_VTS_TTN_TT_DOM, vts_ttn);

                pgc_init();
            }
            else
            {
#if DBG_ON(DBG_VERBOSE)
                DbgPrint(("pgc_play: (pgc_gi.pgc_nv_ctl.next_pgcn == 0)\n"));
                DbgPrint(("pgc_play.cpp, Line %d, Set pgc_mode to PGC_STOP\n", __LINE__));
#endif
                pgc_mode = PGC_STOP;
            }
            break;
        }
    }

} /* end of pgc_play() */


/**
 *   Name:           update_playback_mode
 *
 *   Description:    update playback_mode, get here after the pgc has been parsed
 *
 *   Arguments:      None
 *
 *   Returns:        None
 *
 *   Structures:
 *
 *   Pseudocode:
 *
 *   Functionality:
 *
 *   Theory of Operation:
 *
 */
void update_playback_mode(void)
{
    UBYTE pg_pb_mode;   /* PG Playback mode from PGC_NV_CTL */

    /* determine the PG playback mode of this PGC */
    pg_pb_mode = pgc_gi.pgc_nv_ctl.pg_playback_mode;
    if (pg_pb_mode == 0)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("update_playback_mode: PG_SEQUENTIAL\n"));
        playback_mode = PG_SEQUENTIAL;
    }
    else
    {
        if (pg_pb_mode < 0x80)
        {
            DBGPRINT(DBG_ON(DBG_TRACE), ("update_playback_mode: PG_RANDOM\n"));
            playback_mode = PG_RANDOM;
        }
        else
        {
            DBGPRINT(DBG_ON(DBG_TRACE), ("update_playback_mode: PG_SHUFFLE\n"));
            playback_mode = PG_SHUFFLE;
        }
        pg_repeat_count = pg_pb_mode &= 0x7F;
    }
}

/**
 *  Name:           pgc_init
 *
 *  Description:    get here after the pgc has been parsed
 *
 *  Arguments:
 *
 *  Returns:
 *
 *  Structures:
 *
 *  Pseudocode:
 *
 *  Functionality:
 *
 *  Theory of Operation:
 */
static void pgc_init(void)
{
    unsigned i;

    pgc_mode = PGC_PRE_CMD;

    update_playback_mode();

    if (vmgi_mat.fp_pgci_sa == 0)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("pgc_init: (vmgi_mat.fp_pgci_sa == 0)\n"));

        pgc_mode = PGC_STOP;
        for (i = 0; i < 4; i++)
        {
            pgc_gi.pgc_uop_ctl[i] = nvpck[CURRENT].pci_gi.vobu_uop_ctl[i] = 0x00;
        }
    }
}

/**
 *   Name:           vob_init
 *
 *   Description:    get here to initialize presentation of a VOB
 *
 *   Arguments:
 *
 *   Returns:
 *
 *   Structures:
 *
 *   Pseudocode:
 *
 *   Functionality:  We get here if a VOB exists and we are starting the
 *    program presentation phase of PGC playback.
 *
 *   Theory of Operation:
 *    Convert PGC_AST_CTLT in PGCI to decoding audio stream no. from SPRM(1).
 *    Extract audio coding mode from VTS_AST_ATRT if TT_DOM, VMGM_AST_ATR if
 *    VMGM_DOM or VTSM_AST_ATR if VTSM_DOM.
 *    Convert SPSTN by language (SPRM(18) & SPRM(19)) as well as aspect ratio
 *    (SPRM(14).
 */
void vob_init(void)
{
    UBYTE astn            = 0;
    UBYTE *a_atr          = NULL;
    UBYTE *v_atr          = NULL;
    UBYTE spstn           = 0;
    UBYTE n_spst;
    UBYTE n_ast;
    UBYTE cell_still_time = 0;
    UBYTE *sp_plt         = NULL;

    UBYTE sysparam_value[2];

    DBGPRINT(DBG_ON(DBG_TRACE), ("vob_init\n"));

    sysparam_value[0] = (get_sprm(SPRM_P_CFG_VID) & 0xff00) >> 8;

    nv_pck_ready = 0;

    switch (pgc_domain)
    {
    case VMGM_PGC:    /* video manager menu PGC */
        a_atr = (UBYTE *) (&(vmgi_mat.vmgm_ast_atr[0]));
        v_atr = (UBYTE *) (&(vmgi_mat.vmgm_v_atr[0]));
        a_drc_fs = vmgi_mat.vmgm_ast_atr[1];

        /* select correct SP stream ID based on aspect ratio & display mode */
        if ((vmgi_mat.vmgm_v_atr[0] & ASPECT_RATIO_MASK) == RATIO_4_3)
        {
            DBGPRINT(DBG_ON(DBG_TRACE), ("which_sp: 4:3 aspect ratio\n"));
            which_sp = 0;       /* 4:3 aspect ratio */
        }
        else
        {
            /* 16:9 aspect ratio */
            if ((sysparam_value[0] & 0x0c) == 0x0c)     /* user TV 16:9 */
            {
                DBGPRINT(DBG_ON(DBG_TRACE), ("which_sp: Wide\n"));
                which_sp = 1;   /* Wide */
            }
            else        /* user TV 4:3 */
            {
                if ((vmgi_mat.vmgm_v_atr[0] & DISPLAY_MODE) == PAN_SCAN_AND_LETTERBOX)
                {
                    if ((sysparam_value[0] & 0x03) == 0x01)     /* pan & scan */
                    {
                        DBGPRINT(DBG_ON(DBG_TRACE), ("which_sp: Pan & Scan\n"));
                        which_sp = 3;   /* Pan & Scan */
                    }
                    else
                    {
                        DBGPRINT(DBG_ON(DBG_TRACE), ("which_sp: LetterBox\n"));
                        which_sp = 2;   /* LetterBox */
                    }
                }
                else if ((vmgi_mat.vmgm_v_atr[0] & DISPLAY_MODE) == PAN_SCAN_ONLY)
                {
                    DBGPRINT(DBG_ON(DBG_TRACE), ("which_sp: Pan & Scan\n"));
                    which_sp = 3;       /* Pan & Scan */
                }