libdvdread/cmd_print.c

   1 /* -*- c-basic-offset: 2; indent-tabs-mode: nil -*- */
   2 /*
   3  * Copyright (C) 2000, 2001, 2002, 2003 Martin Norbäck, Håkan Hjort
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "config.h"
  21
  22 #include <stdio.h>
  23 #include <ctype.h>
  24
  25 #if defined(HAVE_INTTYPES_H)
  26 #include <inttypes.h>
  27 #elif defined(HAVE_STDINT_H)
  28 #include <stdint.h>
  29 #endif
  30
  31 #include "cmd_print.h"
  32
  33
  34 typedef struct
  35 {
  36   uint8_t bits[8];
  37   uint8_t examined[8];
  38 } cmd_t;
  39
  40
  41 static const char *cmp_op_table[] = {
  42   NULL, "&", "==", "!=", ">=", ">", "<=", "<"
  43 };
  44 static const char *set_op_table[] = {
  45   NULL, "=", "<->", "+=", "-=", "*=", "/=", "%=", "rnd", "&=", "|=", "^="
  46 };
  47
  48 static const char *link_table[] = {
  49   "LinkNoLink",  "LinkTopC",    "LinkNextC",   "LinkPrevC",
  50   NULL,          "LinkTopPG",   "LinkNextPG",  "LinkPrevPG",
  51   NULL,          "LinkTopPGC",  "LinkNextPGC", "LinkPrevPGC",
  52   "LinkGoUpPGC", "LinkTailPGC", NULL,          NULL,
  53   "RSM"
  54 };
  55
  56 static const char *system_reg_table[] = {
  57   "Menu Description Language Code",
  58   "Audio Stream Number",
  59   "Sub-picture Stream Number",
  60   "Angle Number",
  61   "Title Track Number",
  62   "VTS Title Track Number",
  63   "VTS PGC Number",
  64   "PTT Number for One_Sequential_PGC_Title",
  65   "Highlighted Button Number",
  66   "Navigation Timer",
  67   "Title PGC Number for Navigation Timer",
  68   "Audio Mixing Mode for Karaoke",
  69   "Country Code for Parental Management",
  70   "Parental Level",
  71   "Player Configurations for Video",
  72   "Player Configurations for Audio",
  73   "Initial Language Code for Audio",
  74   "Initial Language Code Extension for Audio",
  75   "Initial Language Code for Sub-picture",
  76   "Initial Language Code Extension for Sub-picture",
  77   "Player Regional Code",
  78   "Reserved 21",
  79   "Reserved 22",
  80   "Reserved 23"
  81 };
  82
  83 static const char *system_reg_abbr_table[] = {
  84   NULL,
  85   "ASTN",
  86   "SPSTN",
  87   "AGLN",
  88   "TTN",
  89   "VTS_TTN",
  90   "TT_PGCN",
  91   "PTTN",
  92   "HL_BTNN",
  93   "NVTMR",
  94   "NV_PGCN",
  95   NULL,
  96   "CC_PLT",
  97   "PLT",
  98   NULL,
  99   NULL,
 100   NULL,
 101   NULL,
 102   NULL,
 103   NULL,
 104   NULL,
 105   NULL,
 106   NULL,
 107   NULL,
 108 };
 109
 110
 111
 112 static unsigned int bits(cmd_t *cmd, int byte, int bit, int count) {
 113   unsigned int val = 0;
 114   unsigned int bit_mask;
 115
 116   while(count--) {
 117     if(bit > 7) {
 118       bit = 0;
 119       byte++;
 120     }
 121     bit_mask = 0x01 << (7-bit);
 122     val <<= 1;
 123     if((cmd->bits[byte]) & bit_mask)
 124       val |= 1;
 125     cmd->examined[byte] |= bit_mask;
 126     bit++;
 127   }
 128   return val;
 129 }
 130
 131
 132 static void print_system_reg(unsigned int reg) {
 133   if(reg < sizeof(system_reg_abbr_table) / sizeof(char *))
 134     fprintf(stdout, system_reg_table[reg]);
 135   else
 136     fprintf(stdout, " WARNING: Unknown system register ");
 137 }
 138
 139 static void print_reg(unsigned int reg) {
 140   if(reg & 0x80)
 141     print_system_reg(reg & 0x7f);
 142   else
 143     if(reg < 16)
 144       fprintf(stdout, "g[%u]", reg);
 145     else
 146       fprintf(stdout, " WARNING: Unknown general register ");
 147 }
 148
 149 static void print_cmp_op(unsigned int op) {
 150   if(op < sizeof(cmp_op_table) / sizeof(char *) && cmp_op_table[op] != NULL)
 151     fprintf(stdout, " %s ", cmp_op_table[op]);
 152   else
 153     fprintf(stdout, " WARNING: Unknown compare op ");
 154 }
 155
 156 static void print_set_op(unsigned int op) {
 157   if(op < sizeof(set_op_table) / sizeof(char *) && set_op_table[op] != NULL)
 158     fprintf(stdout, " %s ", set_op_table[op]);
 159   else
 160     fprintf(stdout, " WARNING: Unknown set op ");
 161 }
 162
 163 static void print_reg_or_data(cmd_t *cmd, unsigned int immediate, int byte) {
 164   if(immediate) {
 165     int i = bits(cmd,byte,0,16);
 166
 167     fprintf(stdout, "0x%x", i);
 168     if(isprint(i & 0xff) && isprint((i>>8) & 0xff))
 169       fprintf(stdout, " (\"%c%c\")", (char)((i>>8) & 0xff), (char)(i & 0xff));
 170   } else {
 171     print_reg(bits(cmd,byte + 1,0,8));
 172   }
 173 }
 174
 175 static void print_reg_or_data_2(cmd_t *cmd, unsigned int immediate, int byte) {
 176   if(immediate)
 177     fprintf(stdout, "0x%x", bits(cmd,byte,1,7));
 178   else
 179     fprintf(stdout, "g[%u]", bits(cmd,byte,4,4));
 180 }
 181
 182 static void print_if_version_1(cmd_t *cmd) {
 183   unsigned int op = bits(cmd,1,1,3);
 184
 185   if(op) {
 186     fprintf(stdout, "if (");
 187     print_reg(bits(cmd,3,0,8));
 188     print_cmp_op(op);
 189     print_reg_or_data(cmd,bits(cmd,1,0,1), 4);
 190     fprintf(stdout, ") ");
 191   }
 192 }
 193
 194 static void print_if_version_2(cmd_t *cmd) {
 195   unsigned int op = bits(cmd,1,1,3);
 196
 197   if(op) {
 198     fprintf(stdout, "if (");
 199     print_reg(bits(cmd,6,0,8));
 200     print_cmp_op(op);
 201     print_reg(bits(cmd,7,0,8));
 202     fprintf(stdout, ") ");
 203   }
 204 }
 205
 206 static void print_if_version_3(cmd_t *cmd) {
 207   unsigned int op = bits(cmd,1,1,3);
 208
 209   if(op) {
 210     fprintf(stdout, "if (");
 211     print_reg(bits(cmd,2,0,8));
 212     print_cmp_op(op);
 213     print_reg_or_data(cmd,bits(cmd,1,0,1), 6);
 214     fprintf(stdout, ") ");
 215   }
 216 }
 217
 218 static void print_if_version_4(cmd_t *cmd) {
 219   unsigned int op = bits(cmd,1,1,3);
 220
 221   if(op) {
 222     fprintf(stdout, "if (");
 223     print_reg(bits(cmd,1,4,4));
 224     print_cmp_op(op);
 225     print_reg_or_data(cmd,bits(cmd,1,0,1), 4);
 226     fprintf(stdout, ") ");
 227   }
 228 }
 229
 230 static void print_if_version_5(cmd_t *cmd) {
 231   unsigned int op = bits(cmd,1,1,3);
 232
 233   if(op) {
 234     fprintf(stdout, "if (");
 235     print_reg(bits(cmd,4,0,8));
 236     print_cmp_op(op);
 237     print_reg(bits(cmd,5,0,8));
 238     fprintf(stdout, ") ");
 239   }
 240 }
 241
 242 static void print_special_instruction(cmd_t *cmd) {
 243   unsigned int op = bits(cmd,1,4,4);
 244
 245   switch(op) {
 246   case 0: // NOP
 247     fprintf(stdout, "Nop");
 248     break;
 249   case 1: // Goto line
 250     fprintf(stdout, "Goto %u", bits(cmd,7,0,8));
 251     break;
 252   case 2: // Break
 253     fprintf(stdout, "Break");
 254     break;
 255   case 3: // Parental level
 256     fprintf(stdout, "SetTmpPML %u, Goto %u",
 257             bits(cmd,6,4,4), bits(cmd,7,0,8));
 258     break;
 259   default:
 260     fprintf(stdout, "WARNING: Unknown special instruction (%u)",
 261             bits(cmd,1,4,4));
 262   }
 263 }
 264
 265 static void print_linksub_instruction(cmd_t *cmd) {
 266   unsigned int linkop = bits(cmd,7,3,5);
 267   unsigned int button = bits(cmd,6,0,6);
 268
 269   if(linkop < sizeof(link_table)/sizeof(char *) && link_table[linkop] != NULL)
 270     fprintf(stdout, "%s (button %u)", link_table[linkop], button);
 271   else
 272     fprintf(stdout, "WARNING: Unknown linksub instruction (%u)", linkop);
 273 }
 274
 275 static void print_link_instruction(cmd_t *cmd, int optional) {
 276   unsigned int op = bits(cmd,1,4,4);
 277
 278   if(optional && op)
 279     fprintf(stdout, ", ");
 280
 281   switch(op) {
 282   case 0:
 283     if(!optional)
 284       fprintf(stdout, "WARNING: NOP (link)!");
 285     break;
 286   case 1:
 287     print_linksub_instruction(cmd);
 288     break;
 289   case 4:
 290     fprintf(stdout, "LinkPGCN %u", bits(cmd,6,1,15));
 291     break;
 292   case 5:
 293     fprintf(stdout, "LinkPTT %u (button %u)",
 294             bits(cmd,6,6,10), bits(cmd,6,0,6));
 295     break;
 296   case 6:
 297     fprintf(stdout, "LinkPGN %u (button %u)",
 298             bits(cmd,7,1,7), bits(cmd,6,0,6));
 299     break;
 300   case 7:
 301     fprintf(stdout, "LinkCN %u (button %u)",
 302             bits(cmd,7,0,8), bits(cmd,6,0,6));
 303     break;
 304   default:
 305     fprintf(stdout, "WARNING: Unknown link instruction");
 306   }
 307 }
 308
 309 static void print_jump_instruction(cmd_t *cmd) {
 310   switch(bits(cmd,1,4,4)) {
 311   case 1:
 312     fprintf(stdout, "Exit");
 313     break;
 314   case 2:
 315     fprintf(stdout, "JumpTT %u", bits(cmd,5,1,7));
 316     break;
 317   case 3:
 318     fprintf(stdout, "JumpVTS_TT %u", bits(cmd,5,1,7));
 319     break;
 320   case 5:
 321     fprintf(stdout, "JumpVTS_PTT %u:%u", bits(cmd,5,1,7), bits(cmd,2,6,10));
 322     break;
 323   case 6:
 324     switch(bits(cmd,5,0,2)) {
 325     case 0:
 326       fprintf(stdout, "JumpSS FP");
 327       break;
 328     case 1:
 329       fprintf(stdout, "JumpSS VMGM (menu %u)", bits(cmd,5,4,4));
 330       break;
 331     case 2:
 332       fprintf(stdout, "JumpSS VTSM (vts %u, title %u, menu %u)",
 333               bits(cmd,4,0,8), bits(cmd,3,0,8), bits(cmd,5,4,4));
 334       break;
 335     case 3:
 336       fprintf(stdout, "JumpSS VMGM (pgc %u)", bits(cmd,2,1,15));
 337       break;
 338     }
 339     break;
 340   case 8:
 341     switch(bits(cmd,5,0,2)) {
 342     case 0:
 343       fprintf(stdout, "CallSS FP (rsm_cell %u)",
 344               bits(cmd,4,0,8));
 345       break;
 346     case 1:
 347       fprintf(stdout, "CallSS VMGM (menu %u, rsm_cell %u)",
 348               bits(cmd,5,4,4), bits(cmd,4,0,8));
 349       break;
 350     case 2:
 351       fprintf(stdout, "CallSS VTSM (menu %u, rsm_cell %u)",
 352               bits(cmd,5,4,4), bits(cmd,4,0,8));
 353       break;
 354     case 3:
 355       fprintf(stdout, "CallSS VMGM (pgc %u, rsm_cell %u)",
 356               bits(cmd,2,1,15), bits(cmd,4,0,8));
 357       break;
 358     }
 359     break;
 360   default:
 361     fprintf(stdout, "WARNING: Unknown Jump/Call instruction");
 362   }
 363 }
 364
 365 static void print_system_set(cmd_t *cmd) {
 366   int i;
 367
 368   switch(bits(cmd,0,4,4)) {
 369   case 1: // Set system reg 1 &| 2 &| 3 (Audio, Subp. Angle)
 370     for(i = 1; i <= 3; i++) {
 371       if(bits(cmd,2+i,0,1)) {
 372         print_system_reg((unsigned int)i);
 373         fprintf(stdout, " = ");
 374         print_reg_or_data_2(cmd,bits(cmd,0,3,1), 2 + i);
 375         fprintf(stdout, " ");
 376       }
 377     }
 378     break;
 379   case 2: // Set system reg 9 & 10 (Navigation timer, Title PGC number)
 380     print_system_reg(9);
 381     fprintf(stdout, " = ");
 382     print_reg_or_data(cmd,bits(cmd,0,3,1), 2);
 383     fprintf(stdout, " ");
 384     print_system_reg(10);
 385     fprintf(stdout, " = %u", bits(cmd,5,0,8)); // ??
 386     break;
 387   case 3: // Mode: Counter / Register + Set
 388     fprintf(stdout, "SetMode ");
 389     if(bits(cmd,5,0,1))
 390       fprintf(stdout, "Counter ");
 391     else
 392       fprintf(stdout, "Register ");
 393     print_reg(bits(cmd,5,4,4));
 394     print_set_op(0x1); // '='
 395     print_reg_or_data(cmd,bits(cmd,0,3,1), 2);
 396     break;
 397   case 6: // Set system reg 8 (Highlighted button)
 398     print_system_reg(8);
 399     if(bits(cmd,0,3,1)) // immediate
 400       fprintf(stdout, " = 0x%x (button no %u)",
 401               bits(cmd,4,0,16), bits(cmd,4,0,6));
 402     else
 403       fprintf(stdout, " = g[%u]", bits(cmd,5,4,4));
 404     break;
 405   default:
 406     fprintf(stdout, "WARNING: Unknown system set instruction (%u)",
 407             bits(cmd,0,4,4));
 408   }
 409 }
 410
 411 static void print_set_version_1(cmd_t *cmd) {
 412   unsigned int set_op = bits(cmd,0,4,4);
 413
 414   if(set_op) {
 415     print_reg(bits(cmd,3,0,8));
 416     print_set_op(set_op);
 417     print_reg_or_data(cmd,bits(cmd,0,3,1), 4);
 418   } else {
 419     fprintf(stdout, "NOP");
 420   }
 421 }
 422
 423 static void print_set_version_2(cmd_t *cmd) {
 424   unsigned int set_op = bits(cmd,0,4,4);
 425
 426   if(set_op) {
 427     print_reg(bits(cmd,1,4,4));
 428     print_set_op(set_op);
 429     print_reg_or_data(cmd,bits(cmd,0,3,1), 2);
 430   } else {
 431     fprintf(stdout, "NOP");
 432   }
 433 }
 434
 435 static void print_set_version_3(cmd_t *cmd) {
 436   unsigned int set_op = bits(cmd,0,4,4);
 437
 438   if(set_op) {
 439     print_reg(bits(cmd,1,4,4));
 440     print_set_op(set_op);
 441     if(bits(cmd,0,3,1)) { // print_reg_or_data
 442       unsigned int i = bits(cmd,2,0,16);
 443
 444       fprintf(stdout, "0x%x", i);
 445       if(isprint(i & 0xff) && isprint((i>>8) & 0xff))
 446         fprintf(stdout, " (\"%c%c\")",
 447                 (char)((i>>8) & 0xff), (char)(i & 0xff));
 448     } else {
 449       print_reg(bits(cmd,2,0,8));
 450     }
 451   } else {
 452     fprintf(stdout, "NOP");
 453   }
 454 }
 455
 456 static void print_command(cmd_t *cmd) {
 457   switch(bits(cmd,0,0,3)) { /* three first bits */
 458   case 0: // Special instructions
 459     print_if_version_1(cmd);
 460     print_special_instruction(cmd);
 461     break;
 462   case 1: // Jump/Call or Link instructions
 463     if(bits(cmd,0,3,1)) {
 464       print_if_version_2(cmd);
 465       print_jump_instruction(cmd);
 466     } else {
 467       print_if_version_1(cmd);
 468       print_link_instruction(cmd,0); // must be pressent
 469     }
 470     break;
 471   case 2: // Set System Parameters instructions
 472     print_if_version_2(cmd);
 473     print_system_set(cmd);
 474     print_link_instruction(cmd,1); // either 'if' or 'link'
 475     break;
 476   case 3: // Set General Parameters instructions
 477     print_if_version_3(cmd);
 478     print_set_version_1(cmd);
 479     print_link_instruction(cmd,1); // either 'if' or 'link'
 480     break;
 481   case 4: // Set, Compare -> LinkSub instructions
 482     print_set_version_2(cmd);
 483     fprintf(stdout, ", ");
 484     print_if_version_4(cmd);
 485     print_linksub_instruction(cmd);
 486     break;
 487   case 5: // Compare -> (Set and LinkSub) instructions
 488     if(bits(cmd,0,3,1))
 489       print_if_version_5(cmd);
 490     else
 491       print_if_version_1(cmd);
 492     fprintf(stdout, "{ ");
 493     print_set_version_3(cmd);
 494     fprintf(stdout, ", ");
 495     print_linksub_instruction(cmd);
 496     fprintf(stdout, " }");
 497     break;
 498   case 6: // Compare -> Set, always LinkSub instructions
 499     if(bits(cmd,0,3,1))
 500       print_if_version_5(cmd);
 501     else
 502       print_if_version_1(cmd);
 503     fprintf(stdout, "{ ");
 504     print_set_version_3(cmd);
 505     fprintf(stdout, " } ");
 506     print_linksub_instruction(cmd);
 507     break;
 508   default:
 509     fprintf(stdout, "WARNING: Unknown instruction type (%i)",
 510             bits(cmd,0,0,3));
 511   }
 512 }
 513
 514 void cmdPrint_mnemonic(vm_cmd_t *command)  {
 515   int i, extra_bits;
 516   cmd_t cmd;
 517
 518   for(i = 0; i < 8; i++) {
 519     cmd.bits[i] = command->bytes[i];
 520     cmd.examined[i] = 0;
 521   }
 522
 523   print_command(&cmd);
 524
 525   // Check if there still are bits set that were not examined
 526   extra_bits = 0;
 527   for(i = 0; i < 8; i++)
 528     if(cmd.bits[i] & ~ cmd.examined[i]) {
 529       extra_bits = 1;
 530       break;
 531     }
 532   if(extra_bits) {
 533     fprintf(stdout, " [WARNING, unknown bits:");
 534     for(i = 0; i < 8; i++)
 535       fprintf(stdout, " %02x", cmd.bits[i] & ~ cmd.examined[i]);
 536     fprintf(stdout, "]");
 537   }
 538 }
 539
 540 void cmdPrint_CMD(int row, vm_cmd_t *command) {
 541   int i;
 542
 543   fprintf(stdout, "(%03d) ", row + 1);
 544   for(i = 0; i < 8; i++)
 545     fprintf(stdout, "%02x ", command->bytes[i]);
 546   fprintf(stdout, "| ");
 547
 548   cmdPrint_mnemonic(command);
 549   fprintf(stdout, "\n");
 550 }