cmdproc_debug.cpp

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

/*****************************************************************************
******************************************************************************
**                                                                          **
**  Copyright (c) 2005-2006 Videon Central, Inc.                            **
**  All rights reserved.                                                    **
**                                                                          **
**  The computer program contained herein contains proprietary information  **
**  which is the property of Videon Central, Inc.  The program may be used  **
**  and/or copied only with the written permission of Videon Central, Inc.  **
**  or in accordance with the terms and conditions stipulated in the        **
**  agreement/contract under which the programs have been supplied.         **
**                                                                          **
******************************************************************************
*****************************************************************************/
/**
 * @file cmdproc_debug.cpp
 *
 * dump cmdproc cmds to text as we get them
 *
 * $Id: cmdproc_debug.cpp,v 1.6 2006/11/07 16:07:36 mspinnenweber Exp $
 */

#include <stdlib.h>
#include <time.h>
#include "vdvd_types.h"
#include "navcmd.h"
#include "cmdproc.h"
#include "cmdproc_types.h"
#include "../mvobjdb.h"
#include "../playctrl/playctrl.h"
#include "dbgprint.h"

/* nav cmd defines */
/* groups */
#define GROUP_BRANCH    0
#define GROUP_COMPARE   1
#define GROUP_SET       2

/* subgroups */
#define SUBGROUP_GOTO   0
#define SUBGROUP_JUMP   1
#define SUBGROUP_PLAY   2

/* branch group, goto subgoup */
#define BR_NOP      0
#define BR_GOTO     1
#define BR_BREAK    2

/* branch group, jump subgoup */
#define BR_JUMPOBJ      0
#define BR_JUMPTITLE    1
#define BR_CALLOBJ      2
#define BR_CALLTITLE    3
#define BR_RESUME       4

/* branch group, play subgoup */
#define BR_PLAYPL   0
#define BR_PLatPI   1
#define BR_PLatMK   2
#define BR_TERMPL   3
#define BR_LINKPI   4
#define BR_LINKMK   5

/* compare group */
#define CM_BC       1
#define CM_EQ       2
#define CM_NE       3
#define CM_GE       4
#define CM_GT       5
#define CM_LE       6
#define CM_LT       7

/* set cmd option */
#define SET_GRP     0
#define SET_SYSTEM  1

/* set command group */
#define SET_MOVE    1
#define SET_SWAP    2
#define SET_ADD     3
#define SET_SUB     4
#define SET_MUL     5
#define SET_DIV     6
#define SET_MOD     7
#define SET_RND     8
#define SET_AND     9
#define SET_OR      10
#define SET_XOR     11
#define SET_BITSET  12
#define SET_BITCLR  13
#define SET_SHL     14
#define SET_SHR     15

/* set system command */
#define SET_STREAM  1
#define SET_NVTIMER 2
#define SET_BTNPG   3
#define SET_ENBTN   4
#define SET_DISBTN  5
#define SET_SECSTM  6
#define SET_POPOFF  7
#define SET_STLON   8
#define SET_STLOFF  9
#define SET_RESV10  10
#define SET_RESV11  11


static ULONG  DebugNavCmdGetRegisterValue(ULONG ulOperand, int PSR);

