/[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 31 - (hide 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 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     #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