Mercurial > libdvdnav.hg
annotate vmcmd.c @ 11:1f479a99339c src
Change the bits function so that there are no global variables left.
author | jcdutton |
---|---|
date | Tue, 09 Apr 2002 20:13:06 +0000 |
parents | 6f0fb88d1463 |
children | 1a214a94a80d |
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> | |
30 #include <ctype.h> | |
31 #include <inttypes.h> | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
32 #include <assert.h> |
0 | 33 |
34 #include "vmcmd.h" | |
35 | |
36 | |
37 /* freebsd compatibility */ | |
38 #ifndef PRIu8 | |
39 #define PRIu8 "d" | |
40 #endif | |
41 | |
42 /* freebsd compatibility */ | |
43 #ifndef PRIu16 | |
44 #define PRIu16 "d" | |
45 #endif | |
46 | |
47 static const char *cmp_op_table[] = { | |
48 NULL, "&", "==", "!=", ">=", ">", "<=", "<" | |
49 }; | |
50 static const char *set_op_table[] = { | |
51 NULL, "=", "<->", "+=", "-=", "*=", "/=", "%=", "rnd", "&=", "|=", "^=" | |
52 }; | |
53 | |
54 static const char *link_table[] = { | |
55 "LinkNoLink", "LinkTopC", "LinkNextC", "LinkPrevC", | |
56 NULL, "LinkTopPG", "LinkNextPG", "LinkPrevPG", | |
57 NULL, "LinkTopPGC", "LinkNextPGC", "LinkPrevPGC", | |
58 "LinkGoUpPGC", "LinkTailPGC", NULL, NULL, | |
59 "RSM" | |
60 }; | |
61 | |
62 static const char *system_reg_table[] = { | |
63 "Menu Description Language Code", | |
64 "Audio Stream Number", | |
65 "Sub-picture Stream Number", | |
66 "Angle Number", | |
67 "Title Track Number", | |
68 "VTS Title Track Number", | |
69 "VTS PGC Number", | |
70 "PTT Number for One_Sequential_PGC_Title", | |
71 "Highlighted Button Number", | |
72 "Navigation Timer", | |
73 "Title PGC Number for Navigation Timer", | |
74 "Audio Mixing Mode for Karaoke", | |
75 "Country Code for Parental Management", | |
76 "Parental Level", | |
77 "Player Configurations for Video", | |
78 "Player Configurations for Audio", | |
79 "Initial Language Code for Audio", | |
80 "Initial Language Code Extension for Audio", | |
81 "Initial Language Code for Sub-picture", | |
82 "Initial Language Code Extension for Sub-picture", | |
83 "Player Regional Code", | |
84 "Reserved 21", | |
85 "Reserved 22", | |
86 "Reserved 23" | |
87 }; | |
88 | |
89 static const char *system_reg_abbr_table[] = { | |
90 NULL, | |
91 "ASTN", | |
92 "SPSTN", | |
93 "AGLN", | |
94 "TTN", | |
95 "VTS_TTN", | |
96 "TT_PGCN", | |
97 "PTTN", | |
98 "HL_BTNN", | |
99 "NVTMR", | |
100 "NV_PGCN", | |
101 NULL, | |
102 "CC_PLT", | |
103 "PLT", | |
104 NULL, | |
105 NULL, | |
106 NULL, | |
107 NULL, | |
108 NULL, | |
109 NULL, | |
110 NULL, | |
111 NULL, | |
112 NULL, | |
113 NULL, | |
114 }; | |
115 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
116 typedef struct |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
117 { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
118 uint64_t instruction; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
119 uint64_t examined; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
120 } command_t; |
0 | 121 |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
122 static uint32_t new_bits(command_t* command, int start, int count); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
123 |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
124 static uint32_t new_bits(command_t *command, int start, int count) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
125 uint64_t result = 0; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
126 uint64_t bit_mask=0xffffffffffffffff; /* I could put -1 instead */ |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
127 uint64_t examining = 0; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
128 if (count == 0) return 0; |
0 | 129 |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
130 if ( ((count+start) > 64) || |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
131 (count > 32) || |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
132 (start > 63) || |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
133 (count < 0) || |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
134 (start < 0) ){ |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
135 fprintf(stderr, "Bad call to new_bits. Parameter out of range\n"); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
136 assert(0); |
0 | 137 } |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
138 bit_mask >>= start; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
139 examining = ((bit_mask >> (64-count-start)) << (64-count-start) ); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
140 command->examined |= examining; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
141 result = (command->instruction & bit_mask) >> (64-count-start); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
142 return (uint32_t) result; |
0 | 143 } |
144 | |
145 static void print_system_reg(uint16_t reg) { | |
146 if(reg < sizeof(system_reg_abbr_table) / sizeof(char *)) | |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
0
diff
changeset
|
147 fprintf(stderr, "%s (SRPM:%d)", system_reg_table[reg], reg); |
0 | 148 else |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
0
diff
changeset
|
149 fprintf(stderr, " WARNING: Unknown system register ( reg=%d ) ", reg); |
0 | 150 } |
151 | |
152 static void print_reg(uint8_t reg) { | |
153 if(reg & 0x80) | |
154 print_system_reg(reg & 0x7f); | |
155 else | |
156 if(reg < 16) | |
157 fprintf(stderr, "g[%" PRIu8 "]", reg); | |
158 else | |
159 fprintf(stderr, " WARNING: Unknown general register "); | |
160 } | |
161 | |
162 static void print_cmp_op(uint8_t op) { | |
163 if(op < sizeof(cmp_op_table) / sizeof(char *) && cmp_op_table[op] != NULL) | |
164 fprintf(stderr, " %s ", cmp_op_table[op]); | |
165 else | |
166 fprintf(stderr, " WARNING: Unknown compare op "); | |
167 } | |
168 | |
169 static void print_set_op(uint8_t op) { | |
170 if(op < sizeof(set_op_table) / sizeof(char *) && set_op_table[op] != NULL) | |
171 fprintf(stderr, " %s ", set_op_table[op]); | |
172 else | |
173 fprintf(stderr, " WARNING: Unknown set op "); | |
174 } | |
175 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
176 static void print_reg_or_data(command_t* command, int immediate, int byte) { |
0 | 177 if(immediate) { |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
178 int i = new_bits(command, (byte*8), 16); |
0 | 179 |
180 fprintf(stderr, "0x%x", i); | |
181 if(isprint(i & 0xff) && isprint((i>>8) & 0xff)) | |
182 fprintf(stderr, " (\"%c%c\")", (char)((i>>8) & 0xff), (char)(i & 0xff)); | |
183 } else { | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
184 print_reg(new_bits(command, ((byte + 1)*8), 8)); |
0 | 185 } |
186 } | |
187 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
188 static void print_reg_or_data_2(command_t* command, int immediate, int byte) { |
0 | 189 if(immediate) |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
190 fprintf(stderr, "0x%x", new_bits(command, ((byte*8)+1), 7)); |
0 | 191 else |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
192 fprintf(stderr, "g[%" PRIu8 "]", new_bits(command, ((byte*8)+4), 4)); |
0 | 193 } |
194 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
195 static void print_if_version_1(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
196 uint8_t op = new_bits(command, 9, 3); |
0 | 197 |
198 if(op) { | |
199 fprintf(stderr, "if ("); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
200 print_reg(new_bits(command,24,8)); |
0 | 201 print_cmp_op(op); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
202 print_reg_or_data(command, new_bits(command, 8,1), 4); |
0 | 203 fprintf(stderr, ") "); |
204 } | |
205 } | |
206 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
207 static void print_if_version_2(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
208 uint8_t op = new_bits(command, 9, 3); |
0 | 209 |
210 if(op) { | |
211 fprintf(stderr, "if ("); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
212 print_reg(new_bits(command, 48, 8)); |
0 | 213 print_cmp_op(op); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
214 print_reg(new_bits(command, 56, 8)); |
0 | 215 fprintf(stderr, ") "); |
216 } | |
217 } | |
218 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
219 static void print_if_version_3(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
220 uint8_t op = new_bits(command, 9, 3); |
0 | 221 |
222 if(op) { | |
223 fprintf(stderr, "if ("); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
224 print_reg(new_bits(command, 20, 4)); |
0 | 225 print_cmp_op(op); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
226 print_reg_or_data(command, new_bits(command, 8, 1), 6); |
0 | 227 fprintf(stderr, ") "); |
228 } | |
229 } | |
230 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
231 static void print_if_version_4(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
232 uint8_t op = new_bits(command, 9, 3); |
0 | 233 |
234 if(op) { | |
235 fprintf(stderr, "if ("); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
236 print_reg(new_bits(command, 12, 4)); |
0 | 237 print_cmp_op(op); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
238 print_reg_or_data(command, new_bits(command, 8, 1), 4); |
0 | 239 fprintf(stderr, ") "); |
240 } | |
241 } | |
242 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
243 static void print_special_instruction(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
244 uint8_t op = new_bits(command, 12, 4); |
0 | 245 |
246 switch(op) { | |
247 case 0: /* NOP */ | |
248 fprintf(stderr, "Nop"); | |
249 break; | |
250 case 1: /* Goto line */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
251 fprintf(stderr, "Goto %" PRIu8, new_bits(command, 56, 8)); |
0 | 252 break; |
253 case 2: /* Break */ | |
254 fprintf(stderr, "Break"); | |
255 break; | |
256 case 3: /* Parental level */ | |
257 fprintf(stderr, "SetTmpPML %" PRIu8 ", Goto %" PRIu8, | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
258 new_bits(command, 52, 4), new_bits(command, 56, 8)); |
0 | 259 break; |
260 default: | |
261 fprintf(stderr, "WARNING: Unknown special instruction (%i)", | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
262 new_bits(command, 12, 4)); |
0 | 263 } |
264 } | |
265 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
266 static void print_linksub_instruction(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
267 int linkop = new_bits(command, 59, 5); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
268 int button = new_bits(command, 48, 6); |
0 | 269 |
270 if(linkop < sizeof(link_table)/sizeof(char *) && link_table[linkop] != NULL) | |
271 fprintf(stderr, "%s (button %" PRIu8 ")", link_table[linkop], button); | |
272 else | |
273 fprintf(stderr, "WARNING: Unknown linksub instruction (%i)", linkop); | |
274 } | |
275 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
276 static void print_link_instruction(command_t* command, int optional) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
277 uint8_t op = new_bits(command, 12, 4); |
0 | 278 |
279 if(optional && op) | |
280 fprintf(stderr, ", "); | |
281 | |
282 switch(op) { | |
283 case 0: | |
284 if(!optional) | |
285 fprintf(stderr, "WARNING: NOP (link)!"); | |
286 break; | |
287 case 1: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
288 print_linksub_instruction(command); |
0 | 289 break; |
290 case 4: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
291 fprintf(stderr, "LinkPGCN %" PRIu16, new_bits(command, 49, 15)); |
0 | 292 break; |
293 case 5: | |
294 fprintf(stderr, "LinkPTT %" PRIu16 " (button %" PRIu8 ")", | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
295 new_bits(command, 54, 10), new_bits(command, 48, 6)); |
0 | 296 break; |
297 case 6: | |
298 fprintf(stderr, "LinkPGN %" PRIu8 " (button %" PRIu8 ")", | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
299 new_bits(command, 57, 7), new_bits(command, 48, 6)); |
0 | 300 break; |
301 case 7: | |
302 fprintf(stderr, "LinkCN %" PRIu8 " (button %" PRIu8 ")", | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
303 new_bits(command, 56, 8), new_bits(command, 48, 6)); |
0 | 304 break; |
305 default: | |
306 fprintf(stderr, "WARNING: Unknown link instruction"); | |
307 } | |
308 } | |
309 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
310 static void print_jump_instruction(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
311 switch(new_bits(command, 12, 4)) { |
0 | 312 case 1: |
313 fprintf(stderr, "Exit"); | |
314 break; | |
315 case 2: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
316 fprintf(stderr, "JumpTT %" PRIu8, new_bits(command, 41, 7)); |
0 | 317 break; |
318 case 3: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
319 fprintf(stderr, "JumpVTS_TT %" PRIu8, new_bits(command, 41, 7)); |
0 | 320 break; |
321 case 5: | |
322 fprintf(stderr, "JumpVTS_PTT %" PRIu8 ":%" PRIu16, | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
323 new_bits(command, 41, 7), new_bits(command, 22, 10)); |
0 | 324 break; |
325 case 6: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
326 switch(new_bits(command, 40, 2)) { |
0 | 327 case 0: |
328 fprintf(stderr, "JumpSS FP"); | |
329 break; | |
330 case 1: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
331 fprintf(stderr, "JumpSS VMGM (menu %" PRIu8 ")", new_bits(command, 44, 4)); |
0 | 332 break; |
333 case 2: | |
334 fprintf(stderr, "JumpSS VTSM (vts %" PRIu8 ", title %" PRIu8 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
335 ", menu %" PRIu8 ")", new_bits(command, 32, 8), new_bits(command, 24, 8), new_bits(command, 44, 4)); |
0 | 336 break; |
337 case 3: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
338 fprintf(stderr, "JumpSS VMGM (pgc %" PRIu8 ")", new_bits(command, 17, 15)); |
0 | 339 break; |
340 } | |
341 break; | |
342 case 8: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
343 switch(new_bits(command, 40, 2)) { |
0 | 344 case 0: |
345 fprintf(stderr, "CallSS FP (rsm_cell %" PRIu8 ")", | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
346 new_bits(command, 32, 8)); |
0 | 347 break; |
348 case 1: | |
349 fprintf(stderr, "CallSS VMGM (menu %" PRIu8 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
350 ", rsm_cell %" PRIu8 ")", new_bits(command, 44, 4), new_bits(command, 32, 8)); |
0 | 351 break; |
352 case 2: | |
353 fprintf(stderr, "CallSS VTSM (menu %" PRIu8 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
354 ", rsm_cell %" PRIu8 ")", new_bits(command, 44, 4), new_bits(command, 32, 8)); |
0 | 355 break; |
356 case 3: | |
357 fprintf(stderr, "CallSS VMGM (pgc %" PRIu8 ", rsm_cell %" PRIu8 ")", | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
358 new_bits(command, 17, 15), new_bits(command, 32, 8)); |
0 | 359 break; |
360 } | |
361 break; | |
362 default: | |
363 fprintf(stderr, "WARNING: Unknown Jump/Call instruction"); | |
364 } | |
365 } | |
366 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
367 static void print_system_set(command_t* command) { |
0 | 368 int i; |
369 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
370 switch(new_bits(command, 4, 4)) { |
0 | 371 case 1: /* Set system reg 1 &| 2 &| 3 (Audio, Subp. Angle) */ |
372 for(i = 1; i <= 3; i++) { | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
373 if(new_bits(command, ((2+i)*8), 1)) { |
0 | 374 print_system_reg(i); |
375 fprintf(stderr, " = "); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
376 print_reg_or_data_2(command, new_bits(command, 3, 1), 2 + i); |
0 | 377 fprintf(stderr, " "); |
378 } | |
379 } | |
380 break; | |
381 case 2: /* Set system reg 9 & 10 (Navigation timer, Title PGC number) */ | |
382 print_system_reg(9); | |
383 fprintf(stderr, " = "); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
384 print_reg_or_data(command, new_bits(command, 3, 1), 2); |
0 | 385 fprintf(stderr, " "); |
386 print_system_reg(10); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
387 fprintf(stderr, " = %" PRIu8, new_bits(command, 40, 8)); /* ?? */ |
0 | 388 break; |
389 case 3: /* Mode: Counter / Register + Set */ | |
390 fprintf(stderr, "SetMode "); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
391 if(new_bits(command, 40, 1)) |
0 | 392 fprintf(stderr, "Counter "); |
393 else | |
394 fprintf(stderr, "Register "); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
395 print_reg(new_bits(command, 44, 4)); |
0 | 396 print_set_op(0x1); /* '=' */ |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
397 print_reg_or_data(command, new_bits(command, 3, 1), 2); |
0 | 398 break; |
399 case 6: /* Set system reg 8 (Highlighted button) */ | |
400 print_system_reg(8); | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
401 if(new_bits(command, 3, 1)) /* immediate */ |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
402 fprintf(stderr, " = 0x%x (button no %d)", new_bits(command, 32, 16), new_bits(command, 32, 6)); |
0 | 403 else |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
404 fprintf(stderr, " = g[%" PRIu8 "]", new_bits(command, 44, 4)); |
0 | 405 break; |
406 default: | |
407 fprintf(stderr, "WARNING: Unknown system set instruction (%i)", | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
408 new_bits(command, 4, 4)); |
0 | 409 } |
410 } | |
411 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
412 static void print_set_version_1(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
413 uint8_t set_op = new_bits(command, 4, 4); |
0 | 414 |
415 if(set_op) { | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
416 print_reg(new_bits(command, 24, 8)); |
0 | 417 print_set_op(set_op); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
418 print_reg_or_data(command, new_bits(command, 3, 1), 4); |
0 | 419 } else { |
420 fprintf(stderr, "NOP"); | |
421 } | |
422 } | |
423 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
424 static void print_set_version_2(command_t* command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
425 uint8_t set_op = new_bits(command, 4, 4); |
0 | 426 |
427 if(set_op) { | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
428 print_reg(new_bits(command, 12, 4)); |
0 | 429 print_set_op(set_op); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
430 print_reg_or_data(command, new_bits(command, 3, 1), 2); |
0 | 431 } else { |
432 fprintf(stderr, "NOP"); | |
433 } | |
434 } | |
435 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
436 void vmPrint_mnemonic(vm_cmd_t *vm_command) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
437 int i; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
438 command_t command; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
439 command.instruction =( (uint64_t) vm_command->bytes[0] << 56 ) | |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
440 ( (uint64_t) vm_command->bytes[1] << 48 ) | |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
441 ( (uint64_t) vm_command->bytes[2] << 40 ) | |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
442 ( (uint64_t) vm_command->bytes[3] << 32 ) | |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
443 ( (uint64_t) vm_command->bytes[4] << 24 ) | |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
444 ( (uint64_t) vm_command->bytes[5] << 16 ) | |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
445 ( (uint64_t) vm_command->bytes[6] << 8 ) | |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
446 (uint64_t) vm_command->bytes[7] ; |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
447 command.examined = 0; |
0 | 448 |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
449 switch(new_bits(&command,0,3)) { /* three first bits */ |
0 | 450 case 0: /* Special instructions */ |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
451 print_if_version_1(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
452 print_special_instruction(&command); |
0 | 453 break; |
454 case 1: /* Jump/Call or Link instructions */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
455 if(new_bits(&command,3,1)) { |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
456 print_if_version_2(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
457 print_jump_instruction(&command); |
0 | 458 } else { |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
459 print_if_version_1(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
460 print_link_instruction(&command, 0); /* must be pressent */ |
0 | 461 } |
462 break; | |
463 case 2: /* Set System Parameters instructions */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
464 print_if_version_2(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
465 print_system_set(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
466 print_link_instruction(&command, 1); /* either 'if' or 'link' */ |
0 | 467 break; |
468 case 3: /* Set General Parameters instructions */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
469 print_if_version_3(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
470 print_set_version_1(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
471 print_link_instruction(&command, 1); /* either 'if' or 'link' */ |
0 | 472 break; |
473 case 4: /* Set, Compare -> LinkSub instructions */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
474 print_set_version_2(&command); |
0 | 475 fprintf(stderr, ", "); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
476 print_if_version_4(&command); |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
477 print_linksub_instruction(&command); |
0 | 478 break; |
479 case 5: /* Compare -> (Set and LinkSub) instructions */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
480 print_if_version_4(&command); |
0 | 481 fprintf(stderr, "{ "); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
482 print_set_version_2(&command); |
0 | 483 fprintf(stderr, ", "); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
484 print_linksub_instruction(&command); |
0 | 485 fprintf(stderr, " }"); |
486 break; | |
487 case 6: /* Compare -> Set, always LinkSub instructions */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
488 print_if_version_4(&command); |
0 | 489 fprintf(stderr, "{ "); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
490 print_set_version_2(&command); |
0 | 491 fprintf(stderr, " } "); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
492 print_linksub_instruction(&command); |
0 | 493 break; |
494 default: | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
495 fprintf(stderr, "WARNING: Unknown instruction type (%i)", new_bits(&command, 0, 3)); |
0 | 496 } |
497 /* Check if there still are bits set that were not examined */ | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
498 |
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
499 if(command.instruction & ~ command.examined) { |
0 | 500 fprintf(stderr, " [WARNING, unknown bits:"); |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
501 fprintf(stderr, " %08llx", (command.instruction & ~ command.examined) ); |
0 | 502 fprintf(stderr, "]"); |
503 } | |
504 } | |
505 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
506 void vmPrint_CMD(int row, vm_cmd_t *vm_command) { |
0 | 507 int i; |
508 | |
509 fprintf(stderr, "(%03d) ", row + 1); | |
510 for(i = 0; i < 8; i++) | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
511 fprintf(stderr, "%02x ", vm_command->bytes[i]); |
0 | 512 fprintf(stderr, "| "); |
513 | |
11
1f479a99339c
Change the bits function so that there are no global variables left.
jcdutton
parents:
10
diff
changeset
|
514 vmPrint_mnemonic(vm_command); |
0 | 515 fprintf(stderr, "\n"); |
516 } | |
10
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
0
diff
changeset
|
517 |
6f0fb88d1463
Added some debug info, to hopefully help in tracking bugs in libdvdnav.
jcdutton
parents:
0
diff
changeset
|
518 |