int NavToText(MVOBJ_NAV_COMMAND *Cmd)
{
    const int STRING_SIZE=500;
    char CurString[STRING_SIZE] ={0};
    int OpCount;
    int CmdGroup;
    int CmdSubGroup;
    int FlagOpOne;
    int FlagOpTwo;
    int BranchOption;
    int CompareOption;
    int SetOption;
    ULONG CurCmd[3];
    char tempstring[50];
    int RegFlag;
    int RegNum;

    memset(CurString, 0, STRING_SIZE);

    /* do some byte swapping here to get it into a good position for parsing */
    memcpy(CurCmd, Cmd, sizeof(MVOBJ_NAV_COMMAND));

#if 0
    /* byte swap */
    for (int b=0; b<3; b++)
    {
        Temp = ((CurCmd[b] & 0xFF000000) >> 24) |
                   ((CurCmd[b] & 0x00FF0000) >> 8) |
                   ((CurCmd[b] & 0x0000FF00) << 8) |
                   ((CurCmd[b] & 0x000000FF) << 24);
            CurCmd[b] = Temp;
        }
#endif

    /* load the first ulong's worth */
    OpCount = (CurCmd[0] & 0xE0000000) >> 29;
    CmdGroup = (CurCmd[0] & 0x18000000) >> 27;
    CmdSubGroup = (CurCmd[0] & 0x07000000) >> 24;

    FlagOpOne = (CurCmd[0] & 0x00800000) >> 23;
    FlagOpTwo = (CurCmd[0] & 0x00400000) >> 22;
    BranchOption = (CurCmd[0] & 0x000F0000) >> 16;

    CompareOption = (CurCmd[0] & 0x00000F00) >> 8;
    SetOption = CurCmd[0] & 0x1F;

    /* check the command group */
    if (CmdGroup == 0)  //branch
    {
        strcat(CurString, "BRANCH ");

        switch (CmdSubGroup)
        {
            case SUBGROUP_GOTO:

                /* the goto subgroup */
                switch (BranchOption)
                {
                    case BR_NOP:
                        strcat(CurString, "NOP ");
                        break;
                    case BR_GOTO:
                        sprintf(tempstring, "GoTo Cmd ID %d ", CurCmd[1]);
                        strcat(CurString, tempstring);
                        break;
                    case BR_BREAK:
                        strcat(CurString, "Break ");
                        break;
                    default:
                        strcat(CurString, "(Invalid Goto Subgroup) ");
                        break;
                }

                break;

            case SUBGROUP_JUMP:

                switch(BranchOption)
                {
                    case BR_JUMPOBJ:
                        sprintf(tempstring, "Jump Obj %d ", CurCmd[1]);
                        strcat(CurString, tempstring);
                        break;
                    case BR_JUMPTITLE:
                        sprintf(tempstring, "Jump Title %d ", CurCmd[1]);
                        strcat(CurString, tempstring);
                        break;
                    case BR_CALLOBJ:
                        sprintf(tempstring, "Call Obj %d ", CurCmd[1]);
                        strcat(CurString, tempstring);
                        break;
                    case BR_CALLTITLE:
                        sprintf(tempstring, "Call Title %d ", CurCmd[1]);
                        strcat(CurString, tempstring);
                        break;
                    case BR_RESUME:
                        strcat(CurString, "Resume ");
                        break;
                    default:
                        strcat(CurString, "invalid BranchOption ");
                        DbgPrint(("invalid BranchOption\n"));
                        break;
                }
                break;

            case SUBGROUP_PLAY:
                strcat(CurString, "Play ");

                switch(BranchOption)
                {
                    case BR_PLAYPL:
                        if (OpCount == 1)
                        {
                            sprintf(tempstring, "Play Playlist %05d.mpls ", CurCmd[1]);
                            strcat(CurString, tempstring);
                        }
                        else
                        {
                            DbgPrint(("error bad opcount in branch play playlist cmd\n"));
                            return -1;
                        }
                        break;
                    case BR_PLatPI:
                        if (OpCount == 2)
                        {
                            sprintf(tempstring, "Play Playlist %05d.mpls at Playitem %d ", CurCmd[1], CurCmd[2]);
                            strcat(CurString, tempstring);
                        }
                        else
                        {
                            DbgPrint(("error bad opcount in branch play playlist at playitem\n"));
                            return -1;
                        }
                        break;
                    case BR_PLatMK:
                        if (OpCount == 2)
                        {
                            sprintf(tempstring, "Play Playlist %05d.mpls at Playmark %d ", CurCmd[1], CurCmd[2]);
                            strcat(CurString, tempstring);
                        }
                        else
                        {
                            DbgPrint(("error bad opcount in branch play playlist at playmark\n"));
                            return -1;
                        }
                        break;
                    case BR_TERMPL:
                        strcat(CurString, "Terminate Playlist");
                        break;
                    case BR_LINKPI:
                        if (OpCount == 1)
                        {
                            sprintf(tempstring, "Link Playitem %d ", CurCmd[1]);
                            strcat(CurString, tempstring);
                        }
                        else
                        {
                            DbgPrint(("error bad opcount in branch link PI\n"));
                            return -1;
                        }
                        break;
                    case BR_LINKMK:
                        if (OpCount == 1)
                        {
                            sprintf(tempstring, "Link Mark %d ", CurCmd[1]);
                            strcat(CurString, tempstring);
                        }
                        else
                        {
                            DbgPrint(("error bad opcount in branch link Mark\n"));
                            return -1;
                        }
                        break;
                    default:
                        break;
                }

                break;

            default:
                strcat(CurString, "(invalid subgroup) ");
                DbgPrint(("invalid subgroup of branch\n"));
                break;
        }
    }
    else if (CmdGroup == 1)  // compare
    {
        strcat(CurString, "COMPARE ");

        char opone[50] = {0};
        char optwo[50] = {0};

        if (OpCount != 2)
        {
            DbgPrint(("error on compare, not two operands\n"));
            return -1;
        }

        if (FlagOpOne == 0)
        {
            RegFlag = (CurCmd[1] & 0x80000000) >> 31;
            RegNum = (CurCmd[1] & 0xFFF);

            if (RegFlag == 0)
            {
                sprintf(opone, "GPR Reg %d (%d) ", RegNum, DebugNavCmdGetRegisterValue(RegNum, 0));
            }
            else if (RegFlag == 1)
            {
                sprintf(opone, "PSR Reg %d (%d) ", RegNum, DebugNavCmdGetRegisterValue(RegNum, 1));
            }
            else
            {
                DbgPrint(("Invalid register flag value\n"));
                strcat(CurString, "(Invalid register flag value) ");
            }
        }
        else
        {
            sprintf(opone, "Immediate Value 0x%x ", CurCmd[1]);
            strcat(CurString, tempstring);
        }

        /* now source register */
        if (FlagOpTwo == 0)
        {
            RegFlag = (CurCmd[2] & 0x80000000) >> 31;
            RegNum = (CurCmd[2] & 0xFFF);

            if (RegFlag == 0)
            {
                sprintf(optwo, "GPR Reg %d (%d) ", RegNum, DebugNavCmdGetRegisterValue(RegNum, 0));
            }
            else if (RegFlag == 1)
            {
                sprintf(optwo, "PSR Reg %d (%d) ", RegNum, DebugNavCmdGetRegisterValue(RegNum, 1));
            }
            else
            {
                DbgPrint(("Invalid register flag value\n"));
                strcat(optwo, "(Invalid register flag value) ");
            }
        }
        else
        {
            sprintf(optwo, "Immediate Value 0x%x", CurCmd[2]);
        }

        switch (CompareOption)
        {
            case CM_BC:
                strcat(CurString, opone);
                strcat(CurString, "Bitwise Compare ");
                strcat(CurString, optwo);
                break;
            case CM_EQ:
                strcat(CurString, opone);
                strcat(CurString, "== ");
                strcat(CurString, optwo);
                break;
            case CM_NE:
                strcat(CurString, opone);
                strcat(CurString, "!= ");
                strcat(CurString, optwo);
                break;
            case CM_GE:
                strcat(CurString, opone);
                strcat(CurString, ">= ");
                strcat(CurString, optwo);
                break;
            case CM_GT:
                strcat(CurString, opone);
                strcat(CurString, "> ");
                strcat(CurString, optwo);
                break;
            case CM_LE:
                strcat(CurString, opone);
                strcat(CurString, "<= ");
                strcat(CurString, optwo);
                break;
            case CM_LT:
                strcat(CurString, opone);
                strcat(CurString, "< ");
                strcat(CurString, optwo);
                break;
            default:
                strcat(CurString, "Invalid Compare Option ");
                DbgPrint(("invalid compare option\n"));
                break;
        }
    }
    else if (CmdGroup == 2)  // set
    {
        strcat(CurString, "SET ");

        if (CmdSubGroup == SET_GRP)
        {
            switch(SetOption)
            {
                case SET_MOVE:
                    strcat(CurString, "Move ");
                    break;
                case SET_SWAP:
                    strcat(CurString, "Swap ");
                    break;
                case SET_ADD:
                    strcat(CurString, "Add ");
                    break;
                case SET_SUB:
                    strcat(CurString, "Sub ");
                    break;
                case SET_MUL: