/[pcsx2_0.9.7]/trunk/pcsx2/Vif_Codes.cpp
ViewVC logotype

Contents of /trunk/pcsx2/Vif_Codes.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (9 years, 10 months ago) by william
File size: 17048 byte(s)
committing r3113 initial commit again...
1 /* PCSX2 - PS2 Emulator for PCs
2 * Copyright (C) 2002-2010 PCSX2 Dev Team
3 *
4 * PCSX2 is free software: you can redistribute it and/or modify it under the terms
5 * of the GNU Lesser General Public License as published by the Free Software Found-
6 * ation, either version 3 of the License, or (at your option) any later version.
7 *
8 * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
9 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 * PURPOSE. See the GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License along with PCSX2.
13 * If not, see <http://www.gnu.org/licenses/>.
14 */
15
16 #include "PrecompiledHeader.h"
17 #include "Common.h"
18 #include "GS.h"
19 #include "Gif.h"
20 #include "Vif_Dma.h"
21 #include "newVif.h"
22 #include "VUmicro.h"
23
24 #define vifOp(vifCodeName) _vifT int __fastcall vifCodeName(int pass, u32 *data)
25 #define pass1 if (pass == 0)
26 #define pass2 if (pass == 1)
27 #define pass3 if (pass == 2)
28 #define vif1Only() { if (!idx) return vifCode_Null<idx>(pass, (u32*)data); }
29 vifOp(vifCode_Null);
30
31 //------------------------------------------------------------------
32 // Vif0/Vif1 Misc Functions
33 //------------------------------------------------------------------
34
35 static _f void vifFlush(int idx) {
36 if (!idx) vif0FLUSH();
37 else vif1FLUSH();
38 }
39
40 static _f void vuExecMicro(int idx, u32 addr) {
41 VURegs* VU = nVif[idx].VU;
42 vifFlush(idx);
43
44 if (VU->vifRegs->itops > (idx ? 0x3ffu : 0xffu)) {
45 Console.WriteLn("VIF%d ITOP overrun! %x", idx, VU->vifRegs->itops);
46 VU->vifRegs->itops &= (idx ? 0x3ffu : 0xffu);
47 }
48
49 VU->vifRegs->itop = VU->vifRegs->itops;
50
51 if (idx) {
52 // in case we're handling a VIF1 execMicro, set the top with the tops value
53 VU->vifRegs->top = VU->vifRegs->tops & 0x3ff;
54
55 // is DBF flag set in VIF_STAT?
56 if (VU->vifRegs->stat.DBF) {
57 // it is, so set tops with base, and clear the stat DBF flag
58 VU->vifRegs->tops = VU->vifRegs->base;
59 VU->vifRegs->stat.DBF = false;
60 }
61 else {
62 // it is not, so set tops with base + offset, and set stat DBF flag
63 VU->vifRegs->tops = VU->vifRegs->base + VU->vifRegs->ofst;
64 VU->vifRegs->stat.DBF = true;
65 }
66 }
67
68 if (!idx) vu0ExecMicro(addr);
69 else vu1ExecMicro(addr);
70 }
71
72 u8 schedulepath3msk = 0;
73
74 void Vif1MskPath3() {
75
76 vif1Regs->mskpath3 = schedulepath3msk & 0x1;
77 //Console.WriteLn("VIF MSKPATH3 %x", vif1Regs->mskpath3);
78 gifRegs->stat.M3P = vif1Regs->mskpath3;
79 if (!vif1Regs->mskpath3) {
80 //Let the Gif know it can transfer again (making sure any vif stall isnt unset prematurely)
81 if(gif->chcr.STR == true)
82 {
83 GSTransferStatus.PTH3 = 3;
84 CPU_INT(DMAC_GIF, 4);
85 }
86
87 }
88
89 schedulepath3msk = 0;
90 }
91
92 //------------------------------------------------------------------
93 // Vif0/Vif1 Code Implementations
94 //------------------------------------------------------------------
95
96 vifOp(vifCode_Base) {
97 vif1Only();
98 pass1 { vif1Regs->base = vif1Regs->code & 0x3ff; vif1.cmd = 0; }
99 pass3 { DevCon.WriteLn("vifCode_Base"); }
100 return 0;
101 }
102
103 template<int idx> _f int _vifCode_Direct(int pass, u8* data, bool isDirectHL) {
104 pass1 {
105 vif1Only();
106 int vifImm = (u16)vif1Regs->code;
107 vif1.tag.size = vifImm ? (vifImm*4) : (65536*4);
108 return 1;
109 }
110 pass2 {
111 vif1Only();
112 //return vifTrans_DirectHL<idx>((u32*)data);
113 gifRegs->stat.P2Q = true;
114 //Should probably do this for both types of transfer seen as the GS hates taking 2 seperate chunks
115 //if (isDirectHL) {
116 if (GSTransferStatus.PTH3 < STOPPED_MODE || GSTransferStatus.PTH1 != STOPPED_MODE)
117 {
118 /*if(!isDirectHL) DevCon.WriteLn("Direct: Waiting for Path3 to finish!");
119 else DevCon.WriteLn("DirectHL: Waiting for Path3 to finish!");*/
120 //VIF_LOG("Mask %x, GIF STR %x, PTH1 %x, PTH2 %x, PTH3 %x", vif1Regs->mskpath3, gif->chcr.STR, GSTransferStatus.PTH1, GSTransferStatus.PTH2, GSTransferStatus.PTH3);
121 vif1Regs->stat.VGW = true; // PATH3 is in image mode, so wait for end of transfer
122 vif1.vifstalled = true;
123 return 0;
124 }
125 //}
126 gifRegs->stat.clear_flags(GIF_STAT_P2Q);
127
128 Registers::Freeze();
129 nVifStruct& v = nVif[1];
130 const int ret = aMin(vif1.vifpacketsize, vif1.tag.size);
131 u32 size = ret << 2;
132
133 gifRegs->stat.APATH = GIF_APATH2; //Flag is cleared in vif1interrupt to simulate it being in progress.
134
135 if (ret == v.vif->tag.size) { // Full Transfer
136 if (v.bSize) { // Last transfer was partial
137 memcpy_fast(&v.buffer[v.bSize], data, size);
138 v.bSize += size;
139 data = v.buffer;
140 size = v.bSize;
141 }
142 if (!size) { DevCon.WriteLn("Path2: No Data Transfer?"); }
143 const uint count = GetMTGS().PrepDataPacket(GIF_PATH_2, data, size >> 4);
144 memcpy_fast(GetMTGS().GetDataPacketPtr(), data, count << 4);
145 GetMTGS().SendDataPacket();
146 vif1.tag.size = 0;
147 vif1.cmd = 0;
148 v.bSize = 0;
149 }
150 else { // Partial Transfer
151 //DevCon.WriteLn("DirectHL: Partial Transfer [%d]", size);
152 memcpy_fast(&v.buffer[v.bSize], data, size);
153 v.bSize += size;
154 vif1.tag.size -= ret;
155 }
156
157 Registers::Thaw();
158 return ret;
159 }
160 return 0;
161 }
162
163 vifOp(vifCode_Direct) {
164 pass3 { DevCon.WriteLn("vifCode_Direct"); }
165 return _vifCode_Direct<idx>(pass, (u8*)data, 0);
166 }
167
168 vifOp(vifCode_DirectHL) {
169 pass3 { DevCon.WriteLn("vifCode_DirectHL"); }
170 return _vifCode_Direct<idx>(pass, (u8*)data, 1);
171 }
172
173 // ToDo: FixMe
174 vifOp(vifCode_Flush) {
175 vif1Only();
176 pass1 { vifFlush(idx); vifX.cmd = 0; }
177 pass3 { DevCon.WriteLn("vifCode_Flush"); }
178 return 0;
179 }
180
181 // ToDo: FixMe
182 vifOp(vifCode_FlushA) {
183 vif1Only();
184 pass1 {
185 // Gif is already transferring so wait for it.
186 if (GSTransferStatus.PTH3 < STOPPED_MODE) {
187 //DevCon.WriteLn("FlushA path3 Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);
188 vif1Regs->stat.VGW = true;
189 vifX.vifstalled = true;
190 }
191 vifFlush(idx);
192 vifX.cmd = 0;
193 }
194 pass3 { DevCon.WriteLn("vifCode_FlushA"); }
195 return 0;
196 }
197
198 // ToDo: FixMe
199 vifOp(vifCode_FlushE) {
200 pass1 { vifFlush(idx); vifX.cmd = 0; }
201 pass3 { DevCon.WriteLn("vifCode_FlushE"); }
202 return 0;
203 }
204
205 vifOp(vifCode_ITop) {
206 pass1 { vifXRegs->itops = vifXRegs->code & 0x3ff; vifX.cmd = 0; }
207 pass3 { DevCon.WriteLn("vifCode_ITop"); }
208 return 0;
209 }
210
211 vifOp(vifCode_Mark) {
212 pass1 {
213 vifXRegs->mark = (u16)vifXRegs->code;
214 vifXRegs->stat.MRK = true;
215 vifX.cmd = 0;
216 }
217 pass3 { DevCon.WriteLn("vifCode_Mark"); }
218 return 0;
219 }
220
221 _f void _vifCode_MPG(int idx, u32 addr, u32 *data, int size) {
222 VURegs& VUx = idx ? VU1 : VU0;
223 pxAssume(VUx.Micro > 0);
224
225 if (memcmp(VUx.Micro + addr, data, size << 2)) {
226 if (!idx) CpuVU0->Clear(addr, size << 2); // Clear before writing!
227 else CpuVU1->Clear(addr, size << 2); // Clear before writing!
228 memcpy_fast(VUx.Micro + addr, data, size << 2);
229 }
230 }
231
232 vifOp(vifCode_MPG) {
233 pass1 {
234 int vifNum = (u8)(vifXRegs->code >> 16);
235 vifX.tag.addr = (u16)(vifXRegs->code << 3) & (idx ? 0x3fff : 0xfff);
236 vifX.tag.size = vifNum ? (vifNum*2) : 512;
237 return 1;
238 }
239 pass2 {
240 vifFlush(idx);
241 if (vifX.vifpacketsize < vifX.tag.size) { // Partial Transfer
242 if((vifX.tag.addr + vifX.vifpacketsize) > (idx ? 0x4000 : 0x1000)) {
243 DevCon.Warning("Vif%d MPG Split Overflow", idx);
244 }
245 _vifCode_MPG(idx, vifX.tag.addr, data, vifX.vifpacketsize);
246 vifX.tag.addr += vifX.vifpacketsize << 2;
247 vifX.tag.size -= vifX.vifpacketsize;
248 return vifX.vifpacketsize;
249 }
250 else { // Full Transfer
251 if((vifX.tag.addr + vifX.tag.size) > (idx ? 0x4000 : 0x1000)) {
252 DevCon.Warning("Vif%d MPG Split Overflow", idx);
253 }
254 _vifCode_MPG(idx, vifX.tag.addr, data, vifX.tag.size);
255 int ret = vifX.tag.size;
256 vifX.tag.size = 0;
257 vifX.cmd = 0;
258 return ret;
259 }
260 }
261 pass3 { DevCon.WriteLn("vifCode_MPG"); }
262 return 0;
263 }
264
265 vifOp(vifCode_MSCAL) {
266 pass1 { vuExecMicro(idx, (u16)(vifXRegs->code) << 3); vifX.cmd = 0; }
267 pass3 { DevCon.WriteLn("vifCode_MSCAL"); }
268 return 0;
269 }
270
271 vifOp(vifCode_MSCALF) {
272 pass1 { vuExecMicro(idx, (u16)(vifXRegs->code) << 3); vifX.cmd = 0; }
273 pass3 { DevCon.WriteLn("vifCode_MSCALF"); }
274 return 0;
275 }
276
277 vifOp(vifCode_MSCNT) {
278 pass1 { vuExecMicro(idx, -1); vifX.cmd = 0; }
279 pass3 { DevCon.WriteLn("vifCode_MSCNT"); }
280 return 0;
281 }
282
283 // ToDo: FixMe
284 vifOp(vifCode_MskPath3) {
285 vif1Only();
286 pass1 {
287 if (vif1ch->chcr.STR) {
288 schedulepath3msk = 0x10 | ((vif1Regs->code >> 15) & 0x1);
289 vif1.vifstalled = true;
290 }
291 else {
292 schedulepath3msk = (vif1Regs->code >> 15) & 0x1;
293 Vif1MskPath3();
294 }
295 vifX.cmd = 0;
296 }
297 pass3 { DevCon.WriteLn("vifCode_MskPath3"); }
298 return 0;
299 }
300
301 vifOp(vifCode_Nop) {
302 pass1 { vifX.cmd = 0; }
303 pass3 { DevCon.WriteLn("vifCode_Nop"); }
304 return 0;
305 }
306
307 // ToDo: Review Flags
308 vifOp(vifCode_Null) {
309 pass1 {
310 // if ME1, then force the vif to interrupt
311 if (!(vifXRegs->err.ME1)) { // Ignore vifcode and tag mismatch error
312 Console.WriteLn("Vif%d: Unknown VifCmd! [%x]", idx, vifX.cmd);
313 vifXRegs->stat.ER1 = true;
314 vifX.vifstalled = true;
315 //vifX.irq++;
316 }
317 vifX.cmd = 0;
318 }
319 pass2 { Console.Error("Vif%d bad vifcode! [CMD = %x]", idx, vifX.cmd); }
320 pass3 { DevCon.WriteLn("vifCode_Null"); }
321 return 0;
322 }
323
324 vifOp(vifCode_Offset) {
325 vif1Only();
326 pass1 {
327 vif1Regs->stat.DBF = false;
328 vif1Regs->ofst = vif1Regs->code & 0x3ff;
329 vif1Regs->tops = vif1Regs->base;
330 vifX.cmd = 0;
331 }
332 pass3 { DevCon.WriteLn("vifCode_Offset"); }
333 return 0;
334 }
335
336 template<int idx> _f int _vifCode_STColRow(u32* data, u32* pmem1, u32* pmem2) {
337 int ret;
338 ret = min(4 - vifX.tag.addr, vifX.vifpacketsize);
339 pxAssume(vifX.tag.addr < 4);
340 pxAssume(ret > 0);
341
342 switch (ret) {
343 case 4:
344 pmem1[12] = data[3];
345 pmem2[3] = data[3];
346 case 3:
347 pmem1[8] = data[2];
348 pmem2[2] = data[2];
349 case 2:
350 pmem1[4] = data[1];
351 pmem2[1] = data[1];
352 case 1:
353 pmem1[0] = data[0];
354 pmem2[0] = data[0];
355 break;
356 jNO_DEFAULT
357 }
358
359 vifX.tag.addr += ret;
360 vifX.tag.size -= ret;
361 if (!vifX.tag.size) vifX.cmd = 0;
362
363 return ret;
364 }
365
366 vifOp(vifCode_STCol) {
367 pass1 {
368 vifX.tag.addr = 0;
369 vifX.tag.size = 4;
370 return 1;
371 }
372 pass2 {
373 u32* cols = idx ? g_vifmask.Col1 : g_vifmask.Col0;
374 u32* pmem1 = &vifXRegs->c0 + (vifX.tag.addr << 2);
375 u32* pmem2 = cols + vifX.tag.addr;
376 return _vifCode_STColRow<idx>(data, pmem1, pmem2);
377 }
378 pass3 { DevCon.WriteLn("vifCode_STCol"); }
379 return 0;
380 }
381
382 vifOp(vifCode_STRow) {
383 pass1 {
384 vifX.tag.addr = 0;
385 vifX.tag.size = 4;
386 return 1;
387 }
388 pass2 {
389 u32* rows = idx ? g_vifmask.Row1 : g_vifmask.Row0;
390 u32* pmem1 = &vifXRegs->r0 + (vifX.tag.addr << 2);
391 u32* pmem2 = rows + vifX.tag.addr;
392 return _vifCode_STColRow<idx>(data, pmem1, pmem2);
393 }
394 pass3 { DevCon.WriteLn("vifCode_STRow"); }
395 return 0;
396 }
397
398 vifOp(vifCode_STCycl) {
399 pass1 {
400 vifXRegs->cycle.cl = (u8)(vifXRegs->code);
401 vifXRegs->cycle.wl = (u8)(vifXRegs->code >> 8);
402 vifX.cmd = 0;
403 }
404 pass3 { DevCon.WriteLn("vifCode_STCycl"); }
405 return 0;
406 }
407
408 vifOp(vifCode_STMask) {
409 pass1 { vifX.tag.size = 1; }
410 pass2 { vifXRegs->mask = data[0]; vifX.tag.size = 0; vifX.cmd = 0; }
411 pass3 { DevCon.WriteLn("vifCode_STMask"); }
412 return 1;
413 }
414
415 vifOp(vifCode_STMod) {
416 pass1 { vifXRegs->mode = vifXRegs->code & 0x3; vifX.cmd = 0; }
417 pass3 { DevCon.WriteLn("vifCode_STMod"); }
418 return 0;
419 }
420
421 vifOp(vifCode_Unpack) {
422 pass1 {
423 if (!idx) vif0UnpackSetup(data);
424 else vif1UnpackSetup(data);
425 return 1;
426 }
427 pass2 { return nVifUnpack(idx, (u8*)data); }
428 pass3 { DevCon.WriteLn("vifCode_Unpack"); }
429 return 0;
430 }
431
432 //------------------------------------------------------------------
433 // Vif0/Vif1 Code Tables
434 //------------------------------------------------------------------
435
436 int (__fastcall *vif0Code[128])(int pass, u32 *data) = {
437 vifCode_Nop<0> , vifCode_STCycl<0> , vifCode_Offset<0> , vifCode_Base<0> , vifCode_ITop<0> , vifCode_STMod<0> , vifCode_MskPath3<0>, vifCode_Mark<0>, /*0x00*/
438 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x08*/
439 vifCode_FlushE<0> , vifCode_Flush<0> , vifCode_Null<0> , vifCode_FlushA<0> , vifCode_MSCAL<0> , vifCode_MSCALF<0> , vifCode_Null<0> , vifCode_MSCNT<0>, /*0x10*/
440 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x18*/
441 vifCode_STMask<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x20*/
442 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x28*/
443 vifCode_STRow<0> , vifCode_STCol<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x30*/
444 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x38*/
445 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x40*/
446 vifCode_Null<0> , vifCode_Null<0> , vifCode_MPG<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x48*/
447 vifCode_Direct<0> , vifCode_DirectHL<0>, vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x50*/
448 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x58*/
449 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Null<0>, /*0x60*/
450 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0>, /*0x68*/
451 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Null<0>, /*0x70*/
452 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Null<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> /*0x78*/
453 };
454
455 int (__fastcall *vif1Code[128])(int pass, u32 *data) = {
456 vifCode_Nop<1> , vifCode_STCycl<1> , vifCode_Offset<1> , vifCode_Base<1> , vifCode_ITop<1> , vifCode_STMod<1> , vifCode_MskPath3<1>, vifCode_Mark<1>, /*0x00*/
457 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x08*/
458 vifCode_FlushE<1> , vifCode_Flush<1> , vifCode_Null<1> , vifCode_FlushA<1> , vifCode_MSCAL<1> , vifCode_MSCALF<1> , vifCode_Null<1> , vifCode_MSCNT<1>, /*0x10*/
459 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x18*/
460 vifCode_STMask<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x20*/
461 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x28*/
462 vifCode_STRow<1> , vifCode_STCol<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x30*/
463 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x38*/
464 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x40*/
465 vifCode_Null<1> , vifCode_Null<1> , vifCode_MPG<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x48*/
466 vifCode_Direct<1> , vifCode_DirectHL<1>, vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x50*/
467 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x58*/
468 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Null<1>, /*0x60*/
469 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1>, /*0x68*/
470 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Null<1>, /*0x70*/
471 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Null<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> /*0x78*/
472 };

  ViewVC Help
Powered by ViewVC 1.1.22