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