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