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

Diff of /trunk/pcsx2/Vif_Codes.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 31 by william, Tue Sep 7 03:24:11 2010 UTC revision 191 by william, Mon Sep 20 05:35:51 2010 UTC
# Line 21  Line 21 
21  #include "newVif.h"  #include "newVif.h"
22  #include "VUmicro.h"  #include "VUmicro.h"
23    
24  #define vifOp(vifCodeName) _vifT int __fastcall vifCodeName(int pass, u32 *data)  #define vifOp(vifCodeName) _vifT int __fastcall vifCodeName(int pass, const u32 *data)
25  #define pass1 if (pass == 0)  #define pass1 if (pass == 0)
26  #define pass2 if (pass == 1)  #define pass2 if (pass == 1)
27  #define pass3 if (pass == 2)  #define pass3 if (pass == 2)
# Line 32  vifOp(vifCode_Null); Line 32  vifOp(vifCode_Null);
32  // Vif0/Vif1 Misc Functions  // Vif0/Vif1 Misc Functions
33  //------------------------------------------------------------------  //------------------------------------------------------------------
34    
35  static _f void vifFlush(int idx) {  static __fi void vifFlush(int idx) {
36          if (!idx) vif0FLUSH();          if (!idx) vif0FLUSH();
37          else      vif1FLUSH();          else      vif1FLUSH();
38  }  }
39    
40  static _f void vuExecMicro(int idx, u32 addr) {  static __fi void vuExecMicro(int idx, u32 addr) {
41          VURegs* VU = nVif[idx].VU;          VIFregisters& vifRegs = vifXRegs;
42          vifFlush(idx);          int startcycles = 0;
43            //vifFlush(idx);
44    
45          if (VU->vifRegs->itops  > (idx ? 0x3ffu : 0xffu)) {          //if(vifX.vifstalled == true) return;
46                  Console.WriteLn("VIF%d ITOP overrun! %x", idx, VU->vifRegs->itops);  
47                  VU->vifRegs->itops &= (idx ? 0x3ffu : 0xffu);          if (vifRegs.itops  > (idx ? 0x3ffu : 0xffu)) {
48                    Console.WriteLn("VIF%d ITOP overrun! %x", idx, vifRegs.itops);
49                    vifRegs.itops &= (idx ? 0x3ffu : 0xffu);
50          }          }
51    
52          VU->vifRegs->itop = VU->vifRegs->itops;          vifRegs.itop = vifRegs.itops;
53    
54          if (idx) {          if (idx) {
55                  // in case we're handling a VIF1 execMicro, set the top with the tops value                  // in case we're handling a VIF1 execMicro, set the top with the tops value
56                  VU->vifRegs->top = VU->vifRegs->tops & 0x3ff;                  vifRegs.top = vifRegs.tops & 0x3ff;
57    
58                  // is DBF flag set in VIF_STAT?                  // is DBF flag set in VIF_STAT?
59                  if (VU->vifRegs->stat.DBF) {                  if (vifRegs.stat.DBF) {
60                          // it is, so set tops with base, and clear the stat DBF flag                          // it is, so set tops with base, and clear the stat DBF flag
61                          VU->vifRegs->tops = VU->vifRegs->base;                          vifRegs.tops = vifRegs.base;
62                          VU->vifRegs->stat.DBF = false;                          vifRegs.stat.DBF = false;
63                  }                  }
64                  else {                  else {
65                          // it is not, so set tops with base + offset, and set stat DBF flag                          // it is not, so set tops with base + offset, and set stat DBF flag
66                          VU->vifRegs->tops = VU->vifRegs->base + VU->vifRegs->ofst;                          vifRegs.tops = vifRegs.base + vifRegs.ofst;
67                          VU->vifRegs->stat.DBF = true;                          vifRegs.stat.DBF = true;
68                  }                  }
69          }          }
70    
71            if(!idx)startcycles = VU0.cycle;
72            else    startcycles = VU1.cycle;
73    
74          if (!idx) vu0ExecMicro(addr);          if (!idx) vu0ExecMicro(addr);
75          else      vu1ExecMicro(addr);          else      vu1ExecMicro(addr);
76    
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  }  }
82    
83  u8 schedulepath3msk = 0;  u8 schedulepath3msk = 0;
84    
85  void Vif1MskPath3() {  void Vif1MskPath3() {
86    
87          vif1Regs->mskpath3 = schedulepath3msk & 0x1;          vif1Regs.mskpath3 = schedulepath3msk & 0x1;
88          //Console.WriteLn("VIF MSKPATH3 %x", vif1Regs->mskpath3);          GIF_LOG("VIF MSKPATH3 %x gif str %x path3 status %x", vif1Regs.mskpath3, gifch.chcr.STR, GSTransferStatus.PTH3);
89          gifRegs->stat.M3P = vif1Regs->mskpath3;          gifRegs.stat.M3P = vif1Regs.mskpath3;
90          if (!vif1Regs->mskpath3) {  
91                  //Let the Gif know it can transfer again (making sure any vif stall isnt unset prematurely)          if (!vif1Regs.mskpath3)
92                  if(gif->chcr.STR == true)          {
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                  {                  {
98                          GSTransferStatus.PTH3 = 3;                          gsInterrupt();//gsInterrupt();
                         CPU_INT(DMAC_GIF, 4);  
99                  }                  }
100            
101          }          }// else if(!gif->chcr.STR && GSTransferStatus.PTH3 == IDLE_MODE) GSTransferStatus.PTH3 = STOPPED_MODE;//else DevCon.Warning("Mask on");
102    
103          schedulepath3msk = 0;          schedulepath3msk = 0;
104  }  }
# Line 95  void Vif1MskPath3() { Line 109  void Vif1MskPath3() {
109    
110  vifOp(vifCode_Base) {  vifOp(vifCode_Base) {
111          vif1Only();          vif1Only();
112          pass1 { vif1Regs->base = vif1Regs->code & 0x3ff; vif1.cmd = 0; }          pass1 { vif1Regs.base = vif1Regs.code & 0x3ff; vif1.cmd = 0; }
113          pass3 { DevCon.WriteLn("vifCode_Base"); }          pass3 { VifCodeLog("Base"); }
114          return 0;          return 0;
115  }  }
116    
117  template<int idx> _f int _vifCode_Direct(int pass, u8* data, bool isDirectHL) {  extern bool SIGNAL_IMR_Pending;
118    
119    template<int idx> __fi int _vifCode_Direct(int pass, const u8* data, bool isDirectHL) {
120          pass1 {          pass1 {
121                  vif1Only();                  vif1Only();
122                  int vifImm    = (u16)vif1Regs->code;                  int vifImm    = (u16)vif1Regs.code;
123                  vif1.tag.size = vifImm ? (vifImm*4) : (65536*4);                  vif1.tag.size = vifImm ? (vifImm*4) : (65536*4);
124                  return 1;                  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          }          }
135          pass2 {          pass2 {
136                  vif1Only();                  vif1Only();
137                  //return vifTrans_DirectHL<idx>((u32*)data);  
138                  gifRegs->stat.P2Q = true;                  if (GSTransferStatus.PTH3 < IDLE_MODE || gifRegs.stat.P1Q == true)
139                  //Should probably do this for both types of transfer seen as the GS hates taking 2 seperate chunks                  {
140                  //if (isDirectHL) {                          if(gifRegs.stat.APATH == GIF_APATH2 || ((GSTransferStatus.PTH3 <= IMAGE_MODE && gifRegs.stat.IMT && (vif1.cmd & 0x7f) == 0x50)) && gifRegs.stat.P1Q == false)
141                  if (GSTransferStatus.PTH3 < STOPPED_MODE || GSTransferStatus.PTH1 != STOPPED_MODE)                          {
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                          /*if(!isDirectHL) DevCon.WriteLn("Direct: Waiting for Path3 to finish!");                          DevCon.Warning("Path 2 Paused (At start)");
                         else DevCon.WriteLn("DirectHL: Waiting for Path3 to finish!");*/  
                         //VIF_LOG("Mask %x, GIF STR %x, PTH1 %x, PTH2 %x, PTH3 %x", vif1Regs->mskpath3, gif->chcr.STR, GSTransferStatus.PTH1, GSTransferStatus.PTH2, GSTransferStatus.PTH3);  
                         vif1Regs->stat.VGW = true; // PATH3 is in image mode, so wait for end of transfer  
158                          vif1.vifstalled    = true;                          vif1.vifstalled    = true;
159                          return 0;                          return 0;
160                  }                  }
161                  //}                  if (gifRegs.stat.PSE)  // temporarily stop
162                  gifRegs->stat.clear_flags(GIF_STAT_P2Q);                  {
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    
170                    // 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    
175                    uint minSize     = aMin(vif1.vifpacketsize, vif1.tag.size);
176                    uint ret;
177    
178                  Registers::Freeze();                  if(minSize < 4)
179                  nVifStruct&     v        = nVif[1];                  {
180                  const int       ret      = aMin(vif1.vifpacketsize, vif1.tag.size);                          // When TTE==1, the VIF might end up sending us 8-byte packets instead of the usual 16-byte
181                  u32                     size = ret << 2;                          // 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                  gifRegs->stat.APATH = GIF_APATH2; //Flag is cleared in vif1interrupt to simulate it being in progress.                          // in this situation.
184                            //
185                  if (ret == v.vif->tag.size) { // Full Transfer                          // Games that use TTE==1 and DIRECT in this fashion:  ICO
186                          if (v.bSize) { // Last transfer was partial                          //
187                                  memcpy_fast(&v.buffer[v.bSize], data, size);                          // Because DIRECT normally has a strict QWC alignment requirement, and this funky behavior
188                                  v.bSize += size;                          // only seems to happen on TTE mode transfers with their split-64-bit packets, there shouldn't
189                                  data = v.buffer;                          // be any need to worry about queuing more than 16 bytes of data,
190                                  size = v.bSize;                          //
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                          }                          }
                         if (!size) { DevCon.WriteLn("Path2: No Data Transfer?"); }  
                         const uint count = GetMTGS().PrepDataPacket(GIF_PATH_2, data, size >> 4);  
                         memcpy_fast(GetMTGS().GetDataPacketPtr(), data, count << 4);  
                         GetMTGS().SendDataPacket();  
                         vif1.tag.size = 0;  
                         vif1.cmd = 0;  
                         v.bSize  = 0;  
208                  }                  }
209                  else { // Partial Transfer                  else
210                          //DevCon.WriteLn("DirectHL: Partial Transfer [%d]", size);                                        {
211                          memcpy_fast(&v.buffer[v.bSize], data, size);                          if (!minSize)
212                          v.bSize           += size;                                  DevCon.Warning("VIF DIRECT (PATH2): No Data Transfer?");
213                          vif1.tag.size -= ret;  
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                            GetMTGS().SendDataPacket();
222                  }                  }
223    
224                  Registers::Thaw();                  vif1.tag.size -= ret;
225    
226                    if(vif1.tag.size == 0)
227                    {
228                            vif1.cmd = 0;
229                    }
230                    vif1.vifstalled    = true;
231                  return ret;                  return ret;
232          }          }
233          return 0;          return 0;
234  }  }
235    
236  vifOp(vifCode_Direct) {  vifOp(vifCode_Direct) {
237          pass3 { DevCon.WriteLn("vifCode_Direct"); }          pass3 { VifCodeLog("Direct"); }
238          return _vifCode_Direct<idx>(pass, (u8*)data, 0);          return _vifCode_Direct<idx>(pass, (u8*)data, 0);
239  }  }
240    
241  vifOp(vifCode_DirectHL) {  vifOp(vifCode_DirectHL) {
242          pass3 { DevCon.WriteLn("vifCode_DirectHL"); }          pass3 { VifCodeLog("DirectHL"); }
243          return _vifCode_Direct<idx>(pass, (u8*)data, 1);          return _vifCode_Direct<idx>(pass, (u8*)data, 1);
244  }  }
245    
246  // ToDo: FixMe  // ToDo: FixMe
247  vifOp(vifCode_Flush) {  vifOp(vifCode_Flush) {
248          vif1Only();          vif1Only();
249          pass1 { vifFlush(idx); vifX.cmd = 0; }          vifStruct& vifX = GetVifX;
250          pass3 { DevCon.WriteLn("vifCode_Flush"); }          pass1 { vifFlush(idx);  vifX.cmd = 0; }
251            pass3 { VifCodeLog("Flush"); }
252          return 0;          return 0;
253  }  }
254    
255  // ToDo: FixMe  // ToDo: FixMe
256  vifOp(vifCode_FlushA) {  vifOp(vifCode_FlushA) {
257          vif1Only();          vif1Only();
258            vifStruct& vifX = GetVifX;
259          pass1 {          pass1 {
260                    vifFlush(idx);
261                  // Gif is already transferring so wait for it.                  // Gif is already transferring so wait for it.
262                  if (GSTransferStatus.PTH3 < STOPPED_MODE) {                  if (gifRegs.stat.P1Q || GSTransferStatus.PTH3 <= PENDINGSTOP_MODE) {
263                            //DevCon.Warning("VIF FlushA Wait MSK = %x", vif1Regs.mskpath3);
264                            //
265                            
266                          //DevCon.WriteLn("FlushA path3 Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);                          //DevCon.WriteLn("FlushA path3 Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);
267                          vif1Regs->stat.VGW = true;                          vif1Regs.stat.VGW = true;
268                            vifX.GifWaitState  = 1;
269                          vifX.vifstalled    = true;                          vifX.vifstalled    = true;
270                  }                  }       // else DevCon.WriteLn("FlushA path3 no Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);        
271                  vifFlush(idx);                  
272                  vifX.cmd = 0;                  vifX.cmd = 0;
273          }          }
274          pass3 { DevCon.WriteLn("vifCode_FlushA"); }          pass3 { VifCodeLog("FlushA"); }
275          return 0;          return 0;
276  }  }
277    
278  // ToDo: FixMe  // ToDo: FixMe
279  vifOp(vifCode_FlushE) {  vifOp(vifCode_FlushE) {
280            vifStruct& vifX = GetVifX;
281          pass1 { vifFlush(idx); vifX.cmd = 0; }          pass1 { vifFlush(idx); vifX.cmd = 0; }
282          pass3 { DevCon.WriteLn("vifCode_FlushE"); }          pass3 { VifCodeLog("FlushE"); }
283          return 0;          return 0;
284  }  }
285    
286  vifOp(vifCode_ITop) {  vifOp(vifCode_ITop) {
287          pass1 { vifXRegs->itops = vifXRegs->code & 0x3ff; vifX.cmd = 0; }          pass1 { vifXRegs.itops = vifXRegs.code & 0x3ff; GetVifX.cmd = 0; }
288          pass3 { DevCon.WriteLn("vifCode_ITop"); }          pass3 { VifCodeLog("ITop"); }
289          return 0;          return 0;
290  }  }
291    
292  vifOp(vifCode_Mark) {  vifOp(vifCode_Mark) {
293            vifStruct& vifX = GetVifX;
294          pass1 {          pass1 {
295                  vifXRegs->mark     = (u16)vifXRegs->code;                  vifXRegs.mark     = (u16)vifXRegs.code;
296                  vifXRegs->stat.MRK = true;                  vifXRegs.stat.MRK = true;
297                  vifX.cmd           = 0;                  vifX.cmd           = 0;
298          }          }
299          pass3 { DevCon.WriteLn("vifCode_Mark"); }          pass3 { VifCodeLog("Mark"); }
300          return 0;          return 0;
301  }  }
302    
303  _f void _vifCode_MPG(int idx, u32 addr, u32 *data, int size) {  static __fi void _vifCode_MPG(int idx, u32 addr, const u32 *data, int size) {
304          VURegs& VUx = idx ? VU1 : VU0;          VURegs& VUx = idx ? VU1 : VU0;
305          pxAssume(VUx.Micro > 0);          pxAssume(VUx.Micro > 0);
306    
307          if (memcmp(VUx.Micro + addr, data, size << 2)) {          if (memcmp_mmx(VUx.Micro + addr, data, size*4)) {
308                  if (!idx)  CpuVU0->Clear(addr, size << 2); // Clear before writing!                  // Clear VU memory before writing!
309                  else       CpuVU1->Clear(addr, size << 2); // Clear before writing!                  // (VUs expect size to be 32-bit scale, same as VIF's internal working sizes)
310                  memcpy_fast(VUx.Micro + addr, data, size << 2);                  if (!idx)  CpuVU0->Clear(addr, size);
311                    else       CpuVU1->Clear(addr, size);
312                    memcpy_fast(VUx.Micro + addr, data, size*4);
313          }          }
314  }  }
315    
316  vifOp(vifCode_MPG) {  vifOp(vifCode_MPG) {
317            vifStruct& vifX = GetVifX;
318          pass1 {          pass1 {
319                  int    vifNum =  (u8)(vifXRegs->code >> 16);                  int    vifNum =  (u8)(vifXRegs.code >> 16);
320                  vifX.tag.addr = (u16)(vifXRegs->code <<  3) & (idx ? 0x3fff : 0xfff);                  vifX.tag.addr = (u16)(vifXRegs.code <<  3) & (idx ? 0x3fff : 0xfff);
321                  vifX.tag.size = vifNum ? (vifNum*2) : 512;                  vifX.tag.size = vifNum ? (vifNum*2) : 512;
322                    //vifFlush(idx);
323                  return 1;                  return 1;
324          }          }
325          pass2 {          pass2 {
                 vifFlush(idx);  
326                  if (vifX.vifpacketsize < vifX.tag.size) { // Partial Transfer                  if (vifX.vifpacketsize < vifX.tag.size) { // Partial Transfer
327                          if((vifX.tag.addr +  vifX.vifpacketsize) > (idx ? 0x4000 : 0x1000)) {                          if((vifX.tag.addr + vifX.vifpacketsize*4) > (idx ? 0x4000 : 0x1000)) {
328                                  DevCon.Warning("Vif%d MPG Split Overflow", idx);                                  DevCon.Warning("Vif%d MPG Split Overflow", idx);
329                          }                          }
330                          _vifCode_MPG(idx,    vifX.tag.addr, data, vifX.vifpacketsize);                          _vifCode_MPG(idx,    vifX.tag.addr, data, vifX.vifpacketsize);
331                          vifX.tag.addr   +=   vifX.vifpacketsize << 2;                          vifX.tag.addr   +=   vifX.vifpacketsize * 4;
332                          vifX.tag.size   -=   vifX.vifpacketsize;                          vifX.tag.size   -=   vifX.vifpacketsize;
333                          return vifX.vifpacketsize;                          return vifX.vifpacketsize;
334                  }                  }
335                  else { // Full Transfer                  else { // Full Transfer
336                          if((vifX.tag.addr + vifX.tag.size) > (idx ? 0x4000 : 0x1000)) {                          if((vifX.tag.addr + vifX.tag.size*4) > (idx ? 0x4000 : 0x1000)) {
337                                  DevCon.Warning("Vif%d MPG Split Overflow", idx);                                  DevCon.Warning("Vif%d MPG Split Overflow", idx);
338                          }                          }
339                          _vifCode_MPG(idx,  vifX.tag.addr, data, vifX.tag.size);                          _vifCode_MPG(idx,  vifX.tag.addr, data, vifX.tag.size);
# Line 258  vifOp(vifCode_MPG) { Line 343  vifOp(vifCode_MPG) {
343                          return ret;                          return ret;
344                  }                  }
345          }          }
346          pass3 { DevCon.WriteLn("vifCode_MPG"); }          pass3 { VifCodeLog("MPG"); }
347          return 0;          return 0;
348  }  }
349    
350  vifOp(vifCode_MSCAL) {  vifOp(vifCode_MSCAL) {
351          pass1 { vuExecMicro(idx, (u16)(vifXRegs->code) << 3); vifX.cmd = 0; }          vifStruct& vifX = GetVifX;
352          pass3 { DevCon.WriteLn("vifCode_MSCAL"); }          pass1 { vifFlush(idx); vuExecMicro(idx, (u16)(vifXRegs.code) << 3); vifX.cmd = 0;}
353            pass3 { VifCodeLog("MSCAL"); }
354          return 0;          return 0;
355  }  }
356    
357  vifOp(vifCode_MSCALF) {  vifOp(vifCode_MSCALF) {
358          pass1 { vuExecMicro(idx, (u16)(vifXRegs->code) << 3); vifX.cmd = 0; }          vifStruct& vifX = GetVifX;
359          pass3 { DevCon.WriteLn("vifCode_MSCALF"); }          pass1 { vifFlush(idx); vuExecMicro(idx, (u16)(vifXRegs.code) << 3); vifX.cmd = 0; }
360            pass3 { VifCodeLog("MSCALF"); }
361          return 0;          return 0;
362  }  }
363    
364  vifOp(vifCode_MSCNT) {  vifOp(vifCode_MSCNT) {
365          pass1 { vuExecMicro(idx, -1); vifX.cmd = 0; }          vifStruct& vifX = GetVifX;
366          pass3 { DevCon.WriteLn("vifCode_MSCNT"); }          pass1 { vifFlush(idx); vuExecMicro(idx, -1); vifX.cmd = 0; }
367            pass3 { VifCodeLog("MSCNT"); }
368          return 0;          return 0;
369  }  }
370    
# Line 284  vifOp(vifCode_MSCNT) { Line 372  vifOp(vifCode_MSCNT) {
372  vifOp(vifCode_MskPath3) {  vifOp(vifCode_MskPath3) {
373          vif1Only();          vif1Only();
374          pass1 {          pass1 {
375                  if (vif1ch->chcr.STR) {                  if (vif1ch.chcr.STR && vif1.lastcmd != 0x13) {
376                          schedulepath3msk = 0x10 | ((vif1Regs->code >> 15) & 0x1);                          schedulepath3msk = 0x10 | ((vif1Regs.code >> 15) & 0x1);
377                          vif1.vifstalled = true;                          vif1.vifstalled = true;
378                  }                  }
379                  else {                  else {
380                          schedulepath3msk = (vif1Regs->code >> 15) & 0x1;                          schedulepath3msk = (vif1Regs.code >> 15) & 0x1;
381                          Vif1MskPath3();                          Vif1MskPath3();
382                  }                  }
383                  vifX.cmd = 0;                  vif1.cmd = 0;
384          }          }
385          pass3 { DevCon.WriteLn("vifCode_MskPath3"); }          pass3 { VifCodeLog("MskPath3"); }
386          return 0;          return 0;
387  }  }
388    
389  vifOp(vifCode_Nop) {  vifOp(vifCode_Nop) {
390          pass1 { vifX.cmd = 0; }          pass1 { GetVifX.cmd = 0; }
391          pass3 { DevCon.WriteLn("vifCode_Nop"); }          pass3 { VifCodeLog("Nop"); }
392          return 0;          return 0;
393  }  }
394    
395  // ToDo: Review Flags  // ToDo: Review Flags
396  vifOp(vifCode_Null) {  vifOp(vifCode_Null) {
397            vifStruct& vifX = GetVifX;
398          pass1 {          pass1 {
399                  // if ME1, then force the vif to interrupt                  // if ME1, then force the vif to interrupt
400                  if (!(vifXRegs->err.ME1)) { // Ignore vifcode and tag mismatch error                  if (!(vifXRegs.err.ME1)) { // Ignore vifcode and tag mismatch error
401                          Console.WriteLn("Vif%d: Unknown VifCmd! [%x]", idx, vifX.cmd);                          Console.WriteLn("Vif%d: Unknown VifCmd! [%x]", idx, vifX.cmd);
402                          vifXRegs->stat.ER1 = true;                          vifXRegs.stat.ER1 = true;
403                          vifX.vifstalled    = true;                          vifX.vifstalled = true;
404                          //vifX.irq++;                          //vifX.irq++;
405                  }                  }
406                  vifX.cmd = 0;                  vifX.cmd = 0;
407          }          }
408          pass2 { Console.Error("Vif%d bad vifcode! [CMD = %x]", idx, vifX.cmd); }          pass2 { Console.Error("Vif%d bad vifcode! [CMD = %x]", idx, vifX.cmd); }
409          pass3 { DevCon.WriteLn("vifCode_Null"); }          pass3 { VifCodeLog("Null"); }
410          return 0;          return 0;
411  }  }
412    
413  vifOp(vifCode_Offset) {  vifOp(vifCode_Offset) {
414          vif1Only();          vif1Only();
415          pass1 {          pass1 {
416                  vif1Regs->stat.DBF      = false;                  vif1Regs.stat.DBF       = false;
417                  vif1Regs->ofst          = vif1Regs->code & 0x3ff;                  vif1Regs.ofst           = vif1Regs.code & 0x3ff;
418                  vif1Regs->tops          = vif1Regs->base;                  vif1Regs.tops           = vif1Regs.base;
419                  vifX.cmd                        = 0;                  vif1.cmd                        = 0;
420          }          }
421          pass3 { DevCon.WriteLn("vifCode_Offset"); }          pass3 { VifCodeLog("Offset"); }
422          return 0;          return 0;
423  }  }
424    
425  template<int idx> _f int _vifCode_STColRow(u32* data, u32* pmem1, u32* pmem2) {  template<int idx> static __fi int _vifCode_STColRow(const u32* data, u32* pmem2) {
426          int ret;          vifStruct& vifX = GetVifX;
427          ret = min(4 - vifX.tag.addr, vifX.vifpacketsize);  
428            int ret = min(4 - vifX.tag.addr, vifX.vifpacketsize);
429          pxAssume(vifX.tag.addr < 4);          pxAssume(vifX.tag.addr < 4);
430          pxAssume(ret > 0);          pxAssume(ret > 0);
431    
432          switch (ret) {          switch (ret) {
433                  case 4:                  case 4:
                         pmem1[12] = data[3];  
434                          pmem2[3]  = data[3];                          pmem2[3]  = data[3];
435                  case 3:                  case 3:
                         pmem1[8]  = data[2];  
436                          pmem2[2]  = data[2];                          pmem2[2]  = data[2];
437                  case 2:                  case 2:
                         pmem1[4]  = data[1];  
438                          pmem2[1]  = data[1];                          pmem2[1]  = data[1];
439                  case 1:                  case 1:
                         pmem1[0]  = data[0];  
440                          pmem2[0]  = data[0];                          pmem2[0]  = data[0];
441                          break;                          break;
442                  jNO_DEFAULT                  jNO_DEFAULT
# Line 364  template<int idx> _f int _vifCode_STColR Line 450  template<int idx> _f int _vifCode_STColR
450  }  }
451    
452  vifOp(vifCode_STCol) {  vifOp(vifCode_STCol) {
453            vifStruct& vifX = GetVifX;
454          pass1 {          pass1 {
455                  vifX.tag.addr = 0;                  vifX.tag.addr = 0;
456                  vifX.tag.size = 4;                  vifX.tag.size = 4;
457                  return 1;                  return 1;
458          }          }
459          pass2 {          pass2 {
460                  u32* cols  = idx ? g_vifmask.Col1 : g_vifmask.Col0;                  return _vifCode_STColRow<idx>(data, &vifX.MaskCol._u32[vifX.tag.addr]);
                 u32* pmem1 = &vifXRegs->c0 + (vifX.tag.addr << 2);  
                 u32* pmem2 = cols                  +  vifX.tag.addr;  
                 return _vifCode_STColRow<idx>(data, pmem1, pmem2);  
461          }          }
462          pass3 { DevCon.WriteLn("vifCode_STCol"); }          pass3 { VifCodeLog("STCol"); }
463          return 0;          return 0;
464  }  }
465    
466  vifOp(vifCode_STRow) {  vifOp(vifCode_STRow) {
467            vifStruct& vifX = GetVifX;
468    
469          pass1 {          pass1 {
470                  vifX.tag.addr = 0;                  vifX.tag.addr = 0;
471                  vifX.tag.size = 4;                  vifX.tag.size = 4;
472                  return 1;                  return 1;
473          }          }
474          pass2 {          pass2 {
475                  u32* rows  = idx ? g_vifmask.Row1 : g_vifmask.Row0;                  return _vifCode_STColRow<idx>(data, &vifX.MaskRow._u32[vifX.tag.addr]);
                 u32* pmem1 = &vifXRegs->r0 + (vifX.tag.addr << 2);  
                 u32* pmem2 = rows                  +  vifX.tag.addr;  
                 return _vifCode_STColRow<idx>(data, pmem1, pmem2);  
476          }          }
477          pass3 { DevCon.WriteLn("vifCode_STRow"); }          pass3 { VifCodeLog("STRow"); }
478          return 0;          return 0;
479  }  }
480    
481  vifOp(vifCode_STCycl) {  vifOp(vifCode_STCycl) {
482            vifStruct& vifX = GetVifX;
483          pass1 {          pass1 {
484                  vifXRegs->cycle.cl = (u8)(vifXRegs->code);                  vifXRegs.cycle.cl = (u8)(vifXRegs.code);
485                  vifXRegs->cycle.wl = (u8)(vifXRegs->code >> 8);                  vifXRegs.cycle.wl = (u8)(vifXRegs.code >> 8);
486                  vifX.cmd                   = 0;                  vifX.cmd                   = 0;
487          }          }
488          pass3 { DevCon.WriteLn("vifCode_STCycl"); }          pass3 { VifCodeLog("STCycl"); }
489          return 0;          return 0;
490  }  }
491    
492  vifOp(vifCode_STMask) {  vifOp(vifCode_STMask) {
493            vifStruct& vifX = GetVifX;
494          pass1 { vifX.tag.size = 1; }          pass1 { vifX.tag.size = 1; }
495          pass2 { vifXRegs->mask = data[0]; vifX.tag.size = 0; vifX.cmd = 0; }          pass2 { vifXRegs.mask = data[0]; vifX.tag.size = 0; vifX.cmd = 0; }
496          pass3 { DevCon.WriteLn("vifCode_STMask"); }          pass3 { VifCodeLog("STMask"); }
497          return 1;          return 1;
498  }  }
499    
500  vifOp(vifCode_STMod) {  vifOp(vifCode_STMod) {
501          pass1 { vifXRegs->mode = vifXRegs->code & 0x3; vifX.cmd = 0; }          pass1 { vifXRegs.mode = vifXRegs.code & 0x3; GetVifX.cmd = 0; }
502          pass3 { DevCon.WriteLn("vifCode_STMod"); }          pass3 { VifCodeLog("STMod"); }
503          return 0;          return 0;
504  }  }
505    
506  vifOp(vifCode_Unpack) {  vifOp(vifCode_Unpack) {
507          pass1 {          pass1 {
508                  if (!idx) vif0UnpackSetup(data);                  vifUnpackSetup<idx>(data);
                 else      vif1UnpackSetup(data);  
509                  return 1;                  return 1;
510          }          }
511          pass2 { return nVifUnpack(idx, (u8*)data); }          pass2 { return nVifUnpack<idx>((u8*)data); }
512          pass3 { DevCon.WriteLn("vifCode_Unpack");  }          pass3 { VifCodeLog("Unpack");  }
513          return 0;          return 0;
514  }  }
515    
# Line 433  vifOp(vifCode_Unpack) { Line 517  vifOp(vifCode_Unpack) {
517  // Vif0/Vif1 Code Tables  // Vif0/Vif1 Code Tables
518  //------------------------------------------------------------------  //------------------------------------------------------------------
519    
520  int (__fastcall *vif0Code[128])(int pass, u32 *data) = {  __aligned16 FnType_VifCmdHandler* const vifCmdHandler[2][128] =
521          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*/  {
522          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*/          {
523          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*/                  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*/
524          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*/                  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*/
525          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*/                  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*/
526          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*/                  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*/
527          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*/                  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*/
528          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*/                  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*/
529          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*/                  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*/
530          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*/                  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*/
531          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*/                  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*/
532          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*/                  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*/
533          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*/                  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*/
534          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*/                  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*/
535          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*/                  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*/
536          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*/                  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*/
537  };                  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*/
538                    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*/
539  int (__fastcall *vif1Code[128])(int pass, u32 *data) = {          },
540          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*/          {
541          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*/                  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*/
542          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*/                  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*/
543          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*/                  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*/
544          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*/                  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*/
545          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*/                  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*/
546          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*/                  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*/
547          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*/                  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*/
548          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*/                  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*/
549          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*/                  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*/
550          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*/                  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*/
551          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*/                  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*/
552          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*/                  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*/
553          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*/                  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*/
554          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*/                  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*/
555          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*/                  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*/
556                    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*/
557            }
558  };  };

Legend:
Removed from v.31  
changed lines
  Added in v.191

  ViewVC Help
Powered by ViewVC 1.1.22