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

Annotation of /trunk/pcsx2/Vif_Codes.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 273 - (hide annotations) (download)
Fri Nov 12 01:10:22 2010 UTC (9 years, 7 months ago) by william
File size: 20364 byte(s)
Auto Commited Import of: pcsx2-0.9.7-DEBUG (upstream: v0.9.7.4013 local: v0.9.7.197-latest) in ./trunk
1 william 31 /* 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 william 62 #define vifOp(vifCodeName) _vifT int __fastcall vifCodeName(int pass, const u32 *data)
25 william 31 #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 william 62 static __fi void vifFlush(int idx) {
36 william 31 if (!idx) vif0FLUSH();
37     else vif1FLUSH();
38     }
39    
40 william 62 static __fi void vuExecMicro(int idx, u32 addr) {
41 william 191 VIFregisters& vifRegs = vifXRegs;
42 william 62 int startcycles = 0;
43     //vifFlush(idx);
44 william 31
45 william 62 //if(vifX.vifstalled == true) return;
46    
47     if (vifRegs.itops > (idx ? 0x3ffu : 0xffu)) {
48     Console.WriteLn("VIF%d ITOP overrun! %x", idx, vifRegs.itops);
49     vifRegs.itops &= (idx ? 0x3ffu : 0xffu);
50 william 31 }
51    
52 william 62 vifRegs.itop = vifRegs.itops;
53 william 31
54     if (idx) {
55     // in case we're handling a VIF1 execMicro, set the top with the tops value
56 william 62 vifRegs.top = vifRegs.tops & 0x3ff;
57 william 31
58     // is DBF flag set in VIF_STAT?
59 william 62 if (vifRegs.stat.DBF) {
60 william 31 // it is, so set tops with base, and clear the stat DBF flag
61 william 62 vifRegs.tops = vifRegs.base;
62     vifRegs.stat.DBF = false;
63 william 31 }
64     else {
65     // it is not, so set tops with base + offset, and set stat DBF flag
66 william 62 vifRegs.tops = vifRegs.base + vifRegs.ofst;
67     vifRegs.stat.DBF = true;
68 william 31 }
69     }
70    
71 william 62 if(!idx)startcycles = VU0.cycle;
72     else startcycles = VU1.cycle;
73    
74 william 31 if (!idx) vu0ExecMicro(addr);
75     else vu1ExecMicro(addr);
76 william 62
77     if(!idx) { g_vu0Cycles += (VU0.cycle-startcycles) * BIAS; g_packetsizeonvu = vif0.vifpacketsize; }
78     else { g_vu1Cycles += (VU1.cycle-startcycles) * BIAS; g_packetsizeonvu = vif1.vifpacketsize; }
79     //DevCon.Warning("Ran VU%x, VU0 Cycles %x, VU1 Cycles %x", idx, g_vu0Cycles, g_vu1Cycles);
80     GetVifX.vifstalled = true;
81 william 31 }
82    
83     u8 schedulepath3msk = 0;
84    
85     void Vif1MskPath3() {
86    
87 william 62 vif1Regs.mskpath3 = schedulepath3msk & 0x1;
88     GIF_LOG("VIF MSKPATH3 %x gif str %x path3 status %x", vif1Regs.mskpath3, gifch.chcr.STR, GSTransferStatus.PTH3);
89     gifRegs.stat.M3P = vif1Regs.mskpath3;
90    
91     if (!vif1Regs.mskpath3)
92     {
93     //if(GSTransferStatus.PTH3 > TRANSFER_MODE && gif->chcr.STR) GSTransferStatus.PTH3 = TRANSFER_MODE;
94     //DevCon.Warning("Mask off");
95     //if(GSTransferStatus.PTH3 >= PENDINGSTOP_MODE) GSTransferStatus.PTH3 = IDLE_MODE;
96     if(gifRegs.stat.P3Q)
97 william 31 {
98 william 62 gsInterrupt();//gsInterrupt();
99 william 31 }
100 william 62
101     }// else if(!gif->chcr.STR && GSTransferStatus.PTH3 == IDLE_MODE) GSTransferStatus.PTH3 = STOPPED_MODE;//else DevCon.Warning("Mask on");
102 william 31
103     schedulepath3msk = 0;
104     }
105    
106     //------------------------------------------------------------------
107     // Vif0/Vif1 Code Implementations
108     //------------------------------------------------------------------
109    
110     vifOp(vifCode_Base) {
111     vif1Only();
112 william 62 pass1 { vif1Regs.base = vif1Regs.code & 0x3ff; vif1.cmd = 0; }
113     pass3 { VifCodeLog("Base"); }
114 william 31 return 0;
115     }
116    
117 william 62 extern bool SIGNAL_IMR_Pending;
118    
119     template<int idx> __fi int _vifCode_Direct(int pass, const u8* data, bool isDirectHL) {
120 william 31 pass1 {
121     vif1Only();
122 william 62 int vifImm = (u16)vif1Regs.code;
123 william 31 vif1.tag.size = vifImm ? (vifImm*4) : (65536*4);
124 william 62 vif1.vifstalled = true;
125     gifRegs.stat.P2Q = true;
126     if (gifRegs.stat.PSE) // temporarily stop
127     {
128     Console.WriteLn("Gif dma temp paused? VIF DIRECT");
129     vif1.GifWaitState = 3;
130     vif1Regs.stat.VGW = true;
131     }
132     //Should cause this to split here to try and time PATH3 right.
133     return 0;
134 william 31 }
135     pass2 {
136     vif1Only();
137 william 62
138     if (GSTransferStatus.PTH3 < IDLE_MODE || gifRegs.stat.P1Q == true)
139 william 31 {
140 william 62 if(gifRegs.stat.APATH == GIF_APATH2 || ((GSTransferStatus.PTH3 <= IMAGE_MODE && gifRegs.stat.IMT && (vif1.cmd & 0x7f) == 0x50)) && gifRegs.stat.P1Q == false)
141     {
142     //Do nothing, allow it
143     vif1Regs.stat.VGW = false;
144     //if(gifRegs.stat.APATH != GIF_APATH2)DevCon.Warning("Continue DIRECT/HL %x P3 %x APATH %x P1Q %x", vif1.cmd, GSTransferStatus.PTH3, gifRegs.stat.APATH, gifRegs.stat.P1Q);
145     }
146     else
147     {
148     //DevCon.Warning("Stall DIRECT/HL %x P3 %x APATH %x P1Q %x", vif1.cmd, GSTransferStatus.PTH3, gifRegs.stat.APATH, gifRegs.stat.P1Q);
149     vif1Regs.stat.VGW = true; // PATH3 is in image mode (DIRECTHL), or busy (BOTH no IMT)
150     vif1.GifWaitState = 0;
151     vif1.vifstalled = true;
152     return 0;
153     }
154     }
155     if(SIGNAL_IMR_Pending == true)
156     {
157     DevCon.Warning("Path 2 Paused (At start)");
158 william 31 vif1.vifstalled = true;
159     return 0;
160     }
161 william 62 if (gifRegs.stat.PSE) // temporarily stop
162     {
163     Console.WriteLn("Gif dma temp paused? VIF DIRECT");
164     vif1.GifWaitState = 3;
165     vif1.vifstalled = true;
166     vif1Regs.stat.VGW = true;
167     return 0;
168     }
169 william 31
170 william 62 // HACK ATTACK!
171     // we shouldn't be clearing the queue flag here at all. Ideally, the queue statuses
172     // should be checked, handled, and cleared from the EOP check in GIFPath only. --air
173     gifRegs.stat.clear_flags(GIF_STAT_P2Q);
174 william 31
175 william 62 uint minSize = aMin(vif1.vifpacketsize, vif1.tag.size);
176     uint ret;
177 william 31
178 william 62 if(minSize < 4)
179     {
180     // When TTE==1, the VIF might end up sending us 8-byte packets instead of the usual 16-byte
181     // variety, if DIRECT tags cross chain dma boundaries. The actual behavior of real hardware
182     // is unknown at this time, but it seems that games *only* ever try to upload zero'd data
183     // in this situation.
184     //
185     // Games that use TTE==1 and DIRECT in this fashion: ICO
186     //
187     // Because DIRECT normally has a strict QWC alignment requirement, and this funky behavior
188     // only seems to happen on TTE mode transfers with their split-64-bit packets, there shouldn't
189     // be any need to worry about queuing more than 16 bytes of data,
190     //
191    
192     static __aligned16 u32 partial_write[4];
193     static uint partial_count = 0;
194    
195     for( uint i=0; i<(minSize & 3); ++i)
196     partial_write[partial_count++] = ((u32*)data)[i];
197    
198     pxAssume( partial_count <= 4 );
199     ret = 0;
200     if (partial_count == 4)
201     {
202     GetMTGS().PrepDataPacket(GIF_PATH_2, 1);
203     GIFPath_CopyTag(GIF_PATH_2, (u128*)partial_write, 1);
204     GetMTGS().SendDataPacket();
205     partial_count = 0;
206     ret = 4;
207 william 31 }
208 william 62 }
209     else
210     {
211     if (!minSize)
212     DevCon.Warning("VIF DIRECT (PATH2): No Data Transfer?");
213    
214     // TTE=1 mode is the only time we should be getting DIRECT packet sizes that are
215     // not a multiple of QWC, and those are assured to be under 128 bits in size.
216     // So if this assert is triggered then it probably means something else is amiss.
217     pxAssertMsg((minSize & 3) == 0, "DIRECT packet size is not a multiple of QWC." );
218    
219     GetMTGS().PrepDataPacket(GIF_PATH_2, minSize/4);
220     ret = GIFPath_CopyTag(GIF_PATH_2, (u128*)data, minSize/4)*4;
221 william 31 GetMTGS().SendDataPacket();
222 william 62 }
223    
224     vif1.tag.size -= ret;
225    
226     if(vif1.tag.size == 0)
227     {
228 william 31 vif1.cmd = 0;
229     }
230 william 62 vif1.vifstalled = true;
231 william 31 return ret;
232     }
233     return 0;
234     }
235    
236     vifOp(vifCode_Direct) {
237 william 62 pass3 { VifCodeLog("Direct"); }
238 william 31 return _vifCode_Direct<idx>(pass, (u8*)data, 0);
239     }
240    
241     vifOp(vifCode_DirectHL) {
242 william 62 pass3 { VifCodeLog("DirectHL"); }
243 william 31 return _vifCode_Direct<idx>(pass, (u8*)data, 1);
244     }
245    
246     // ToDo: FixMe
247     vifOp(vifCode_Flush) {
248     vif1Only();
249 william 62 vifStruct& vifX = GetVifX;
250     pass1 { vifFlush(idx); vifX.cmd = 0; }
251     pass3 { VifCodeLog("Flush"); }
252 william 31 return 0;
253     }
254    
255     // ToDo: FixMe
256     vifOp(vifCode_FlushA) {
257     vif1Only();
258 william 62 vifStruct& vifX = GetVifX;
259 william 31 pass1 {
260 william 62 vifFlush(idx);
261 william 31 // Gif is already transferring so wait for it.
262 william 62 if (gifRegs.stat.P1Q || GSTransferStatus.PTH3 <= PENDINGSTOP_MODE) {
263     //DevCon.Warning("VIF FlushA Wait MSK = %x", vif1Regs.mskpath3);
264     //
265    
266 william 31 //DevCon.WriteLn("FlushA path3 Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);
267 william 62 vif1Regs.stat.VGW = true;
268     vifX.GifWaitState = 1;
269 william 31 vifX.vifstalled = true;
270 william 62 } // else DevCon.WriteLn("FlushA path3 no Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);
271    
272 william 31 vifX.cmd = 0;
273     }
274 william 62 pass3 { VifCodeLog("FlushA"); }
275 william 31 return 0;
276     }
277    
278     // ToDo: FixMe
279     vifOp(vifCode_FlushE) {
280 william 62 vifStruct& vifX = GetVifX;
281 william 31 pass1 { vifFlush(idx); vifX.cmd = 0; }
282 william 62 pass3 { VifCodeLog("FlushE"); }
283 william 31 return 0;
284     }
285    
286     vifOp(vifCode_ITop) {
287 william 62 pass1 { vifXRegs.itops = vifXRegs.code & 0x3ff; GetVifX.cmd = 0; }
288     pass3 { VifCodeLog("ITop"); }
289 william 31 return 0;
290     }
291    
292     vifOp(vifCode_Mark) {
293 william 62 vifStruct& vifX = GetVifX;
294 william 31 pass1 {
295 william 62 vifXRegs.mark = (u16)vifXRegs.code;
296     vifXRegs.stat.MRK = true;
297 william 31 vifX.cmd = 0;
298     }
299 william 62 pass3 { VifCodeLog("Mark"); }
300 william 31 return 0;
301     }
302    
303 william 62 static __fi void _vifCode_MPG(int idx, u32 addr, const u32 *data, int size) {
304 william 31 VURegs& VUx = idx ? VU1 : VU0;
305     pxAssume(VUx.Micro > 0);
306    
307 william 62 if (memcmp_mmx(VUx.Micro + addr, data, size*4)) {
308     // Clear VU memory before writing!
309     // (VUs expect size to be 32-bit scale, same as VIF's internal working sizes)
310     if (!idx) CpuVU0->Clear(addr, size);
311     else CpuVU1->Clear(addr, size);
312     memcpy_fast(VUx.Micro + addr, data, size*4);
313 william 31 }
314     }
315    
316     vifOp(vifCode_MPG) {
317 william 62 vifStruct& vifX = GetVifX;
318 william 31 pass1 {
319 william 62 int vifNum = (u8)(vifXRegs.code >> 16);
320     vifX.tag.addr = (u16)(vifXRegs.code << 3) & (idx ? 0x3fff : 0xfff);
321 william 31 vifX.tag.size = vifNum ? (vifNum*2) : 512;
322 william 62 //vifFlush(idx);
323 william 31 return 1;
324     }
325     pass2 {
326     if (vifX.vifpacketsize < vifX.tag.size) { // Partial Transfer
327 william 62 if((vifX.tag.addr + vifX.vifpacketsize*4) > (idx ? 0x4000 : 0x1000)) {
328 william 31 DevCon.Warning("Vif%d MPG Split Overflow", idx);
329     }
330     _vifCode_MPG(idx, vifX.tag.addr, data, vifX.vifpacketsize);
331 william 62 vifX.tag.addr += vifX.vifpacketsize * 4;
332 william 31 vifX.tag.size -= vifX.vifpacketsize;
333     return vifX.vifpacketsize;
334     }
335     else { // Full Transfer
336 william 62 if((vifX.tag.addr + vifX.tag.size*4) > (idx ? 0x4000 : 0x1000)) {
337 william 31 DevCon.Warning("Vif%d MPG Split Overflow", idx);
338     }
339     _vifCode_MPG(idx, vifX.tag.addr, data, vifX.tag.size);
340     int ret = vifX.tag.size;
341     vifX.tag.size = 0;
342     vifX.cmd = 0;
343     return ret;
344     }
345     }
346 william 62 pass3 { VifCodeLog("MPG"); }
347 william 31 return 0;
348     }
349    
350     vifOp(vifCode_MSCAL) {
351 william 62 vifStruct& vifX = GetVifX;
352     pass1 { vifFlush(idx); vuExecMicro(idx, (u16)(vifXRegs.code) << 3); vifX.cmd = 0;}
353     pass3 { VifCodeLog("MSCAL"); }
354 william 31 return 0;
355     }
356    
357     vifOp(vifCode_MSCALF) {
358 william 62 vifStruct& vifX = GetVifX;
359     pass1 { vifFlush(idx); vuExecMicro(idx, (u16)(vifXRegs.code) << 3); vifX.cmd = 0; }
360     pass3 { VifCodeLog("MSCALF"); }
361 william 31 return 0;
362     }
363    
364     vifOp(vifCode_MSCNT) {
365 william 62 vifStruct& vifX = GetVifX;
366     pass1 { vifFlush(idx); vuExecMicro(idx, -1); vifX.cmd = 0; }
367     pass3 { VifCodeLog("MSCNT"); }
368 william 31 return 0;
369     }
370    
371     // ToDo: FixMe
372     vifOp(vifCode_MskPath3) {
373     vif1Only();
374     pass1 {
375 william 62 if (vif1ch.chcr.STR && vif1.lastcmd != 0x13) {
376     schedulepath3msk = 0x10 | ((vif1Regs.code >> 15) & 0x1);
377 william 31 vif1.vifstalled = true;
378     }
379     else {
380 william 62 schedulepath3msk = (vif1Regs.code >> 15) & 0x1;
381 william 31 Vif1MskPath3();
382     }
383 william 62 vif1.cmd = 0;
384 william 31 }
385 william 62 pass3 { VifCodeLog("MskPath3"); }
386 william 31 return 0;
387     }
388    
389     vifOp(vifCode_Nop) {
390 william 62 pass1 { GetVifX.cmd = 0; }
391     pass3 { VifCodeLog("Nop"); }
392 william 31 return 0;
393     }
394    
395     // ToDo: Review Flags
396     vifOp(vifCode_Null) {
397 william 62 vifStruct& vifX = GetVifX;
398 william 31 pass1 {
399     // if ME1, then force the vif to interrupt
400 william 62 if (!(vifXRegs.err.ME1)) { // Ignore vifcode and tag mismatch error
401 william 31 Console.WriteLn("Vif%d: Unknown VifCmd! [%x]", idx, vifX.cmd);
402 william 62 vifXRegs.stat.ER1 = true;
403     vifX.vifstalled = true;
404 william 31 //vifX.irq++;
405     }
406     vifX.cmd = 0;
407     }
408     pass2 { Console.Error("Vif%d bad vifcode! [CMD = %x]", idx, vifX.cmd); }
409 william 62 pass3 { VifCodeLog("Null"); }
410 william 31 return 0;
411     }
412    
413     vifOp(vifCode_Offset) {
414     vif1Only();
415     pass1 {
416 william 62 vif1Regs.stat.DBF = false;
417     vif1Regs.ofst = vif1Regs.code & 0x3ff;
418     vif1Regs.tops = vif1Regs.base;
419     vif1.cmd = 0;
420 william 31 }
421 william 62 pass3 { VifCodeLog("Offset"); }
422 william 31 return 0;
423     }
424    
425 william 191 template<int idx> static __fi int _vifCode_STColRow(const u32* data, u32* pmem2) {
426 william 62 vifStruct& vifX = GetVifX;
427    
428     int ret = min(4 - vifX.tag.addr, vifX.vifpacketsize);
429 william 31 pxAssume(vifX.tag.addr < 4);
430     pxAssume(ret > 0);
431    
432     switch (ret) {
433     case 4:
434     pmem2[3] = data[3];
435     case 3:
436     pmem2[2] = data[2];
437     case 2:
438     pmem2[1] = data[1];
439     case 1:
440     pmem2[0] = data[0];
441     break;
442     jNO_DEFAULT
443     }
444    
445     vifX.tag.addr += ret;
446     vifX.tag.size -= ret;
447     if (!vifX.tag.size) vifX.cmd = 0;
448    
449     return ret;
450     }
451    
452     vifOp(vifCode_STCol) {
453 william 62 vifStruct& vifX = GetVifX;
454 william 31 pass1 {
455     vifX.tag.addr = 0;
456     vifX.tag.size = 4;
457     return 1;
458     }
459     pass2 {
460 william 191 return _vifCode_STColRow<idx>(data, &vifX.MaskCol._u32[vifX.tag.addr]);
461 william 31 }
462 william 62 pass3 { VifCodeLog("STCol"); }
463 william 31 return 0;
464     }
465    
466     vifOp(vifCode_STRow) {
467 william 62 vifStruct& vifX = GetVifX;
468    
469 william 31 pass1 {
470     vifX.tag.addr = 0;
471     vifX.tag.size = 4;
472     return 1;
473     }
474     pass2 {
475 william 191 return _vifCode_STColRow<idx>(data, &vifX.MaskRow._u32[vifX.tag.addr]);
476 william 31 }
477 william 62 pass3 { VifCodeLog("STRow"); }
478 william 31 return 0;
479     }
480    
481     vifOp(vifCode_STCycl) {
482 william 62 vifStruct& vifX = GetVifX;
483 william 31 pass1 {
484 william 62 vifXRegs.cycle.cl = (u8)(vifXRegs.code);
485     vifXRegs.cycle.wl = (u8)(vifXRegs.code >> 8);
486 william 31 vifX.cmd = 0;
487     }
488 william 62 pass3 { VifCodeLog("STCycl"); }
489 william 31 return 0;
490     }
491    
492     vifOp(vifCode_STMask) {
493 william 62 vifStruct& vifX = GetVifX;
494 william 31 pass1 { vifX.tag.size = 1; }
495 william 62 pass2 { vifXRegs.mask = data[0]; vifX.tag.size = 0; vifX.cmd = 0; }
496     pass3 { VifCodeLog("STMask"); }
497 william 31 return 1;
498     }
499    
500     vifOp(vifCode_STMod) {
501 william 62 pass1 { vifXRegs.mode = vifXRegs.code & 0x3; GetVifX.cmd = 0; }
502     pass3 { VifCodeLog("STMod"); }
503 william 31 return 0;
504     }
505    
506 william 273 template< uint idx >
507     static uint calc_addr(bool flg)
508     {
509     VIFregisters& vifRegs = vifXRegs;
510    
511     uint retval = vifRegs.code;
512     if (idx && flg) retval += vifRegs.tops;
513     return retval & (idx ? 0x3ff : 0xff);
514     }
515    
516 william 31 vifOp(vifCode_Unpack) {
517     pass1 {
518 william 191 vifUnpackSetup<idx>(data);
519 william 31 return 1;
520     }
521 william 191 pass2 { return nVifUnpack<idx>((u8*)data); }
522 william 273 pass3 {
523     vifStruct& vifX = GetVifX;
524     VIFregisters& vifRegs = vifXRegs;
525     uint vl = vifX.cmd & 0x03;
526     uint vn = (vifX.cmd >> 2) & 0x3;
527     bool flg = (vifRegs.code >> 15) & 1;
528     static const char* const vntbl[] = { "S", "V2", "V3", "V4" };
529     static const uint vltbl[] = { 32, 16, 8, 5 };
530    
531     VifCodeLog("Unpack %s_%u (%s) @ 0x%04X%s (cl=%u wl=%u num=0x%02X)",
532     vntbl[vn], vltbl[vl], (vifX.cmd & 0x10) ? "masked" : "unmasked",
533     calc_addr<idx>(flg), flg ? "(FLG)" : "",
534     vifRegs.cycle.cl, vifRegs.cycle.wl, (vifXRegs.code >> 16) & 0xff
535     );
536     }
537 william 31 return 0;
538     }
539    
540     //------------------------------------------------------------------
541     // Vif0/Vif1 Code Tables
542     //------------------------------------------------------------------
543    
544 william 62 __aligned16 FnType_VifCmdHandler* const vifCmdHandler[2][128] =
545     {
546     {
547     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*/
548     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*/
549     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*/
550     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*/
551     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*/
552     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*/
553     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*/
554     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*/
555     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*/
556     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*/
557     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*/
558     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*/
559     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*/
560     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*/
561     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*/
562     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*/
563     },
564     {
565     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*/
566     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*/
567     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*/
568     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*/
569     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*/
570     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*/
571     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*/
572     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*/
573     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*/
574     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*/
575     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*/
576     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*/
577     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*/
578     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*/
579     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*/
580     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*/
581     }
582 william 31 };

  ViewVC Help
Powered by ViewVC 1.1.22