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