Mercurial > libdvdnav.hg
annotate decoder.c @ 15:74aee0b81da0 src
only one bits function now.
author | jcdutton |
---|---|
date | Wed, 10 Apr 2002 13:33:12 +0000 |
parents | ebf344d11bde |
children | e6ac0a8d9c14 |
rev | line source |
---|---|
0 | 1 /* |
2 * Copyright (C) 2000, 2001 Martin Norbäck, Håkan Hjort | |
3 * | |
4 * This file is part of libdvdnav, a DVD navigation library. It is modified | |
5 * from a file originally part of the Ogle DVD player. | |
6 * | |
7 * libdvdnav is free software; you can redistribute it and/or modify | |
8 * it under the terms of the GNU General Public License as published by | |
9 * the Free Software Foundation; either version 2 of the License, or | |
10 * (at your option) any later version. | |
11 * | |
12 * libdvdnav is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 * GNU General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU General Public License | |
18 * along with this program; if not, write to the Free Software | |
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA | |
20 * | |
21 * $Id$ | |
22 * | |
23 */ | |
24 | |
25 #ifdef HAVE_CONFIG_H | |
26 #include "config.h" | |
27 #endif | |
28 | |
29 #include <stdio.h> | |
12 | 30 #include <stdlib.h> |
0 | 31 #include <inttypes.h> |
32 #include <string.h> /* For memset */ | |
33 #include <dvdread/ifo_types.h> /* vm_cmd_t */ | |
6 | 34 #include <assert.h> |
0 | 35 #include "vmcmd.h" |
36 #include "decoder.h" | |
37 | |
15 | 38 uint32_t vm_getbits(command_t *command, int start, int count) { |
12 | 39 uint64_t result = 0; |
40 uint64_t bit_mask=0xffffffffffffffff; /* I could put -1 instead */ | |
41 uint64_t examining = 0; | |
14 | 42 int32_t bits; |
12 | 43 if (count == 0) return 0; |
0 | 44 |
12 | 45 if ( ((count+start) > 64) || |
46 (count > 32) || | |
47 (start > 63) || | |
48 (count < 0) || | |
49 (start < 0) ){ | |
15 | 50 fprintf(stderr, "Bad call to vm_getbits. Parameter out of range\n"); |
12 | 51 assert(0); |
0 | 52 } |
12 | 53 bit_mask >>= start; |
14 | 54 bits = 64-count-start; |
55 examining = ((bit_mask >> bits) << bits ); | |
12 | 56 command->examined |= examining; |
14 | 57 result = (command->instruction & bit_mask) >> bits; |
12 | 58 return (uint32_t) result; |
0 | 59 } |
60 | |
61 /* Eval register code, can either be system or general register. | |
62 SXXX_XXXX, where S is 1 if it is system register. */ | |
13 | 63 static uint16_t eval_reg(command_t* command, uint8_t reg) { |
0 | 64 if(reg & 0x80) { |
13 | 65 return command->registers->SPRM[reg & 0x1f]; /* FIXME max 24 not 32 */ |
0 | 66 } else { |
13 | 67 return command->registers->GPRM[reg & 0x0f]; |
0 | 68 } |
69 } | |
70 | |
71 /* Eval register or immediate data. | |
72 AAAA_AAAA BBBB_BBBB, if immediate use all 16 bits for data else use | |
73 lower eight bits for the system or general purpose register. */ | |
12 | 74 static uint16_t eval_reg_or_data(command_t* command, int32_t imm, int32_t byte) { |
0 | 75 if(imm) { /* immediate */ |
15 | 76 return vm_getbits(command, (byte*8), 16); |
0 | 77 } else { |
15 | 78 return eval_reg(command, vm_getbits(command, ((byte + 1)*8), 8)); |
0 | 79 } |
80 } | |
81 | |
82 /* Eval register or immediate data. | |
83 xBBB_BBBB, if immediate use all 7 bits for data else use | |
84 lower four bits for the general purpose register number. */ | |
85 /* Evaluates gprm or data depending on bit, data is in byte n */ | |
12 | 86 uint16_t eval_reg_or_data_2(command_t* command, int32_t imm, int32_t byte) { |
0 | 87 if(imm) /* immediate */ |
15 | 88 return vm_getbits(command, ((byte*8)+1), 7); |
0 | 89 else |
15 | 90 return command->registers->GPRM[vm_getbits(command, ((byte*8)+4), 4)]; |
0 | 91 } |
92 | |
93 | |
94 /* Compare data using operation, return result from comparison. | |
95 Helper function for the different if functions. */ | |
12 | 96 static int32_t eval_compare(uint8_t operation, uint16_t data1, uint16_t data2) { |
0 | 97 switch(operation) { |
98 case 1: | |
99 return data1 & data2; | |
100 case 2: | |
101 return data1 == data2; | |
102 case 3: | |
103 return data1 != data2; | |
104 case 4: | |
105 return data1 >= data2; | |
106 case 5: | |
107 return data1 > data2; | |
108 case 6: | |
109 return data1 <= data2; | |
110 case 7: | |
111 return data1 < data2; | |
112 } | |
113 fprintf(stderr,"eval_compare: Invalid comparison code\n"); | |
114 return 0; | |
115 } | |
116 | |
117 | |
118 /* Evaluate if version 1. | |
119 Has comparison data in byte 3 and 4-5 (immediate or register) */ | |
12 | 120 static int32_t eval_if_version_1(command_t* command) { |
15 | 121 uint8_t op = vm_getbits(command, 9, 3); |
0 | 122 if(op) { |
15 | 123 return eval_compare(op, eval_reg(command, vm_getbits(command, 24, 8)), |
124 eval_reg_or_data(command, vm_getbits(command, 8, 1), 4)); | |
0 | 125 } |
126 return 1; | |
127 } | |
128 | |
129 /* Evaluate if version 2. | |
130 This version only compares register which are in byte 6 and 7 */ | |
12 | 131 static int32_t eval_if_version_2(command_t* command) { |
15 | 132 uint8_t op = vm_getbits(command, 9, 3); |
0 | 133 if(op) { |
15 | 134 return eval_compare(op, eval_reg(command, vm_getbits(command, 48, 8)), |
135 eval_reg(command, vm_getbits(command, 56, 8))); | |
0 | 136 } |
137 return 1; | |
138 } | |
139 | |
140 /* Evaluate if version 3. | |
141 Has comparison data in byte 2 and 6-7 (immediate or register) */ | |
12 | 142 static int32_t eval_if_version_3(command_t* command) { |
15 | 143 uint8_t op = vm_getbits(command, 9, 3); |
0 | 144 if(op) { |
15 | 145 return eval_compare(op, eval_reg(command, vm_getbits(command, 16, 8)), |
146 eval_reg_or_data(command, vm_getbits(command, 8, 1), 6)); | |
0 | 147 } |
148 return 1; | |
149 } | |
150 | |
151 /* Evaluate if version 4. | |
152 Has comparison data in byte 1 and 4-5 (immediate or register) | |
12 | 153 The register in byte 1 is only the lowe nibble (4 bits) */ |
154 static int32_t eval_if_version_4(command_t* command) { | |
15 | 155 uint8_t op = vm_getbits(command, 9, 3); |
0 | 156 if(op) { |
15 | 157 return eval_compare(op, eval_reg(command, vm_getbits(command, 12, 4)), |
158 eval_reg_or_data(command, vm_getbits(command, 8, 1), 4)); | |
0 | 159 } |
160 return 1; | |
161 } | |
162 | |
163 /* Evaluate special instruction.... returns the new row/line number, | |
164 0 if no new row and 256 if Break. */ | |
12 | 165 static int32_t eval_special_instruction(command_t* command, int32_t cond) { |
166 int32_t line, level; | |
0 | 167 |
15 | 168 switch(vm_getbits(command, 12, 4)) { |
0 | 169 case 0: /* NOP */ |
170 line = 0; | |
171 return cond ? line : 0; | |
172 case 1: /* Goto line */ | |
15 | 173 line = vm_getbits(command, 56, 8); |
0 | 174 return cond ? line : 0; |
175 case 2: /* Break */ | |
176 /* max number of rows < 256, so we will end this set */ | |
177 line = 256; | |
178 return cond ? 256 : 0; | |
179 case 3: /* Set temporary parental level and goto */ | |
15 | 180 line = vm_getbits(command, 56, 8); |
181 level = vm_getbits(command, 52, 4); | |
0 | 182 if(cond) { |
183 /* This always succeeds now, if we want real parental protection */ | |
184 /* we need to ask the user and have passwords and stuff. */ | |
13 | 185 command->registers->SPRM[13] = level; |
0 | 186 } |
187 return cond ? line : 0; | |
188 } | |
189 return 0; | |
190 } | |
191 | |
192 /* Evaluate link by subinstruction. | |
193 Return 1 if link, or 0 if no link | |
194 Actual link instruction is in return_values parameter */ | |
12 | 195 static int32_t eval_link_subins(command_t* command, int32_t cond, link_t *return_values) { |
15 | 196 uint16_t button = vm_getbits(command, 48, 6); |
197 uint8_t linkop = vm_getbits(command, 59, 5); | |
0 | 198 |
199 if(linkop > 0x10) | |
200 return 0; /* Unknown Link by Sub-Instruction command */ | |
201 | |
202 /* Assumes that the link_cmd_t enum has the same values as the LinkSIns codes */ | |
203 return_values->command = linkop; | |
204 return_values->data1 = button; | |
205 return cond; | |
206 } | |
207 | |
208 | |
209 /* Evaluate link instruction. | |
210 Return 1 if link, or 0 if no link | |
211 Actual link instruction is in return_values parameter */ | |
12 | 212 static int32_t eval_link_instruction(command_t* command, int32_t cond, link_t *return_values) { |
15 | 213 uint8_t op = vm_getbits(command, 12, 4); |
0 | 214 |
215 switch(op) { | |
216 case 1: | |
12 | 217 return eval_link_subins(command, cond, return_values); |
0 | 218 case 4: |
219 return_values->command = LinkPGCN; | |
15 | 220 return_values->data1 = vm_getbits(command, 49, 15); |
0 | 221 return cond; |
222 case 5: | |
223 return_values->command = LinkPTTN; | |
15 | 224 return_values->data1 = vm_getbits(command, 54, 10); |
225 return_values->data2 = vm_getbits(command, 48, 6); | |
0 | 226 return cond; |
227 case 6: | |
228 return_values->command = LinkPGN; | |
15 | 229 return_values->data1 = vm_getbits(command, 57, 7); |
230 return_values->data2 = vm_getbits(command, 48, 6); | |
0 | 231 return cond; |
232 case 7: | |
233 return_values->command = LinkCN; | |
15 | 234 return_values->data1 = vm_getbits(command, 56, 8); |
235 return_values->data2 = vm_getbits(command, 48, 6); | |
0 | 236 return cond; |
237 } | |
238 return 0; | |
239 } | |
240 | |
241 | |
242 /* Evaluate a jump instruction. | |
243 returns 1 if jump or 0 if no jump | |
244 actual jump instruction is in return_values parameter */ | |
12 | 245 static int32_t eval_jump_instruction(command_t* command, int32_t cond, link_t *return_values) { |
0 | 246 |
15 | 247 switch(vm_getbits(command, 12, 4)) { |
0 | 248 case 1: |
249 return_values->command = Exit; | |
250 return cond; | |
251 case 2: | |
252 return_values->command = JumpTT; | |
15 | 253 return_values->data1 = vm_getbits(command, 41, 7); |
0 | 254 return cond; |
255 case 3: | |
256 return_values->command = JumpVTS_TT; | |
15 | 257 return_values->data1 = vm_getbits(command, 41, 7); |
0 | 258 return cond; |
259 case 5: | |
260 return_values->command = JumpVTS_PTT; | |
15 | 261 return_values->data1 = vm_getbits(command, 41, 7); |
262 return_values->data2 = vm_getbits(command, 22, 10); | |
0 | 263 return cond; |
264 case 6: | |
15 | 265 switch(vm_getbits(command, 40, 2)) { |
0 | 266 case 0: |
267 return_values->command = JumpSS_FP; | |
268 return cond; | |
269 case 1: | |
270 return_values->command = JumpSS_VMGM_MENU; | |
15 | 271 return_values->data1 = vm_getbits(command, 44, 4); |
0 | 272 return cond; |
273 case 2: | |
274 return_values->command = JumpSS_VTSM; | |
15 | 275 return_values->data1 = vm_getbits(command, 32, 8); |
276 return_values->data2 = vm_getbits(command, 24, 8); | |
277 return_values->data3 = vm_getbits(command, 44, 4); | |
0 | 278 return cond; |
279 case 3: | |
280 return_values->command = JumpSS_VMGM_PGC; | |
15 | 281 return_values->data1 = vm_getbits(command, 17, 15); |
0 | 282 return cond; |
283 } | |
284 break; | |
285 case 8: | |
15 | 286 switch(vm_getbits(command, 40, 2)) { |
0 | 287 case 0: |
288 return_values->command = CallSS_FP; | |
15 | 289 return_values->data1 = vm_getbits(command, 32, 8); |
0 | 290 return cond; |
291 case 1: | |
292 return_values->command = CallSS_VMGM_MENU; | |
15 | 293 return_values->data1 = vm_getbits(command, 44, 4); |
294 return_values->data2 = vm_getbits(command, 32, 8); | |
0 | 295 return cond; |
296 case 2: | |
297 return_values->command = CallSS_VTSM; | |
15 | 298 return_values->data1 = vm_getbits(command, 44, 4); |
299 return_values->data2 = vm_getbits(command, 32, 8); | |
0 | 300 return cond; |
301 case 3: | |
302 return_values->command = CallSS_VMGM_PGC; | |
15 | 303 return_values->data1 = vm_getbits(command, 17, 15); |
304 return_values->data2 = vm_getbits(command, 32, 8); | |
0 | 305 return cond; |
306 } | |
307 break; | |
308 } | |
309 return 0; | |
310 } | |
311 | |
312 /* Evaluate a set sytem register instruction | |
313 May contain a link so return the same as eval_link */ | |
12 | 314 static int32_t eval_system_set(command_t* command, int32_t cond, link_t *return_values) { |
315 int32_t i; | |
0 | 316 uint16_t data, data2; |
317 | |
15 | 318 switch(vm_getbits(command, 4, 4)) { |
0 | 319 case 1: /* Set system reg 1 &| 2 &| 3 (Audio, Subp. Angle) */ |
320 for(i = 1; i <= 3; i++) { | |
15 | 321 if(vm_getbits(command, ((2 + i)*8), 1)) { |
322 data = eval_reg_or_data_2(command, vm_getbits(command, 3, 1), 2 + i); | |
0 | 323 if(cond) { |
13 | 324 command->registers->SPRM[i] = data; |
0 | 325 } |
326 } | |
327 } | |
328 break; | |
329 case 2: /* Set system reg 9 & 10 (Navigation timer, Title PGC number) */ | |
15 | 330 data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 2); |
331 data2 = vm_getbits(command, 40, 8); /* ?? size */ | |
0 | 332 if(cond) { |
13 | 333 command->registers->SPRM[9] = data; /* time */ |
334 command->registers->SPRM[10] = data2; /* pgcN */ | |
0 | 335 } |
336 break; | |
337 case 3: /* Mode: Counter / Register + Set */ | |
15 | 338 data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 2); |
339 data2 = vm_getbits(command, 44, 4); | |
340 if(vm_getbits(command, 40, 1)) { | |
0 | 341 fprintf(stderr, "Detected SetGPRMMD Counter!! This is unsupported.\n"); |
13 | 342 command->registers->GPRM_mode[data2] = 1; |
0 | 343 } else { |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
344 fprintf(stderr, "Detected ResetGPRMMD Counter!! This is unsupported.\n"); |
13 | 345 command->registers->GPRM_mode[data2] = 0; |
0 | 346 } |
347 if(cond) { | |
13 | 348 command->registers->GPRM[data2] = data; |
0 | 349 } |
350 break; | |
351 case 6: /* Set system reg 8 (Highlighted button) */ | |
15 | 352 data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 4); /* Not system reg!! */ |
0 | 353 if(cond) { |
13 | 354 command->registers->SPRM[8] = data; |
0 | 355 } |
356 break; | |
357 } | |
15 | 358 if(vm_getbits(command, 12, 4)) { |
12 | 359 return eval_link_instruction(command, cond, return_values); |
0 | 360 } |
361 return 0; | |
362 } | |
363 | |
364 | |
365 /* Evaluate set operation | |
366 Sets the register given to the value indicated by op and data. | |
367 For the swap case the contents of reg is stored in reg2. | |
368 */ | |
13 | 369 static void eval_set_op(command_t* command, int32_t op, int32_t reg, int32_t reg2, int32_t data) { |
12 | 370 const int32_t shortmax = 0xffff; |
371 int32_t tmp; | |
0 | 372 switch(op) { |
373 case 1: | |
13 | 374 command->registers->GPRM[reg] = data; |
0 | 375 break; |
376 case 2: /* SPECIAL CASE - SWAP! */ | |
13 | 377 command->registers->GPRM[reg2] = command->registers->GPRM[reg]; |
378 command->registers->GPRM[reg] = data; | |
0 | 379 break; |
380 case 3: | |
13 | 381 tmp = command->registers->GPRM[reg] + data; |
12 | 382 if(tmp > shortmax) tmp = shortmax; |
13 | 383 command->registers->GPRM[reg] = (uint16_t)tmp; |
0 | 384 break; |
385 case 4: | |
13 | 386 tmp = command->registers->GPRM[reg] - data; |
12 | 387 if(tmp < 0) tmp = 0; |
13 | 388 command->registers->GPRM[reg] = (uint16_t)tmp; |
0 | 389 break; |
390 case 5: | |
13 | 391 tmp = command->registers->GPRM[reg] * data; |
12 | 392 if(tmp >= shortmax) tmp = shortmax; |
13 | 393 command->registers->GPRM[reg] = (uint16_t)tmp; |
0 | 394 break; |
395 case 6: | |
12 | 396 if (data != 0) { |
13 | 397 command->registers->GPRM[reg] /= data; |
12 | 398 } else { |
13 | 399 command->registers->GPRM[reg] = 0; /* Avoid that divide by zero! */ |
12 | 400 } |
0 | 401 break; |
402 case 7: | |
13 | 403 command->registers->GPRM[reg] %= data; |
0 | 404 break; |
405 case 8: /* SPECIAL CASE - RND! */ | |
13 | 406 command->registers->GPRM[reg] = (uint16_t) ((float) data * rand()/(RAND_MAX+1.0)); |
0 | 407 break; |
408 case 9: | |
13 | 409 command->registers->GPRM[reg] &= data; |
0 | 410 break; |
411 case 10: | |
13 | 412 command->registers->GPRM[reg] |= data; |
0 | 413 break; |
414 case 11: | |
13 | 415 command->registers->GPRM[reg] ^= data; |
0 | 416 break; |
417 } | |
418 } | |
419 | |
420 /* Evaluate set instruction, combined with either Link or Compare. */ | |
12 | 421 static void eval_set_version_1(command_t* command, int32_t cond) { |
15 | 422 uint8_t op = vm_getbits(command, 4, 4); |
423 uint8_t reg = vm_getbits(command, 28, 4); /* FIXME: This is different from vmcmd.c!!! */ | |
424 uint8_t reg2 = vm_getbits(command, 44, 4); | |
425 uint16_t data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 4); | |
0 | 426 |
427 if(cond) { | |
13 | 428 eval_set_op(command, op, reg, reg2, data); |
0 | 429 } |
430 } | |
431 | |
432 | |
433 /* Evaluate set instruction, combined with both Link and Compare. */ | |
12 | 434 static void eval_set_version_2(command_t* command, int32_t cond) { |
15 | 435 uint8_t op = vm_getbits(command, 4, 4); |
436 uint8_t reg = vm_getbits(command, 12, 4); | |
437 uint8_t reg2 = vm_getbits(command, 28, 4); /* FIXME: This is different from vmcmd.c!!! */ | |
438 uint16_t data = eval_reg_or_data(command, vm_getbits(command, 3, 1), 2); | |
0 | 439 |
440 if(cond) { | |
13 | 441 eval_set_op(command, op, reg, reg2, data); |
0 | 442 } |
443 } | |
444 | |
445 | |
446 /* Evaluate a command | |
447 returns row number of goto, 0 if no goto, -1 if link. | |
448 Link command in return_values */ | |
13 | 449 static int32_t eval_command(uint8_t *bytes, registers_t* registers, link_t *return_values) { |
12 | 450 int32_t cond, res = 0; |
451 command_t command; | |
452 command.instruction =( (uint64_t) bytes[0] << 56 ) | | |
453 ( (uint64_t) bytes[1] << 48 ) | | |
454 ( (uint64_t) bytes[2] << 40 ) | | |
455 ( (uint64_t) bytes[3] << 32 ) | | |
456 ( (uint64_t) bytes[4] << 24 ) | | |
457 ( (uint64_t) bytes[5] << 16 ) | | |
458 ( (uint64_t) bytes[6] << 8 ) | | |
459 (uint64_t) bytes[7] ; | |
460 command.examined = 0; | |
13 | 461 command.registers = registers; |
0 | 462 memset(return_values, 0, sizeof(link_t)); |
463 | |
15 | 464 switch(vm_getbits(&command, 0, 3)) { /* three first old_bits */ |
0 | 465 case 0: /* Special instructions */ |
12 | 466 cond = eval_if_version_1(&command); |
467 res = eval_special_instruction(&command, cond); | |
0 | 468 if(res == -1) { |
469 fprintf(stderr, "Unknown Instruction!\n"); | |
6 | 470 assert(0); |
0 | 471 } |
472 break; | |
473 case 1: /* Link/jump instructions */ | |
15 | 474 if(vm_getbits(&command, 3, 1)) { |
12 | 475 cond = eval_if_version_2(&command); |
476 res = eval_jump_instruction(&command, cond, return_values); | |
0 | 477 } else { |
12 | 478 cond = eval_if_version_1(&command); |
479 res = eval_link_instruction(&command, cond, return_values); | |
0 | 480 } |
481 if(res) | |
482 res = -1; | |
483 break; | |
484 case 2: /* System set instructions */ | |
12 | 485 cond = eval_if_version_2(&command); |
486 res = eval_system_set(&command, cond, return_values); | |
0 | 487 if(res) |
488 res = -1; | |
489 break; | |
490 case 3: /* Set instructions, either Compare or Link may be used */ | |
12 | 491 cond = eval_if_version_3(&command); |
492 eval_set_version_1(&command, cond); | |
15 | 493 if(vm_getbits(&command, 12, 4)) { |
12 | 494 res = eval_link_instruction(&command, cond, return_values); |
0 | 495 } |
496 if(res) | |
497 res = -1; | |
498 break; | |
499 case 4: /* Set, Compare -> Link Sub-Instruction */ | |
12 | 500 eval_set_version_2(&command, /*True*/ 1); |
501 cond = eval_if_version_4(&command); | |
502 res = eval_link_subins(&command, cond, return_values); | |
0 | 503 if(res) |
504 res = -1; | |
505 break; | |
506 case 5: /* Compare -> (Set and Link Sub-Instruction) */ | |
12 | 507 cond = eval_if_version_4(&command); |
508 eval_set_version_2(&command, cond); | |
509 res = eval_link_subins(&command, cond, return_values); | |
0 | 510 if(res) |
511 res = -1; | |
512 break; | |
513 case 6: /* Compare -> Set, allways Link Sub-Instruction */ | |
12 | 514 cond = eval_if_version_4(&command); |
515 eval_set_version_2(&command, cond); | |
516 res = eval_link_subins(&command, /*True*/ 1, return_values); | |
0 | 517 if(res) |
518 res = -1; | |
519 break; | |
12 | 520 default: /* Unknown command */ |
15 | 521 fprintf(stderr, "WARNING: Unknown Command=%x\n", vm_getbits(&command, 0, 3)); |
0 | 522 } |
523 /* Check if there are bits not yet examined */ | |
524 | |
12 | 525 if(command.instruction & ~ command.examined) { |
526 fprintf(stderr, " libdvdnav: decoder.c: [WARNING, unknown bits:"); | |
527 fprintf(stderr, " %08llx", (command.instruction & ~ command.examined) ); | |
528 fprintf(stderr, "]"); | |
0 | 529 } |
530 | |
531 return res; | |
532 } | |
533 | |
534 /* Evaluate a set of commands in the given register set (which is | |
535 * modified */ | |
12 | 536 int32_t vmEval_CMD(vm_cmd_t commands[], int32_t num_commands, |
0 | 537 registers_t *registers, link_t *return_values) { |
12 | 538 int32_t i = 0; |
539 int32_t total = 0; | |
0 | 540 |
541 #ifdef TRACE | |
542 /* DEBUG */ | |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
543 fprintf(stderr, "libdvdnav: Registers before transaction\n"); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
544 vmPrint_registers( registers ); |
0 | 545 if(1) { |
12 | 546 int32_t i; |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
547 fprintf(stderr, "libdvdnav: Full list of commands to execute\n"); |
0 | 548 for(i = 0; i < num_commands; i++) |
549 vmPrint_CMD(i, &commands[i]); | |
550 fprintf(stderr, "--------------------------------------------\n"); | |
551 } /* end DEBUG */ | |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
552 if (1) { |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
553 fprintf(stderr, "libdvdnav: Single stepping commands\n"); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
554 } |
0 | 555 #endif |
556 | |
557 while(i < num_commands && total < 100000) { | |
12 | 558 int32_t line; |
0 | 559 |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
560 #ifdef TRACE |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
561 if(1) vmPrint_CMD(i, &commands[i]); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
562 #endif |
13 | 563 line = eval_command(&commands[i].bytes[0], registers, return_values); |
0 | 564 |
565 if (line < 0) { /* Link command */ | |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
566 #ifdef TRACE |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
567 fprintf(stderr, "libdvdnav: Registers after transaction\n"); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
568 vmPrint_registers( registers ); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
569 #endif |
0 | 570 fprintf(stderr, "eval: Doing Link/Jump/Call\n"); |
571 return 1; | |
572 } | |
573 | |
574 if (line > 0) /* Goto command */ | |
575 i = line - 1; | |
576 else /* Just continue on the next line */ | |
577 i++; | |
578 | |
579 total++; | |
580 } | |
581 | |
582 memset(return_values, 0, sizeof(link_t)); | |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
583 #ifdef TRACE |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
584 fprintf(stderr, "libdvdnav: Registers after transaction\n"); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
585 vmPrint_registers( registers ); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
586 #endif |
0 | 587 return 0; |
588 } | |
589 | |
590 static char *linkcmd2str(link_cmd_t cmd) { | |
591 switch(cmd) { | |
592 case LinkNoLink: | |
593 return "LinkNoLink"; | |
594 case LinkTopC: | |
595 return "LinkTopC"; | |
596 case LinkNextC: | |
597 return "LinkNextC"; | |
598 case LinkPrevC: | |
599 return "LinkPrevC"; | |
600 case LinkTopPG: | |
601 return "LinkTopPG"; | |
602 case LinkNextPG: | |
603 return "LinkNextPG"; | |
604 case LinkPrevPG: | |
605 return "LinkPrevPG"; | |
606 case LinkTopPGC: | |
607 return "LinkTopPGC"; | |
608 case LinkNextPGC: | |
609 return "LinkNextPGC"; | |
610 case LinkPrevPGC: | |
611 return "LinkPrevPGC"; | |
612 case LinkGoUpPGC: | |
613 return "LinkGoUpPGC"; | |
614 case LinkTailPGC: | |
615 return "LinkTailPGC"; | |
616 case LinkRSM: | |
617 return "LinkRSM"; | |
618 case LinkPGCN: | |
619 return "LinkPGCN"; | |
620 case LinkPTTN: | |
621 return "LinkPTTN"; | |
622 case LinkPGN: | |
623 return "LinkPGN"; | |
624 case LinkCN: | |
625 return "LinkCN"; | |
626 case Exit: | |
627 return "Exit"; | |
628 case JumpTT: | |
629 return "JumpTT"; | |
630 case JumpVTS_TT: | |
631 return "JumpVTS_TT"; | |
632 case JumpVTS_PTT: | |
633 return "JumpVTS_PTT"; | |
634 case JumpSS_FP: | |
635 return "JumpSS_FP"; | |
636 case JumpSS_VMGM_MENU: | |
637 return "JumpSS_VMGM_MENU"; | |
638 case JumpSS_VTSM: | |
639 return "JumpSS_VTSM"; | |
640 case JumpSS_VMGM_PGC: | |
641 return "JumpSS_VMGM_PGC"; | |
642 case CallSS_FP: | |
643 return "CallSS_FP"; | |
644 case CallSS_VMGM_MENU: | |
645 return "CallSS_VMGM_MENU"; | |
646 case CallSS_VTSM: | |
647 return "CallSS_VTSM"; | |
648 case CallSS_VMGM_PGC: | |
649 return "CallSS_VMGM_PGC"; | |
650 case PlayThis: | |
651 return "PlayThis"; | |
652 } | |
653 return "*** (bug)"; | |
654 } | |
655 | |
656 void vmPrint_LINK(link_t value) { | |
657 char *cmd = linkcmd2str(value.command); | |
658 | |
659 switch(value.command) { | |
660 case LinkNoLink: | |
661 case LinkTopC: | |
662 case LinkNextC: | |
663 case LinkPrevC: | |
664 case LinkTopPG: | |
665 case LinkNextPG: | |
666 case LinkPrevPG: | |
667 case LinkTopPGC: | |
668 case LinkNextPGC: | |
669 case LinkPrevPGC: | |
670 case LinkGoUpPGC: | |
671 case LinkTailPGC: | |
672 case LinkRSM: | |
673 fprintf(stderr, "%s (button %d)\n", cmd, value.data1); | |
674 break; | |
675 case LinkPGCN: | |
676 case JumpTT: | |
677 case JumpVTS_TT: | |
678 case JumpSS_VMGM_MENU: /* == 2 -> Title Menu */ | |
679 case JumpSS_VMGM_PGC: | |
680 fprintf(stderr, "%s %d\n", cmd, value.data1); | |
681 break; | |
682 case LinkPTTN: | |
683 case LinkPGN: | |
684 case LinkCN: | |
685 fprintf(stderr, "%s %d (button %d)\n", cmd, value.data1, value.data2); | |
686 break; | |
687 case Exit: | |
688 case JumpSS_FP: | |
689 case PlayThis: /* Humm.. should we have this at all.. */ | |
690 fprintf(stderr, "%s\n", cmd); | |
691 break; | |
692 case JumpVTS_PTT: | |
693 fprintf(stderr, "%s %d:%d\n", cmd, value.data1, value.data2); | |
694 break; | |
695 case JumpSS_VTSM: | |
696 fprintf(stderr, "%s vts %d title %d menu %d\n", | |
697 cmd, value.data1, value.data2, value.data3); | |
698 break; | |
699 case CallSS_FP: | |
700 fprintf(stderr, "%s resume cell %d\n", cmd, value.data1); | |
701 break; | |
702 case CallSS_VMGM_MENU: /* == 2 -> Title Menu */ | |
703 case CallSS_VTSM: | |
704 fprintf(stderr, "%s %d resume cell %d\n", cmd, value.data1, value.data2); | |
705 break; | |
706 case CallSS_VMGM_PGC: | |
707 fprintf(stderr, "%s %d resume cell %d\n", cmd, value.data1, value.data2); | |
708 break; | |
709 } | |
710 } | |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
711 |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
712 void vmPrint_registers( registers_t *registers ) { |
12 | 713 int32_t i; |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
714 fprintf(stderr, " # "); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
715 for(i = 0; i < 24; i++) |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
716 fprintf(stderr, " %2d |", i); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
717 fprintf(stderr, "\nSRPMS: "); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
718 for(i = 0; i < 24; i++) |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
719 fprintf(stderr, "%04x|", registers->SPRM[i]); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
720 fprintf(stderr, "\nGRPMS: "); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
721 for(i = 0; i < 16; i++) |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
722 fprintf(stderr, "%04x|", registers->GPRM[i]); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
723 fprintf(stderr, "\nGmode: "); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
724 for(i = 0; i < 16; i++) |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
725 fprintf(stderr, "%04x|", registers->GPRM_mode[i]); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
726 fprintf(stderr, "\n"); |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
6
diff
changeset
|
727 } |