/[pcsx2_0.9.7]/branch/debug/0.X/0.9.X/0.9.7/ramdump-lateset/plugins/zzogl-pg/opengl/HostMemory.cpp
ViewVC logotype

Contents of /branch/debug/0.X/0.9.X/0.9.7/ramdump-lateset/plugins/zzogl-pg/opengl/HostMemory.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 314 - (show annotations) (download)
Sun Dec 26 18:56:19 2010 UTC (9 years, 2 months ago) by william
File size: 17112 byte(s)
** merged upstream r4049 (re-integration of GregMiscellaneous branch)
** applied patched to GigTranser.cpp in ZZOgl from r4140 to change 'static int count = 0;' to 'static int path1_count = 0;')
1 /* ZZ Open GL graphics plugin
2 * Copyright (c)2009-2010 zeydlitz@gmail.com, arcum42@gmail.com
3 * Based on Zerofrog's ZeroGS KOSMOS (c)2005-2008
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include "GS.h"
21 #include <Cg/cg.h>
22 #include <Cg/cgGL.h>
23
24 #include <stdlib.h>
25 #include "Mem.h"
26 #include "x86.h"
27 #include "targets.h"
28 #include "ZZoglVB.h"
29
30 // flush current vertices, call before setting new registers (the main render method)
31 extern void Flush(int context);
32
33 u8* g_pbyGSMemory = NULL; // 4Mb GS system mem
34
35 void GSMemory::init()
36 {
37 const u32 mem_size = MEMORY_END + 0x10000; // leave some room for out of range accesses (saves on the checks)
38
39 // clear
40 g_pbyGSMemory = (u8*)_aligned_malloc(mem_size, 1024);
41 memset(g_pbyGSMemory, 0, mem_size);
42 }
43
44 void GSMemory::destroy()
45 {
46 _aligned_free(g_pbyGSMemory);
47 g_pbyGSMemory = NULL;
48 }
49
50 u8* GSMemory::get()
51 {
52 return g_pbyGSMemory;
53 }
54
55 u8* GSMemory::get(u32 addr)
56 {
57 return &g_pbyGSMemory[addr*8];
58 }
59 u8* GSMemory::get_raw(u32 addr)
60 {
61 return &g_pbyGSMemory[addr];
62 }
63
64 u8* g_pbyGSClut = NULL; // ZZ
65
66 void GSClut::init()
67 {
68 g_pbyGSClut = (u8*)_aligned_malloc(256 * 8, 1024); // need 512 alignment!
69 memset(g_pbyGSClut, 0, 256*8);
70 }
71
72 void GSClut::destroy()
73 {
74 _aligned_free(g_pbyGSClut);
75 g_pbyGSClut = NULL;
76 }
77
78 u8* GSClut::get()
79 {
80 return g_pbyGSClut;
81 }
82
83 u8* GSClut::get(u32 addr)
84 {
85 return &g_pbyGSClut[addr*8];
86 }
87 u8* GSClut::get_raw(u32 addr)
88 {
89 return &g_pbyGSClut[addr];
90 }
91
92 extern _getPixelAddress getPixelFun[64];
93
94 extern CRangeManager s_RangeMngr; // manages overwritten memory
95 extern void ResolveInRange(int start, int end);
96
97 static vector<u8> s_vTempBuffer, s_vTransferCache;
98 static int gs_imageEnd = 0;
99
100 // From the start of monster labs. In all 3 cases, psm == 0.
101 // ZZogl-PG: GetRectMemAddress(0x3f4000, 0x404000, 0x0, 0x0, 0x0, 0x100, 0x40, 0x3f40, 0x100);
102 // ZZogl-PG: GetRectMemAddress(0x3f8000, 0x408000, 0x0, 0x0, 0x0, 0x100, 0x40, 0x3f80, 0x100);
103 // ZZogl-PG: GetRectMemAddress(0x3fc000, 0x40c000, 0x0, 0x0, 0x0, 0x100, 0x40, 0x3fc0, 0x100);
104
105 void GetRectMemAddress(int& start, int& end, int psm, int x, int y, int w, int h, int bp, int bw)
106 {
107 FUNCLOG
108 u32 bits = 0;
109
110 if (m_Blocks[psm].bpp == 0)
111 {
112 ZZLog::Error_Log("ZeroGS: Bad psm 0x%x.", psm);
113 start = 0;
114 end = MEMORY_END;
115 return;
116 }
117
118 if (PSMT_ISZTEX(psm))
119 {
120 // Somehow, I doubt this code is right. I'll have to look into it. For the moment, I'm keeping it the
121 // way it was. --arcum42
122
123 const BLOCK& b = m_Blocks[psm];
124
125 bw = (bw + b.width - 1) / b.width;
126 start = bp * 256 + ((y / b.height) * bw + (x / b.width)) * 0x2000;
127 end = bp * 256 + (((y + h - 1) / b.height) * bw + (x + w + b.width - 1) / b.width) * 0x2000;
128 return;
129 }
130
131 bits = PSMT_BITS_NUM(psm);
132 start = getPixelFun[psm](x, y, bp, bw);
133 end = getPixelFun[psm](x + w - 1, y + h - 1, bp, bw) + 1;
134
135 if (bits > 0)
136 {
137 start *= bits;
138 end *= bits;
139 }
140 else
141 {
142 // This is what it used to do, which doesn't seem right.
143 // Keeping it for reference, in case removing it breaks anything.
144
145 //int newx = ((x + w - 1 + 31) & ~31) - 1;
146 //int newy = ((y + h - 1 + 15) & ~15) - 1;
147 //start = getPixelAddress4(x, y, bp, bw) / 2;
148 //end = (getPixelAddress4(max(newx, x), max(newy, y), bp, bw) + 2) / 2;
149
150 start /= 2;
151 end /= 2;
152 }
153 }
154
155 void InitTransferHostLocal()
156 {
157 FUNCLOG
158
159 #if defined(_DEBUG)
160 // Xenosaga 1.
161 if (gs.trxpos.dx + gs.imageWnew > gs.dstbuf.bw)
162 ZZLog::Debug_Log("Transfer error, width exceeded. (0x%x > 0X%x)", gs.trxpos.dx + gs.imageWnew, gs.dstbuf.bw);
163 #endif
164
165 //bool bHasFlushed = false;
166
167 gs.imageX = gs.trxpos.dx;
168 gs.imageY = gs.trxpos.dy;
169
170 gs.imageEndX = gs.imageX + gs.imageWnew;
171 gs.imageEndY = gs.imageY + gs.imageHnew;
172
173 assert(gs.imageEndX < 2048 && gs.imageEndY < 2048);
174
175 // This needs to be looked in to, since psm should *not* be 63.
176 // hack! viewful joe
177 if (gs.dstbuf.psm == 63) gs.dstbuf.psm = 0;
178
179 int start, end;
180
181 GetRectMemAddress(start, end, gs.dstbuf.psm, gs.trxpos.dx, gs.trxpos.dy, gs.imageWnew, gs.imageHnew, gs.dstbuf.bp, gs.dstbuf.bw);
182
183 if (end > MEMORY_END)
184 {
185 // Monster Lab - the screwed up title screen
186 // Init host local out of bounds! (end == 0x404000)
187 // Init host local out of bounds! (end == 0x408000)
188 // Init host local out of bounds! (end == 0x40c000)
189 // MEMORY_END is 0x400000...
190
191 ZZLog::Warn_Log("Init host local out of bounds! (end == 0x%x)", end);
192 //gs.imageTransfer = -1;
193 end = MEMORY_END;
194 }
195
196 gs_imageEnd = end;
197
198 if (vb[0].nCount > 0) Flush(0);
199 if (vb[1].nCount > 0) Flush(1);
200
201 //ZZLog::Prim_Log("trans: bp:%x x:%x y:%x w:%x h:%x\n", gs.dstbuf.bp, gs.trxpos.dx, gs.trxpos.dy, gs.imageWnew, gs.imageHnew);
202 }
203
204 void TransferHostLocal(const void* pbyMem, u32 nQWordSize)
205 {
206 FUNCLOG
207
208 int start, end;
209
210 GetRectMemAddress(start, end, gs.dstbuf.psm, gs.imageX, gs.imageY, gs.imageWnew, gs.imageHnew, gs.dstbuf.bp, gs.dstbuf.bw);
211
212 assert(start < gs_imageEnd);
213 end = gs_imageEnd;
214
215 // sometimes games can decompress to alpha channel of render target only, in this case
216 // do a resolve right away. wolverine x2
217 if (((gs.dstbuf.psm == PSMT8H) || (gs.dstbuf.psm == PSMT4HL) || (gs.dstbuf.psm == PSMT4HH)) && !(conf.settings().gust))
218 {
219 list<CRenderTarget*> listTransmissionUpdateTargs;
220 s_RTs.GetTargs(start, end, listTransmissionUpdateTargs);
221
222 for (list<CRenderTarget*>::iterator it = listTransmissionUpdateTargs.begin(); it != listTransmissionUpdateTargs.end(); ++it)
223 {
224 CRenderTarget* ptarg = *it;
225
226 if ((ptarg->status & CRenderTarget::TS_Virtual)) continue;
227
228 //ZZLog::Error_Log("Resolving to alpha channel.");
229 ptarg->Resolve();
230 }
231 }
232
233 s_RangeMngr.Insert(start, min(end, start + (int)nQWordSize*16));
234
235 const u8* porgend = (const u8*)pbyMem + 4 * nQWordSize;
236
237 if (s_vTransferCache.size() > 0)
238 {
239
240 int imagecache = s_vTransferCache.size();
241 s_vTempBuffer.resize(imagecache + nQWordSize*4);
242 memcpy(&s_vTempBuffer[0], &s_vTransferCache[0], imagecache);
243 memcpy(&s_vTempBuffer[imagecache], pbyMem, nQWordSize*4);
244
245 pbyMem = (const void*) & s_vTempBuffer[0];
246 porgend = &s_vTempBuffer[0] + s_vTempBuffer.size();
247
248 int wordinc = imagecache / 4;
249
250 if ((nQWordSize * 4 + imagecache) / 3 == ((nQWordSize + wordinc) * 4) / 3)
251 {
252 // can use the data
253 nQWordSize += wordinc;
254 }
255 }
256
257 int leftover = m_Blocks[gs.dstbuf.psm].TransferHostLocal(pbyMem, nQWordSize);
258
259 if (leftover > 0)
260 {
261 // copy the last gs.image24bitOffset to the cache
262 s_vTransferCache.resize(leftover);
263 memcpy(&s_vTransferCache[0], porgend - leftover, leftover);
264 }
265 else
266 {
267 s_vTransferCache.resize(0);
268 }
269
270 #if defined(_DEBUG)
271 if (g_bSaveTrans)
272 {
273 tex0Info t;
274 t.tbp0 = gs.dstbuf.bp;
275 t.tw = gs.imageWnew;
276 t.th = gs.imageHnew;
277 t.tbw = gs.dstbuf.bw;
278 t.psm = gs.dstbuf.psm;
279 SaveTex(&t, 0);
280 }
281
282 #endif
283 }
284
285 void InitTransferLocalHost()
286 {
287 FUNCLOG
288 assert(gs.trxpos.sx + gs.imageWnew <= 2048 && gs.trxpos.sy + gs.imageHnew <= 2048);
289
290 #if defined(_DEBUG)
291 if (gs.trxpos.sx + gs.imageWnew > gs.srcbuf.bw)
292 ZZLog::Debug_Log("Transfer error, width exceeded. (0x%x > 0x%x)", gs.trxpos.sx + gs.imageWnew, gs.srcbuf.bw);
293 #endif
294
295 gs.imageX = gs.trxpos.sx;
296 gs.imageY = gs.trxpos.sy;
297
298 gs.imageEndX = gs.imageX + gs.imageWnew;
299 gs.imageEndY = gs.imageY + gs.imageHnew;
300
301 s_vTransferCache.resize(0);
302
303 int start, end;
304
305 GetRectMemAddress(start, end, gs.srcbuf.psm, gs.trxpos.sx, gs.trxpos.sy, gs.imageWnew, gs.imageHnew, gs.srcbuf.bp, gs.srcbuf.bw);
306
307 ResolveInRange(start, end);
308 }
309
310 template <class T>
311 void TransferLocalHost(void* pbyMem, u32 nQWordSize, int& x, int& y, u8 *pstart)
312 {
313 _readPixel_0 rp = readPixelFun_0[gs.srcbuf.psm];
314
315 int i = x, j = y;
316 T* pbuf = (T*)pbyMem;
317 u32 nSize = nQWordSize * 16 / sizeof(T);
318
319 for (; i < gs.imageEndY; ++i)
320 {
321 for (; j < gs.imageEndX && nSize > 0; ++j, --nSize)
322 {
323 *pbuf++ = rp(pstart, j % 2048, i % 2048, gs.srcbuf.bw);
324 }
325
326 if (j >= gs.imageEndX)
327 {
328 assert(j == gs.imageEndX);
329 j = gs.trxpos.sx;
330 }
331 else
332 {
333 assert(nSize == 0);
334 break;
335 }
336 }
337 }
338
339 void TransferLocalHost_24(void* pbyMem, u32 nQWordSize, int& x, int& y, u8 *pstart)
340 {
341 _readPixel_0 rp = readPixelFun_0[gs.srcbuf.psm];
342
343 int i = x, j = y;
344 u8* pbuf = (u8*)pbyMem;
345 u32 nSize = nQWordSize * 16 / 3;
346
347 for (; i < gs.imageEndY; ++i)
348 {
349 for (; j < gs.imageEndX && nSize > 0; ++j, --nSize)
350 {
351 u32 p = rp(pstart, j % 2048, i % 2048, gs.srcbuf.bw);
352 pbuf[0] = (u8)p;
353 pbuf[1] = (u8)(p >> 8);
354 pbuf[2] = (u8)(p >> 16);
355 pbuf += 3;
356 }
357
358 if (j >= gs.imageEndX)
359 {
360 assert(j == gs.imageEndX);
361 j = gs.trxpos.sx;
362 }
363 else
364 {
365 assert(nSize == 0);
366 break;
367 }
368 }
369 }
370
371 // left/right, top/down
372 void TransferLocalHost(void* pbyMem, u32 nQWordSize)
373 {
374 FUNCLOG
375 assert(gs.imageTransfer == 1);
376
377 u8* pstart = g_pbyGSMemory + 256 * gs.srcbuf.bp;
378
379 switch(PSMT_BITMODE(gs.srcbuf.psm))
380 {
381 case 0:
382 TransferLocalHost<u32>(pbyMem, nQWordSize, gs.imageY, gs.imageX, pstart);
383 break;
384 case 1:
385 TransferLocalHost_24(pbyMem, nQWordSize, gs.imageY, gs.imageX, pstart);
386 break;
387 case 2:
388 TransferLocalHost<u16>(pbyMem, nQWordSize, gs.imageY, gs.imageX, pstart);
389 break;
390 case 3:
391 TransferLocalHost<u8>(pbyMem, nQWordSize, gs.imageY, gs.imageX, pstart);
392 break;
393 default:
394 assert(0);
395 break;
396 }
397
398 if (gs.imageY >= gs.imageEndY)
399 {
400 ZZLog::Error_Log("gs.imageY >= gs.imageEndY!");
401 assert(gs.imageY == gs.imageEndY);
402 gs.imageTransfer = -1;
403 }
404 }
405
406 __forceinline void _TransferLocalLocal()
407 {
408 //ZZLog::Error_Log("TransferLocalLocal(0x%x, 0x%x)", gs.srcbuf.psm, gs.dstbuf.psm);
409 _writePixel_0 wp = writePixelFun_0[gs.srcbuf.psm];
410 _readPixel_0 rp = readPixelFun_0[gs.dstbuf.psm];
411 u8* pSrcBuf = g_pbyGSMemory + gs.srcbuf.bp * 256;
412 u8* pDstBuf = g_pbyGSMemory + gs.dstbuf.bp * 256;
413 u32 widthlimit = 4;
414 u32 maxX = gs.trxpos.sx + gs.imageWnew;
415 u32 maxY = gs.trxpos.sy + gs.imageHnew;
416
417 if (PSMT_BITMODE(gs.srcbuf.psm) == 0) widthlimit = 2;
418 if ((gs.imageWnew & widthlimit) != 0) return;
419
420 for(int i = gs.trxpos.sy, i2 = gs.trxpos.dy; i < maxY; i++, i2++)
421 {
422 for(int j = gs.trxpos.sx, j2 = gs.trxpos.dx; j < maxX; j += widthlimit, j2 += widthlimit)
423 {
424 wp(pDstBuf, j2%2048, i2%2048,
425 rp(pSrcBuf, j%2048, i%2048, gs.srcbuf.bw), gs.dstbuf.bw);
426
427 wp(pDstBuf, (j2+1)%2048, i2%2048,
428 rp(pSrcBuf, (j+1)%2048, i%2048, gs.srcbuf.bw), gs.dstbuf.bw);
429
430 if (widthlimit > 2)
431 {
432 // Then widthlimit == 4.
433 wp(pDstBuf, (j2+2)%2048, i2%2048,
434 rp(pSrcBuf, (j+2)%2048, i%2048, gs.srcbuf.bw), gs.dstbuf.bw);
435
436 wp(pDstBuf, (j2+3)%2048, i2%2048,
437 rp(pSrcBuf, (j+3)%2048, i%2048, gs.srcbuf.bw), gs.dstbuf.bw);
438 }
439 }
440 }
441 }
442
443 __forceinline void _TransferLocalLocal_4()
444 {
445 //ZZLog::Error_Log("TransferLocalLocal_4(0x%x, 0x%x)", gs.srcbuf.psm, gs.dstbuf.psm);
446 _getPixelAddress_0 gsp = getPixelFun_0[gs.srcbuf.psm];
447 _getPixelAddress_0 gdp = getPixelFun_0[gs.dstbuf.psm];
448 u8* pSrcBuf = g_pbyGSMemory + gs.srcbuf.bp * 256;
449 u8* pDstBuf = g_pbyGSMemory + gs.dstbuf.bp * 256;
450 u32 maxX = gs.trxpos.sx + gs.imageWnew;
451 u32 maxY = gs.trxpos.sy + gs.imageHnew;
452
453 assert((gs.imageWnew % 8) == 0);
454
455 for(int i = gs.trxpos.sy, i2 = gs.trxpos.dy; i < maxY; ++i, ++i2)
456 {
457 for(int j = gs.trxpos.sx, j2 = gs.trxpos.dx; j < maxX; j += 8, j2 += 8)
458 {
459 /* NOTE: the 2 conseq 4bit values are in NOT in the same byte */
460 u32 read = gsp(j%2048, i%2048, gs.srcbuf.bw);
461 u32 write = gdp(j2%2048, i2%2048, gs.dstbuf.bw);
462 pDstBuf[write] = (pDstBuf[write]&0xf0)|(pSrcBuf[read]&0x0f);
463
464 read = gsp((j+1)%2048, i%2048, gs.srcbuf.bw);
465 write = gdp((j2+1)%2048, i2%2048, gs.dstbuf.bw);
466 pDstBuf[write] = (pDstBuf[write]&0x0f)|(pSrcBuf[read]&0xf0);
467
468 read = gsp((j+2)%2048, i%2048, gs.srcbuf.bw);
469 write = gdp((j2+2)%2048, i2%2048, gs.dstbuf.bw);
470 pDstBuf[write] = (pDstBuf[write]&0xf0)|(pSrcBuf[read]&0x0f);
471
472 read = gsp((j+3)%2048, i%2048, gs.srcbuf.bw);
473 write = gdp((j2+3)%2048, i2%2048, gs.dstbuf.bw);
474 pDstBuf[write] = (pDstBuf[write]&0x0f)|(pSrcBuf[read]&0xf0);
475
476 read = gsp((j+4)%2048, i%2048, gs.srcbuf.bw);
477 write = gdp((j2+4)%2048, i2%2048, gs.dstbuf.bw);
478 pDstBuf[write] = (pDstBuf[write]&0xf0)|(pSrcBuf[read]&0x0f);
479
480 read = gsp((j+5)%2048, i%2048, gs.srcbuf.bw);
481 write = gdp((j2+5)%2048, i2%2048, gs.dstbuf.bw);
482 pDstBuf[write] = (pDstBuf[write]&0x0f)|(pSrcBuf[read]&0xf0);
483
484 read = gsp((j+6)%2048, i%2048, gs.srcbuf.bw);
485 write = gdp((j2+6)%2048, i2%2048, gs.dstbuf.bw);
486 pDstBuf[write] = (pDstBuf[write]&0xf0)|(pSrcBuf[read]&0x0f);
487
488 read = gsp((j+7)%2048, i%2048, gs.srcbuf.bw);
489 write = gdp((j2+7)%2048, i2%2048, gs.dstbuf.bw);
490 pDstBuf[write] = (pDstBuf[write]&0x0f)|(pSrcBuf[read]&0xf0);
491 }
492 }
493 }
494
495 // dir depends on trxpos.dirx & trxpos.diry
496 void TransferLocalLocal()
497 {
498 FUNCLOG
499
500 //ZZLog::Error_Log("I'z in your code, transferring your memory...");
501 assert(gs.imageTransfer == 2);
502 assert(gs.trxpos.sx + gs.imageWnew < 2048 && gs.trxpos.sy + gs.imageHnew < 2048);
503 assert(gs.trxpos.dx + gs.imageWnew < 2048 && gs.trxpos.dy + gs.imageHnew < 2048);
504 assert((gs.srcbuf.psm&0x7) == (gs.dstbuf.psm&0x7));
505
506 if (gs.trxpos.sx + gs.imageWnew > gs.srcbuf.bw)
507 ZZLog::Debug_Log("Transfer error, src width exceeded.(0x%x > 0x%x)", gs.trxpos.sx + gs.imageWnew, gs.srcbuf.bw);
508
509 if (gs.trxpos.dx + gs.imageWnew > gs.dstbuf.bw)
510 ZZLog::Debug_Log("Transfer error, dst width exceeded.(0x%x > 0x%x)", gs.trxpos.dx + gs.imageWnew, gs.dstbuf.bw);
511
512 int srcstart, srcend, dststart, dstend;
513
514 GetRectMemAddress(srcstart, srcend, gs.srcbuf.psm, gs.trxpos.sx, gs.trxpos.sy, gs.imageWnew, gs.imageHnew, gs.srcbuf.bp, gs.srcbuf.bw);
515 GetRectMemAddress(dststart, dstend, gs.dstbuf.psm, gs.trxpos.dx, gs.trxpos.dy, gs.imageWnew, gs.imageHnew, gs.dstbuf.bp, gs.dstbuf.bw);
516
517 // resolve the targs
518 ResolveInRange(srcstart, srcend);
519
520 list<CRenderTarget*> listTargs;
521
522 s_RTs.GetTargs(dststart, dstend, listTargs);
523
524 for (list<CRenderTarget*>::iterator it = listTargs.begin(); it != listTargs.end(); ++it)
525 {
526 if (!((*it)->status & CRenderTarget::TS_Virtual))
527 {
528 (*it)->Resolve();
529 //(*it)->status |= CRenderTarget::TS_NeedUpdate;
530 }
531 }
532
533 if (PSMT_BITMODE(gs.srcbuf.psm) != 4)
534 {
535 _TransferLocalLocal();
536 }
537 else
538 {
539 _TransferLocalLocal_4();
540 }
541
542 g_MemTargs.ClearRange(dststart, dstend);
543
544 #ifdef ZEROGS_DEVBUILD
545
546 if (g_bSaveTrans)
547 {
548 tex0Info t;
549 t.tbp0 = gs.dstbuf.bp;
550 t.tw = gs.imageWnew;
551 t.th = gs.imageHnew;
552 t.tbw = gs.dstbuf.bw;
553 t.psm = gs.dstbuf.psm;
554 SaveTex(&t, 0);
555
556 t.tbp0 = gs.srcbuf.bp;
557 t.tw = gs.imageWnew;
558 t.th = gs.imageHnew;
559 t.tbw = gs.srcbuf.bw;
560 t.psm = gs.srcbuf.psm;
561 SaveTex(&t, 0);
562 }
563
564 #endif
565 }
566
567 __forceinline void TerminateLocalHost()
568 {
569 FUNCLOG
570 //ZZLog::Error_Log("Terminate Local Host!");
571 }
572
573 __forceinline void TerminateHostLocal()
574 {
575 FUNCLOG
576 gs.imageTransfer = -1;
577 }
578

  ViewVC Help
Powered by ViewVC 1.1.22