开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
intel2700g.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：49k
源码类别：

Windows CE

开发平台：

C/C++

intel2700g.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: intel2700g.c 607 2006-01-22 20:58:29Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "stdafx.h"
  25. #include "gxvadd.h"
  27. #if defined(ARM)
  29. #define VSYNC_WORKAROUND
  31. typedef struct pvr
  32. {
  33. overlay p;
  34. idct IdctVMT;
  36. // idct
  37. int mx,my;
  38. int SubPos;
  39. int ImageWrite[3];
  40. int MCompType;
  41. int FetchA[2][2];
  42. int Width16;
  43. int Height16;
  45. // vsync
  46. #ifdef VSYNC_WORKAROUND
  47. bool_t SetupVSync;
  48. bool_t DisableVSync;
  49. int* VSyncPtr;
  50. int VSyncTotal; // total units
  51. int VSyncBottom;   // start of vsync
  52. int VSyncLimit; // units per 1msec
  53. tick_t VSyncRefresh;
  54. #endif
  56. GXVAError (*M24VA_FrameDimensions)(gx_uint32 ui32Height, gx_uint32 ui32Width);
  57. GXVAError (*M24VA_FrameAllocate)(SMSurface *phFrames, gx_uint32 ui32FrameCnt);
  58. GXVAError (*M24VA_FrameFree)(SMSurface *phFrames, gx_uint32 ui32FrameCnt);
  59. GXVAError (*M24VA_BeginFrame)(SMSurface hOutputSurface, gx_bool bEnableIDCT);
  60. GXVAError (*M24VA_EndFrame)(gx_bool bSyncHardware);
  61. GXVAError (*M24VA_SetReferenceFrameAddress)(gx_uint32 ui32FrameNo, SMSurface hSurface);
  62. GXVAError (*M24VA_FrameBeginAccess)(SMSurface hSurface, gx_uint8 **ppuint8FrameAddress, gx_uint32 *pui32FrameStride, gx_bool bSyncHardware);
  63. GXVAError (*M24VA_FrameEndAccess)(SMSurface hSurface);
  64. GXVAError (*M24VA_WriteIZZBlock)(gx_int32 *pi32Data, gx_uint32 ui32Count);
  65. GXVAError (*M24VA_WriteIZZData)(gx_int32 i32Coeff, gx_uint32 ui32Index, gx_bool bEOB);
  66. GXVAError (*M24VA_SetIZZMode)(GXVA_IZZMODE eMode);
  67. GXVAError (*M24VA_WriteResidualDifferenceData)(gx_int16 *pi16Data, gx_uint32 ui32Count); 
  68. GXVAError (*M24VA_WriteMCCmdData)(gx_uint32 ui32Data);
  69. GXVAError (*M24VA_FCFrameAllocate)(SMSurface *phFrame, GXVA_SURF_FORMAT eFormat);
  70. GXVAError (*M24VA_FrameConvert)(SMSurface hDestSurface, SMSurface hSourSurface);                                        
  71. GXVAError (*M24VA_Initialise)(void*);
  72. GXVAError (*M24VA_Deinitialise)();
  73. GXVAError (*M24VA_Reset)();
  75. VDISPError (*VDISP_Initialise)(void*);
  76. VDISPError (*VDISP_Deinitialise)();
  77. VDISPError (*VDISP_OverlaySetAttributes)(PVDISP_OVERLAYATTRIBS psOverlayAttributes, SMSurface hSurface);
  78. VDISPError (*VDISP_OverlayFlipSurface)(SMSurface hSurfaceFlipTo, VDISP_DEINTERLACE eDeinterlace);
  79. VDISPError (*VDISP_OverlayContrast)(gx_uint32 ui32Contrast);
  80. VDISPError (*VDISP_OverlayGamma)(gx_uint32 ui32Gamma);
  81. VDISPError (*VDISP_OverlayBrightness)(gx_uint32 ui32Brightness);
  82. VDISPError (*VDISP_OverlaySetColorspaceConversion)(PVDISP_CSCCoeffs psCoeffs);
  84. int16_t IZZ[2*(64+8)];
  86. VDISP_OVERLAYATTRIBS Attribs;
  87. uint8_t* RegBase;
  88. bool_t CloseWMP;
  89. bool_t SetupIDCTRotate;
  90. bool_t M24VA;
  91. bool_t VDISP;
  92. bool_t IDCT;
  93. bool_t YUV422;
  94. bool_t Empty;
  95. bool_t IDCTInit;
  96. bool_t Initing;
  97. bool_t FirstUpdate;
  98. int FirstUpdateTime;
  99. int IDCTMemInit;
  100. int IDCTWidth;
  101. int IDCTHeight;
  102. int AllCount;
  103. int BufCount;
  104. int TempCount;
  105. int ShowNext;
  106. int ShowCurr;
  107. int ShowLast;
  108. int FlipLastTime;
  109. int NativeDirection;
  110. video Overlay;
  111. rect OverlayRect;
  112. blitfx OvlFX;
  113. blitfx SoftFX;
  114. pin IDCTOutput;
  115. bool_t IDCTRounding;
  116. int Brightness;
  117. int Contrast;
  118. int Saturation;
  119. int RGBAdjust[3];
  121. SMSurface Buf[MAXIDCTBUF]; 
  122. planes BufMem[MAXIDCTBUF];
  123. int BufFrameNo[MAXIDCTBUF];
  125. } pvr;
  127. #define PVR(p) ((pvr*)((char*)(p)-(int)&(((pvr*)0)->IdctVMT)))
  129. //------------------------------------------------------------
  131. #define MID 0x3FE0FF0
  132. #define DVT01 0x3FE2164
  133. #define DVT02 0x3FE2168
  134. #define DVT03 0x3FE216C
  135. #define DVLNUM 0x3FE2308
  137. static void GetMode(pvr* p)
  138. {
  139. RawFrameBufferInfo Info;
  140. HDC DC= GetDC(NULL);
  141. memset(&Info,0,sizeof(Info));
  142. ExtEscape(DC, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char*)&Info);
  143. ReleaseDC(NULL,DC);
  145. p->NativeDirection = 0;
  147. #ifdef VSYNC_WORKAROUND
  148. p->VSyncPtr = NULL;
  149. #endif
  151. if (Info.pFramePointer)
  152. {
  153. if (abs(Info.cyStride) < abs(Info.cxPixels * Info.cxStride))
  154. SwapInt(&Info.cxPixels,&Info.cyPixels); // correct possible orientation error
  156. if (abs(Info.cyStride) < abs(Info.cxStride))
  157. {
  158. p->NativeDirection |= DIR_SWAPXY;
  159. if (Info.cxStride<0) 
  160. p->NativeDirection |= DIR_MIRRORUPDOWN;
  161. if (Info.cyStride<0) 
  162. p->NativeDirection |= DIR_MIRRORLEFTRIGHT;
  163. }
  164. else
  165. {
  166. if (Info.cxStride<0) 
  167. p->NativeDirection |= DIR_MIRRORLEFTRIGHT;
  168. if (Info.cyStride<0) 
  169. p->NativeDirection |= DIR_MIRRORUPDOWN;
  170. }
  172. p->NativeDirection = CombineDir(0,p->NativeDirection,GetOrientation());
  173. p->RegBase = (uint8_t*)((uint32_t)Info.pFramePointer & ~(1024*1024-1)); // align to 1MB
  175. #ifdef VSYNC_WORKAROUND
  176. {
  177. int VSyncTop = 0;
  179. p->VSyncTotal = -1;
  180. p->VSyncBottom = 0;
  182. TRY_BEGIN
  183. if ((*(uint32_t*)(p->RegBase+MID) & 0xFFFFFF) == 0x727189) // Intel 2700G ?
  184. {
  185. p->VSyncRefresh = TICKSPERSEC / 60; // todo: find a way to get lcd refresh rate
  186. p->VSyncTotal = *(uint32_t*)(p->RegBase+DVT01) & 4095;
  187. VSyncTop = *(uint32_t*)(p->RegBase+DVT02) & 4095;
  188. p->VSyncBottom = *(uint32_t*)(p->RegBase+DVT03) & 4095;
  189. p->VSyncLimit = Scale(p->VSyncTotal,TICKSPERSEC,p->VSyncRefresh*1000);
  190. }
  191. TRY_END
  193. if (p->VSyncTotal >= p->VSyncBottom && (p->VSyncBottom  - VSyncTop) >= Info.cyPixels)
  194. {
  195. p->VSyncBottom -= 16; // adjust a little
  196. p->VSyncPtr = (int*)(p->RegBase+DVLNUM);
  197. }
  198. }
  199. #endif
  200. }
  201. QueryDesktop(&p->p.Output.Format.Video);
  202. }
  204. static void BufferFormat(pvr* p,video* Format)
  205. {
  206. *Format = p->Overlay;
  207. DefaultPitch(Format);
  208. }
  210. static void ClearIMC4(uint8_t* Ptr,const video* Format)
  211. {
  212. FillColor(Ptr,
  213. Format->Pitch,0,0,Format->Width,Format->Height,8,0);
  214. FillColor(Ptr+Format->Pitch*Format->Height,
  215. Format->Pitch,0,0,Format->Width>>1,Format->Height>>1,8,128);
  216. FillColor(Ptr+Format->Pitch*Format->Height+(Format->Pitch >> 1),
  217. Format->Pitch,0,0,Format->Width>>1,Format->Height>>1,8,128);
  218. }
  220. static int UpdateAlloc(pvr* p,int BufCount,int TempCount,int MemCount)
  221. {
  222. int Result = ERR_NONE;
  223. int AllCount;
  225. if (BufCount && BufCount+TempCount<2)
  226. ++TempCount;
  228. AllCount = BufCount + TempCount;
  229. if (AllCount > MAXIDCTBUF)
  230. return ERR_INVALID_PARAM;
  232. if (p->AllCount > AllCount)
  233. {
  234. p->M24VA_FrameFree(&p->Buf[AllCount],p->AllCount-AllCount);
  236. p->AllCount = AllCount;
  237. p->BufCount = BufCount;
  238. p->TempCount = TempCount;
  239. }
  240. else
  241. {
  242. p->BufCount = min(p->AllCount,BufCount);
  243. p->TempCount = p->AllCount - p->BufCount;
  245. while (p->AllCount < AllCount)
  246. {
  247. gx_uint8* Ptr;
  248. bool_t Clear = !p->IDCT || MemCount <= p->AllCount;
  250. if (p->IDCT && MemCount <= p->AllCount)
  251. {
  252. video Buffer;
  253. BufferFormat(p,&Buffer);
  254. if (SurfaceAlloc(p->BufMem[p->AllCount],&Buffer) != ERR_NONE)
  255. {
  256. Result = ERR_OUT_OF_MEMORY;
  257. break;
  258. }
  259. ++MemCount;
  260. }
  262. if (p->M24VA_FrameAllocate(&p->Buf[p->AllCount],1) != GXVAError_OK)
  263. {
  264. Result = ERR_OUT_OF_MEMORY;
  265. break;
  266. }
  268. if (Clear && p->M24VA_FrameBeginAccess(p->Buf[p->AllCount],&Ptr,(gx_uint32*)&p->Overlay.Pitch,1) == GXVAError_OK)
  269. {
  270. ClearIMC4(Ptr,&p->Overlay);
  271. p->M24VA_FrameEndAccess(p->Buf[p->AllCount]);
  272. }
  274. p->BufFrameNo[p->AllCount] = -1;
  275. p->AllCount++;
  276. p->BufCount = min(p->AllCount,BufCount);
  277. p->TempCount = p->AllCount - p->BufCount;
  278. }
  279. }
  281. while (MemCount > p->AllCount)
  282. SurfaceFree(p->BufMem[--MemCount]);
  284. return Result;
  285. }
  287. static int16_t Sat11(int x,int Adjust)
  288. { 
  289. x = (x * (Adjust + 256)) >> 8;
  290. return (int16_t)(x>1023?1023:(x<-1024?-1024:x));
  291. }
  293. static int SatUV(pvr* p,int v)
  294. {
  295. int m = p->Saturation;
  296. if (m<0) m >>= 1; // adjust negtive interval: -128..0 -> -64..0
  297. m = 4*m+256;
  298. v = (v*m) >> 8;
  299. return v;
  300. }
  302. static void UpdateColorSpace(pvr* p)
  303. {
  304. VDISP_CSCCoeffs Color;
  305. p->VDISP_OverlayBrightness(p->Brightness+128);
  306. p->VDISP_OverlayContrast(p->Contrast+128);
  308. //R = 1.164(Y - 16) + 1.596(V - 128)
  309. //G = 1.164(Y - 16) - 0.813(V - 128) - 0.391(U - 128)
  310. //B = 1.164(Y - 16)                  + 2.018(U - 128)
  312. Color.ui16RyCoeff = Sat11(298,p->RGBAdjust[0]);
  313. Color.ui16RuCoeff = Sat11(SatUV(p,0),p->RGBAdjust[0]);
  314. Color.ui16RvCoeff = Sat11(SatUV(p,408),p->RGBAdjust[0]);
  315. Color.ui16GyCoeff = Sat11(298,p->RGBAdjust[1]);
  316. Color.ui16GuCoeff = Sat11(SatUV(p,-100),p->RGBAdjust[1]);
  317. Color.ui16GvCoeff = Sat11(SatUV(p,-208),p->RGBAdjust[1]);
  318. Color.ui16ByCoeff = Sat11(298,p->RGBAdjust[2]);
  319. Color.ui16BuCoeff = Sat11(SatUV(p,517),p->RGBAdjust[2]);
  320. Color.ui16BvCoeff = Sat11(SatUV(p,0),p->RGBAdjust[2]);
  322. p->VDISP_OverlaySetColorspaceConversion(&Color);
  323. }
  325. static void ReInit(pvr* p);
  326. static int Lock(pvr* p,int No,planes Planes,bool_t UseReInit);
  327. static void Unlock(pvr* p,int No);
  329. static bool_t UpdateDirection(pvr* p)
  330. {
  331. int No;
  332. video New = p->Overlay;
  334. p->OvlFX = p->p.FX;
  336. memset(&p->SoftFX,0,sizeof(blitfx));
  337. p->SoftFX.Flags = p->p.FX.Flags & BLITFX_DITHER;
  338. p->SoftFX.ScaleX = SCALE_ONE;
  339. p->SoftFX.ScaleY = SCALE_ONE;
  341. if (p->IDCT && (!p->SetupIDCTRotate || p->YUV422))
  342. {
  343. p->SoftFX.Direction = 0;
  344. p->OvlFX.Direction = CombineDir(p->p.InputDirection,p->p.OrigFX.Direction,p->p.Output.Format.Video.Direction);
  345. }
  346. else
  347. {
  348. p->SoftFX.Direction = CombineDir(p->p.InputDirection,p->p.OrigFX.Direction,p->NativeDirection);
  349. p->OvlFX.Direction = CombineDir(p->NativeDirection,0,p->p.Output.Format.Video.Direction);
  350. }
  352. if (p->SoftFX.Direction & DIR_SWAPXY)
  353. SwapInt(&p->OvlFX.ScaleX,&p->OvlFX.ScaleY);
  355. #ifdef VSYNC_WORKAROUND
  356. // hwrotation is used? no vsync needed
  357. p->DisableVSync = !p->SetupVSync || ((p->OvlFX.Direction ^ p->NativeDirection ^ p->p.Output.Format.Video.Direction) & DIR_SWAPXY) != 0;
  358. #endif
  360. New.Width = p->Width16+16;
  361. New.Height = p->Height16+16;
  362. New.Direction = CombineDir(p->p.Input.Format.Video.Direction,p->SoftFX.Direction,0);
  363. if (New.Direction & DIR_SWAPXY)
  364. SwapInt(&New.Width,&New.Height);
  365. New.Pitch = New.Width;
  367. // DEBUG_MSG6(-1,T("UpdateDirection w:%d h:%d dir:%d native:%d softfx:%d ovlfx:%d"),
  368. // New.Width,New.Height,New.Direction,p->NativeDirection,p->SoftFX.Direction,p->OvlFX.Direction);
  370. if (New.Direction != p->Overlay.Direction)
  371. {
  372. planes Planes;
  373. int Rotate;
  374. planes BufMem = { NULL };
  375. int BufCount = p->BufCount;
  376. int TempCount = p->TempCount;
  377. video Buffer;
  378. BufferFormat(p,&Buffer);
  380. if (p->Attribs.ui16ValidFlags)
  381. {
  382. Sleep(50); // be sure last flipping finished
  383. p->Attribs.bOverlayOn = 0;
  384. p->VDISP_OverlaySetAttributes(&p->Attribs,p->Buf[0]);
  385. p->VDISP_OverlaySetAttributes(&p->Attribs,p->Buf[1]);
  386. Sleep(20); //wait for overlay turn off
  387. }
  389. // save old surfaces
  390. if (p->IDCT)
  391. {
  392. for (No=0;No<p->BufCount;++No)
  393. if (p->BufMem[No][0] && Lock(p,No,Planes,0)==ERR_NONE)
  394. {
  395. SurfaceCopy(&p->Overlay,&Buffer,Planes,p->BufMem[No],NULL);
  396. Unlock(p,No);
  397. }
  398. }
  399. else
  400. {
  401. // only ShowCurr
  402. if (Lock(p,p->ShowCurr,Planes,0)==ERR_NONE)
  403. {
  404. if (SurfaceAlloc(BufMem,&Buffer) == ERR_NONE)
  405. SurfaceCopy(&p->Overlay,&Buffer,Planes,BufMem,NULL);
  406. Unlock(p,p->ShowCurr);
  407. }
  408. }
  410. if (p->AllCount)
  411. p->M24VA_FrameFree(p->Buf,p->AllCount);
  412. p->AllCount = 0;
  413. p->TempCount = 0;
  414. p->BufCount = 0;
  415. p->Empty = 1;
  416. p->ShowLast = -1;
  417. if (p->ShowNext >= 0)
  418. p->ShowCurr = p->ShowNext;
  419. if (p->ShowCurr<0 || p->ShowCurr>=BufCount)
  420. p->ShowCurr = 0;
  422. if (p->M24VA_FrameDimensions(New.Height,New.Width) == GXVAError_HardwareNotAvailable && !p->Initing)
  423. {
  424. ReInit(p);
  425. return 1;
  426. }
  428. p->Overlay = New;
  429. UpdateAlloc(p,BufCount,TempCount,BufCount+TempCount);
  431. // restore old surfaces (rotated)
  432. Rotate = CombineDir(Buffer.Direction,0,New.Direction);
  433. if (p->IDCT)
  434. {
  435. for (No=0;No<p->BufCount;++No)
  436. if (p->BufMem[No][0] && Lock(p,No,Planes,1)==ERR_NONE)
  437. {
  438. SurfaceRotate(&Buffer,&p->Overlay,p->BufMem[No],Planes,Rotate);
  439. Unlock(p,No);
  440. }
  441. }
  442. else
  443. if (BufMem[0])
  444. {
  445. if (Lock(p,p->ShowCurr,Planes,1)==ERR_NONE)
  446. {
  447. SurfaceRotate(&Buffer,&p->Overlay,BufMem,Planes,Rotate);
  448. Unlock(p,p->ShowCurr);
  449. }
  450. SurfaceFree(BufMem);
  451. }
  453. return 1;
  454. }
  455. return 0;
  456. }
  458. static const datatable PVRParams[] = 
  459. {
  460. #ifdef VSYNC_WORKAROUND
  461. { INTEL2700G_VSYNC, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  462. #endif
  463. { INTEL2700G_IDCTROTATE, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  464. { INTEL2700G_CLOSE_WMP, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  466. DATATABLE_END(INTEL2700G_ID)
  467. };
  469. static int Enum(pvr* p, int* No, datadef* Param)
  470. {
  471. if (OverlayEnum(&p->p,No,Param)==ERR_NONE)
  472. return ERR_NONE;
  473. return NodeEnumTable(No,Param,PVRParams);
  474. }
  476. static void Done(pvr* p);
  478. static int Set(pvr* p,int No,const void* Data,int Size)
  479. {
  480. int Result = OverlaySet(&p->p,No,Data,Size);
  481. switch (No)
  482. {
  483. #ifdef VSYNC_WORKAROUND
  484. case INTEL2700G_VSYNC: SETVALUE(p->SetupVSync,bool_t,OverlayUpdateFX(&p->p,0)); break;
  485. #endif
  486. case INTEL2700G_CLOSE_WMP: SETVALUE(p->CloseWMP,bool_t,ERR_NONE); break;
  487. case INTEL2700G_IDCTROTATE: SETVALUE(p->SetupIDCTRotate,bool_t,OverlayUpdateFX(&p->p,0)); break;
  489. case NODE_CRASH:
  490. memset(p->BufMem,0,sizeof(p->BufMem)); // heap could be corrupted
  491. Done(p);
  492. break;
  493. }
  495. return Result;
  496. }
  498. static int Get(pvr* p,int No,void* Data,int Size)
  499. {
  500. int Result = OverlayGet(&p->p,No,Data,Size);
  501. switch (No)
  502. {
  503. #ifdef VSYNC_WORKAROUND
  504. case INTEL2700G_VSYNC: GETVALUE(p->SetupVSync,bool_t); break;
  505. #endif
  506. case INTEL2700G_CLOSE_WMP: GETVALUE(p->CloseWMP,bool_t); break;
  507. case INTEL2700G_IDCTROTATE: GETVALUE(p->SetupIDCTRotate,bool_t); break;
  508. }
  509. return Result;
  510. }
  512. static int Update(pvr* p);
  514. static BOOL CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lParam)
  515. {
  516. if (!(GetWindowLong(hWnd,GWL_STYLE) & WS_POPUP))
  517. {
  518. tchar_t Name[64];
  519. if (GetWindowText(hWnd,Name,64)>0 && tcscmp(Name,T("Windows Media"))==0)
  520. *(HWND*)lParam = hWnd;
  521. }
  522. return TRUE;
  523. }
  525. static HWND FindWMP()
  526. {
  527. HWND Result = NULL;
  528. EnumWindows(EnumWindowsProc,(LPARAM)&Result);
  529. return Result;
  530. }
  532. static bool_t InitM24VA(pvr* p)
  533. {
  534. HWND WMP = NULL;
  535. int ReTry;
  537. for (;;)
  538. {
  539. for (ReTry=0;ReTry<4;++ReTry)
  540. {
  541. if (ReTry)
  542. ThreadSleep(50);
  543. if (p->M24VA_Initialise(NULL) == GXVAError_OK)
  544. {
  545. p->M24VA = 1;
  546. return 1;
  547. }
  548. }
  550. if (!p->CloseWMP || WMP || (WMP = FindWMP())==NULL)
  551. break;
  553. PostMessage(WMP,WM_CLOSE,0,0);
  554. }
  556. ShowError(INTEL2700G_ID,INTEL2700G_ID,INTEL2700G_LOCKED);
  557. return 0;
  558. }
  560. static void ReInit(pvr* p)
  561. {
  562. int BufCount = p->BufCount;
  563. int TempCount = p->TempCount;
  565. if (p->VDISP)
  566. {
  567. p->VDISP_Deinitialise();
  568. p->VDISP = 0;
  569. }
  571. // keep p->BufMem[]
  572. if (p->AllCount)
  573. p->M24VA_FrameFree(p->Buf,p->AllCount);
  574. p->AllCount = 0;
  575. p->TempCount = 0;
  576. p->BufCount = 0;
  578. if (p->M24VA)
  579. {
  580. p->M24VA_Deinitialise();
  581. p->M24VA = 0;
  582. }
  584. p->Initing = 1;
  585. if (InitM24VA(p))
  586. {
  587. if (p->VDISP_Initialise(NULL) == VDISPError_OK)
  588. {
  589. p->VDISP = 1;
  590. memset(&p->Attribs,0,sizeof(p->Attribs)); // force new udpate
  591. p->Overlay.Direction = -1; // force update in UpdateDirection
  592. p->FirstUpdate = 1;
  593. p->FirstUpdateTime = GetTimeTick() - 10000;
  595. UpdateColorSpace(p);
  596. UpdateDirection(p);
  597. UpdateAlloc(p,BufCount,TempCount,BufCount+TempCount);
  598. Update(p);
  599. }
  600. else
  601. {
  602. p->M24VA_Deinitialise();
  603. p->M24VA = 0;
  604. }
  605. }
  606. p->Initing = 0;
  607. }
  609. static void Done(pvr* p)
  610. {
  611. int No;
  613. if (p->VDISP)
  614. {
  615. p->VDISP_Deinitialise();
  616. p->VDISP = 0;
  617. }
  619. if (p->AllCount)
  620. p->M24VA_FrameFree(p->Buf,p->AllCount);
  622. for (No=0;No<p->AllCount;++No)
  623. SurfaceFree(p->BufMem[No]);
  625. p->AllCount = 0;
  626. p->TempCount = 0;
  627. p->BufCount = 0;
  629. if (p->M24VA)
  630. {
  631. p->M24VA_Deinitialise();
  632. p->M24VA = 0;
  633. }
  634. }
  636. static int Init(pvr* p)
  637. {
  638. int Result = ERR_DEVICE_ERROR;
  640. p->BufCount = 0;
  641. p->AllCount = 0;
  642. p->TempCount = 0;
  643. p->YUV422 = 0;
  644. #ifdef VSYNC_WORKAROUND
  645. p->DisableVSync = !p->SetupVSync;
  646. #endif
  648. if (p->IDCTInit)
  649. {
  650. if (!PlanarYUV420(&p->p.Input.Format.Video.Pixel))
  651. {
  652. if (PlanarYUV422(&p->p.Input.Format.Video.Pixel))
  653. p->YUV422 = 1;
  654. else
  655. return ERR_NOT_SUPPORTED;
  656. }
  657. }
  659. p->Initing = 1;
  661. if (InitM24VA(p))
  662. {
  663. if (p->VDISP_Initialise(NULL) == VDISPError_OK)
  664. {
  665. p->VDISP = 1;
  666. p->IDCT = p->IDCTInit;
  668. p->FirstUpdate = 1;
  669. memset(&p->Attribs,0,sizeof(p->Attribs));
  671. p->Brightness = 0;
  672. p->Contrast = 0;
  673. p->Saturation = 0;
  674. p->RGBAdjust[0] = 0;
  675. p->RGBAdjust[1] = 0;
  676. p->RGBAdjust[2] = 0;
  678. p->FlipLastTime = GetTimeTick();
  679. p->RegBase = NULL;
  681. p->IDCTOutput.Node = (node*)p;
  682. p->IDCTOutput.No = OUT_INPUT;
  683. p->IDCTRounding = 0;
  684. p->Width16 = ALIGN16(p->IDCT ? p->IDCTWidth:p->p.Input.Format.Video.Width)-16;
  685. if (p->Width16<0) p->Width16=0;
  686. p->Height16 = ALIGN16(p->IDCT ? p->IDCTHeight:p->p.Input.Format.Video.Height)-16;
  687. if (p->Height16<0) p->Height16=0;
  689. if (p->IDCT)
  690. {
  691. if (p->p.Input.Format.Video.Direction & DIR_SWAPXY)
  692. SwapInt(&p->p.Input.Format.Video.Width,&p->p.Input.Format.Video.Height);
  693. p->p.Input.Format.Video.Direction = 0;
  694. }
  695. else
  696. if (p->p.Input.Format.Video.Direction & DIR_SWAPXY)
  697. SwapInt(&p->Width16,&p->Height16);
  699. p->ShowCurr = 0;
  700. p->ShowNext = -1;
  701. p->ShowLast = -1;
  703. GetMode(p);
  705. p->Overlay = p->p.Input.Format.Video;
  706. p->Overlay.Pitch = 0;
  707. p->Overlay.Pixel.Flags = PF_FOURCC;
  708. p->Overlay.Pixel.FourCC = FOURCC_IMC4;
  709. p->Overlay.Aspect = ASPECT_ONE;
  710. p->Overlay.Direction = -1; // force update in UpdateDirection
  711. p->Overlay.Width = 0;
  712. p->Overlay.Height = 0;
  714. UpdateColorSpace(p);
  715. UpdateDirection(p);
  717. Result = UpdateAlloc(p,max(3-p->IDCT,p->IDCTMemInit),0,p->IDCTMemInit);
  719. }
  720. }
  721. else
  722. Result = ERR_NOT_SUPPORTED;
  724. p->Initing = 0;
  726. if (Result != ERR_NONE)
  727. Done(p);
  729. return Result;
  730. }
  732. static int Update(pvr* p)
  733. {
  734. int NativeFX;
  735. rect FullScreen;
  736. VDISP_OVERLAYATTRIBS Attribs;
  737. bool_t Slept = UpdateDirection(p);
  739. if (p->Brightness != p->p.FX.Brightness ||
  740. p->Contrast != p->p.FX.Contrast ||
  741. p->Saturation != p->p.FX.Saturation ||
  742. p->RGBAdjust[0] != p->p.FX.RGBAdjust[0] ||
  743. p->RGBAdjust[1] != p->p.FX.RGBAdjust[1] ||
  744. p->RGBAdjust[2] != p->p.FX.RGBAdjust[2])
  745. {
  746. p->Brightness = p->p.FX.Brightness;
  747. p->Contrast = p->p.FX.Contrast;
  748. p->Saturation = p->p.FX.Saturation;
  749. p->RGBAdjust[0] = p->p.FX.RGBAdjust[0];
  750. p->RGBAdjust[1] = p->p.FX.RGBAdjust[1];
  751. p->RGBAdjust[2] = p->p.FX.RGBAdjust[2];
  752. UpdateColorSpace(p);
  753. }
  755. NativeFX = CombineDir(p->p.InputDirection,p->p.OrigFX.Direction,p->NativeDirection);
  756. p->p.PrefDirection = CombineDir(NativeFX,0,p->p.Input.Format.Video.Direction);
  758. PhyToVirt(NULL,&FullScreen,&p->p.Output.Format.Video);
  759. p->p.ColorKey = COLORKEY; 
  761. VirtToPhy(&p->p.Viewport,&p->p.DstAlignedRect,&p->p.Output.Format.Video);
  762. VirtToPhy(NULL,&p->p.SrcAlignedRect,&p->p.Input.Format.Video);
  763. if (p->IDCT)
  764. {
  765. p->OverlayRect = p->p.SrcAlignedRect;
  766. if (p->SoftFX.Direction & DIR_SWAPXY)
  767. SwapInt(&p->OverlayRect.Width,&p->OverlayRect.Height);
  768. if (p->SoftFX.Direction & DIR_MIRRORLEFTRIGHT)
  769. p->OverlayRect.x += p->Overlay.Width - p->OverlayRect.Width;
  770. if (p->SoftFX.Direction & DIR_MIRRORUPDOWN)
  771. p->OverlayRect.y += p->Overlay.Height - p->OverlayRect.Height;
  772. p->p.Caps = 0; // no dither
  773. }
  774. else
  775. {
  776. VirtToPhy(NULL,&p->OverlayRect,&p->Overlay);
  777. BlitRelease(p->p.Soft);
  778. p->p.Soft = BlitCreate(&p->Overlay,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  779. BlitAlign(p->p.Soft, &p->OverlayRect, &p->p.SrcAlignedRect);
  780. }
  782. p->p.Caps |= VC_BRIGHTNESS|VC_SATURATION|VC_CONTRAST|VC_RGBADJUST;
  783. AnyAlign(&p->p.DstAlignedRect, &p->OverlayRect, &p->OvlFX, 2, 2, SCALE_ONE/4, SCALE_ONE*8);
  784. PhyToVirt(&p->p.DstAlignedRect,&p->p.GUIAlignedRect,&p->p.Output.Format.Video);
  786. OverlayUpdateShow(&p->p,1);
  787. if (p->p.ColorKey != RGB_NULL)
  788. WinInvalidate(&p->p.Viewport,1);
  790. // setup overlay attributes
  791. if (p->AllCount>=2)
  792. {
  793. bool_t Show = p->p.Show && (!p->IDCT || (p->IDCTWidth>0 && p->IDCTHeight>0));
  794. memset(&Attribs,0,sizeof(Attribs));
  796. Attribs.bDisableRotation = 0;
  797. if (p->OvlFX.Direction & DIR_SWAPXY)
  798. Attribs.ui16RotateDegree = (gx_uint16)((p->OvlFX.Direction & DIR_MIRRORUPDOWN) ? 90:270);
  799. else
  800. Attribs.ui16RotateDegree = (gx_uint16)((p->OvlFX.Direction & DIR_MIRRORUPDOWN) ? 180:0);
  802. Attribs.bCKeyOn = 1;//p->p.ColorKey != RGB_NULL;
  803. Attribs.ui32CKeyValue = RGBToFormat(p->p.ColorKey,&p->p.Output.Format.Video.Pixel); 
  804. Attribs.bOverlayOn = Show;
  805. Attribs.i16Left = (gx_int16)p->p.DstAlignedRect.x;
  806. Attribs.i16Top = (gx_int16)p->p.DstAlignedRect.y;
  807. Attribs.i16Right = (gx_int16)(p->p.DstAlignedRect.Width + p->p.DstAlignedRect.x);
  808. Attribs.i16Bottom = (gx_int16)(p->p.DstAlignedRect.Height + p->p.DstAlignedRect.y);
  809. Attribs.ui16SrcX1 = (gx_uint16)p->OverlayRect.x;
  810. Attribs.ui16SrcY1 = (gx_uint16)p->OverlayRect.y;
  811. Attribs.ui16SrcX2 = (gx_uint16)(p->OverlayRect.Width + p->OverlayRect.x);
  812. Attribs.ui16SrcY2 = (gx_uint16)(p->OverlayRect.Height + p->OverlayRect.y);
  813. Attribs.ui16ValidFlags = 
  814. VDISP_OVERLAYATTRIB_VALID_CKEY | VDISP_OVERLAYATTRIB_VALID_VISIBILITY |
  815. VDISP_OVERLAYATTRIB_VALID_DSTPOSITION | VDISP_OVERLAYATTRIB_VALID_SRCPOSITION | 0x20 | 0x40;
  817. if (memcmp(&p->Attribs,&Attribs,sizeof(Attribs))!=0)
  818. {
  819. if (!Slept && !p->FirstUpdate)
  820. Sleep(50); // be sure last flipping finished
  822. if (Show)
  823. {
  824. if (!p->FirstUpdate) // already updated?
  825. {
  826. if (p->Attribs.bOverlayOn || p->Attribs.ui16RotateDegree != Attribs.ui16RotateDegree)
  827. {
  828. // we don't want to trash the screen when the new rotation attributes are set
  829. // disable overlay first and flip the current surface with the new settings
  831. // with X50v A03 ROM setting attribs when the overlay is on seem to make them move
  832. // let's turn overlay off before setting new src/dst rectangles 
  834. Attribs.bOverlayOn = 0;
  835. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[0]);
  836. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[1]);
  837. p->Empty = 1;
  838. }
  840. if (p->Empty)
  841. {
  842. p->VDISP_OverlayFlipSurface(p->Buf[p->ShowCurr],VDISP_NONE);
  843. Sleep(50); //wait flipping
  844. }
  846. Attribs.bOverlayOn = 1;
  847. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[0]);
  848. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[1]);
  849. }
  850. else
  851. {
  852. int Time = GetTimeTick();
  853. p->FirstUpdate = 0;
  855. if (p->FirstUpdateTime+500 < Time) // avoid this step if it was done recently
  856. {
  857. // first create a 100% (without this the overlay stais black after sleep mode)
  858. p->FirstUpdateTime = Time;
  860. p->Attribs = Attribs;
  861. p->Attribs.i16Left = 0;
  862. p->Attribs.i16Top = 0;
  863. p->Attribs.i16Right = 16;
  864. p->Attribs.i16Bottom = 16;
  865. p->Attribs.ui16SrcX1 = 0;
  866. p->Attribs.ui16SrcY1 = 0;
  867. p->Attribs.ui16SrcX2 = 16;
  868. p->Attribs.ui16SrcY2 = 16;
  869. p->Attribs.bOverlayOn = QueryPlatform(PLATFORM_VER) >= 500;
  871. p->VDISP_OverlaySetAttributes(&p->Attribs,p->Buf[0]);
  872. p->VDISP_OverlaySetAttributes(&p->Attribs,p->Buf[1]);
  873. p->VDISP_OverlayFlipSurface(p->Buf[p->ShowCurr],VDISP_NONE);
  874. Sleep(50);
  875. }
  877. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[0]);
  878. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[1]);
  879. }
  881. Sleep(20); //wait for overlay turn on
  882. p->Empty = 0;
  883. }
  884. else
  885. {
  886. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[0]);
  887. p->VDISP_OverlaySetAttributes(&Attribs,p->Buf[1]);
  888. Sleep(20); //wait for overlay turn off
  889. }
  891. p->Attribs = Attribs;
  892. }
  893. }
  895. return ERR_NONE;
  896. }
  898. static int Lock(pvr* p,int No,planes Planes,bool_t UseReInit)
  899. {
  900. GXVAError Result;
  902. Planes[1] = NULL;
  903. Planes[2] = NULL;
  905. if (No<0 || No>=p->AllCount)
  906. {
  907. Planes[0] = NULL;
  908. return ERR_INVALID_PARAM;
  909. }
  911. Result = p->M24VA_FrameBeginAccess(p->Buf[No],(gx_uint8**) &Planes[0],(gx_uint32*)&p->Overlay.Pitch,1);
  913. if (Result == GXVAError_HardwareNotAvailable && UseReInit && !p->Initing)
  914. {
  915. ReInit(p);
  916. if (p->M24VA) 
  917. Result = p->M24VA_FrameBeginAccess(p->Buf[No],(gx_uint8**) &Planes[0],(gx_uint32*)&p->Overlay.Pitch,1);
  918. }
  920. return (Result == GXVAError_OK) ? ERR_NONE : ERR_DEVICE_ERROR;
  921. }
  923. static void Unlock(pvr* p,int No)
  924. {
  925. p->M24VA_FrameEndAccess(p->Buf[No]);
  926. }
  928. static int Blit(pvr* p, const constplanes Data, const constplanes DataLast )
  929. {
  930. planes Planes;
  931. int Result;
  933. if (!p->M24VA)
  934. return ERR_DEVICE_ERROR;
  936. p->ShowLast = p->ShowCurr;
  937. if (++p->ShowCurr == p->AllCount)
  938. p->ShowCurr = 0;
  940. Result = Lock(p,p->ShowCurr,Planes,1);
  941. if (Result == ERR_NONE)
  942. {
  943. BlitImage(p->p.Soft,Planes,Data,DataLast,p->Overlay.Pitch,-1);
  945. Unlock(p,p->ShowCurr);
  947. if (p->p.CurrTime<0 && p->p.LastTime>=0)
  948. {
  949. int t = GetTimeTick();
  950. if (t-p->FlipLastTime<16) // it would just stall unneccessary the benchmark
  951. return ERR_NONE;
  952. p->FlipLastTime = t;
  953. }
  955. if (p->Attribs.bOverlayOn)
  956. p->VDISP_OverlayFlipSurface(p->Buf[p->ShowCurr],VDISP_NONE);
  957. }
  958. return Result;
  959. }
  961. static int UpdateShow(pvr* p)
  962. {
  963. Update(p);
  964. return ERR_NONE;
  965. }
  967. static int Reset(pvr* p)
  968. {
  969. GetMode(p);
  970. return ERR_NONE;
  971. }
  973. //------------------------------------------------------------
  975. static const uint8_t ScanTable[3][64] = {
  976. {
  977.  0,  1,  8, 16,  9,  2,  3, 10, 
  978. 17, 24, 32, 25, 18, 11,  4,  5,
  979. 12, 19, 26, 33, 40, 48, 41, 34, 
  980. 27, 20, 13,  6,  7, 14, 21, 28, 
  981. 35, 42, 49, 56, 57, 50, 43, 36, 
  982. 29, 22, 15, 23, 30, 37, 44, 51, 
  983. 58, 59, 52, 45, 38, 31, 39, 46, 
  984. 53, 60, 61, 54, 47, 55, 62, 63
  985. },
  986. {
  987.    0,  1,  2,  3,  8,  9, 16, 17, 
  988. 10, 11,  4,  5,  6,  7, 15, 14,
  989. 13, 12, 19, 18, 24, 25, 32, 33, 
  990. 26, 27, 20, 21, 22, 23, 28, 29,
  991. 30, 31, 34, 35, 40, 41, 48, 49, 
  992. 42, 43, 36, 37, 38, 39, 44, 45,
  993. 46, 47, 50, 51, 56, 57, 58, 59, 
  994. 52, 53, 54, 55, 60, 61, 62, 63
  995. },
  996. {
  997.  0,  8, 16, 24,  1,  9,  2, 10, 
  998. 17, 25, 32, 40, 48, 56, 57, 49,
  999. 41, 33, 26, 18,  3, 11,  4, 12, 
  1000. 19, 27, 34, 42, 50, 58, 35, 43,
  1001. 51, 59, 20, 28,  5, 13,  6, 14, 
  1002. 21, 29, 36, 44, 52, 60, 37, 45,
  1003. 53, 61, 22, 30,  7, 15, 23, 31, 
  1004. 38, 46, 54, 62, 39, 47, 55, 63
  1005. }};
  1007. static const uint8_t ScanTable8x4[3][64*2] = {
  1008. {
  1009. // source
  1010.  0,  1,  8, 16,  9,  2,  3, 10, 
  1011. 17, 24, 32, 25, 18, 11,  4,  5,
  1012. 12, 19, 26, 33, 40, 48, 41, 34, 
  1013. 27, 20, 13,  6,  7, 14, 21, 28, 
  1014. 35, 42, 49, 56, 57, 50, 43, 36, 
  1015. 29, 22, 15, 23, 30, 37, 44, 51, 
  1016. 58, 59, 52, 45, 38, 31, 39, 46, 
  1017. 53, 60, 61, 54, 47, 55, 62, 63,
  1019. // dest
  1020.  0,  1, 16, 32, 17,  2,  3, 18, 
  1021. 33, 48, 64, 49, 34, 19,  4,  5,
  1022. 20, 35, 50, 64, 64, 64, 64, 64, 
  1023. 51, 36, 21,  6,  7, 22, 37, 52, 
  1024. 64, 64, 64, 64, 64, 64, 64, 64, 
  1025. 53, 38, 23, 39, 54, 64, 64, 64, 
  1026. 64, 64, 64, 64, 64, 55, 64, 64, 
  1027. 64, 64, 64, 64, 64, 64, 64, 64
  1029. }};
  1031. //------------------------------------------------------------
  1033. #define FUNC(x) x##_0
  1034. #define FA_XMASK GXVA_FETCH_A_PREDX_MASK
  1035. #define FA_YMASK GXVA_FETCH_A_PREDY_MASK
  1036. #define FA_XSHIFT GXVA_FETCH_A_PREDX_SHIFT
  1037. #define FA_YSHIFT GXVA_FETCH_A_PREDY_SHIFT
  1038. #define IW_XSHIFT GXVA_IMAGE_WRITE_X_SHIFT
  1039. #define IW_YSHIFT GXVA_IMAGE_WRITE_Y_SHIFT
  1040. #define MIRRORXY
  1041. #define IZZDATA   v <<= 1;
  1042. #define MVDIRX +
  1043. #define MVDIRY +
  1044. #define MVPOS_00 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_0
  1045. #define MVIDX_00 0
  1046. #define MVPOS_01 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_8
  1047. #define MVIDX_01 2
  1048. #define MVPOS_10 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_0
  1049. #define MVIDX_10 4
  1050. #define MVPOS_11 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_8
  1051. #define MVIDX_11 6
  1052. #define IDCT_00 GXVA_IDCT_MODE_BLK_TOP_LEFT
  1053. #define IDCT_01 GXVA_IDCT_MODE_BLK_TOP_RGHT
  1054. #define IDCT_10 GXVA_IDCT_MODE_BLK_BOT_LEFT
  1055. #define IDCT_11 GXVA_IDCT_MODE_BLK_BOT_RGHT
  1057. #include "intel2700g_idct420.h"
  1059. #define FUNC(x) x##_90
  1060. #define FA_XMASK GXVA_FETCH_A_PREDY_MASK
  1061. #define FA_YMASK GXVA_FETCH_A_PREDX_MASK
  1062. #define FA_XSHIFT GXVA_FETCH_A_PREDY_SHIFT
  1063. #define FA_YSHIFT GXVA_FETCH_A_PREDX_SHIFT
  1064. #define IW_XSHIFT GXVA_IMAGE_WRITE_Y_SHIFT
  1065. #define IW_YSHIFT GXVA_IMAGE_WRITE_X_SHIFT
  1066. #define MIRRORXY x=PVR(p)->Width16-x;
  1067. #define IZZDATA   if (v & 1) { d=-d; } v = ((v & 7) << 4)|((v & 56) >> 2);
  1068. #define MVDIRX -
  1069. #define MVDIRY +
  1070. #define MVPOS_00 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_0
  1071. #define MVIDX_00 2
  1072. #define MVPOS_01 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_0
  1073. #define MVIDX_01 0
  1074. #define MVPOS_10 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_8
  1075. #define MVIDX_10 6
  1076. #define MVPOS_11 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_8
  1077. #define MVIDX_11 4
  1078. #define IDCT_00 GXVA_IDCT_MODE_BLK_BOT_LEFT
  1079. #define IDCT_01 GXVA_IDCT_MODE_BLK_TOP_LEFT
  1080. #define IDCT_10 GXVA_IDCT_MODE_BLK_BOT_RGHT
  1081. #define IDCT_11 GXVA_IDCT_MODE_BLK_TOP_RGHT
  1083. #include "intel2700g_idct420.h"
  1085. #define FUNC(x) x##_180
  1086. #define FA_XMASK GXVA_FETCH_A_PREDX_MASK
  1087. #define FA_YMASK GXVA_FETCH_A_PREDY_MASK
  1088. #define FA_XSHIFT GXVA_FETCH_A_PREDX_SHIFT
  1089. #define FA_YSHIFT GXVA_FETCH_A_PREDY_SHIFT
  1090. #define IW_XSHIFT GXVA_IMAGE_WRITE_X_SHIFT
  1091. #define IW_YSHIFT GXVA_IMAGE_WRITE_Y_SHIFT
  1092. #define MIRRORXY x=PVR(p)->Width16-x; y=PVR(p)->Height16-y;
  1093. #define IZZDATA   if ((v ^ (v >> 3)) & 1) { d=-d; } v <<= 1;
  1094. #define MVDIRX -
  1095. #define MVDIRY -
  1096. #define MVPOS_00 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_0
  1097. #define MVIDX_00 6
  1098. #define MVPOS_01 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_8
  1099. #define MVIDX_01 4
  1100. #define MVPOS_10 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_0
  1101. #define MVIDX_10 2
  1102. #define MVPOS_11 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_8
  1103. #define MVIDX_11 0
  1104. #define IDCT_00 GXVA_IDCT_MODE_BLK_BOT_RGHT
  1105. #define IDCT_01 GXVA_IDCT_MODE_BLK_BOT_LEFT
  1106. #define IDCT_10 GXVA_IDCT_MODE_BLK_TOP_RGHT
  1107. #define IDCT_11 GXVA_IDCT_MODE_BLK_TOP_LEFT
  1109. #include "intel2700g_idct420.h"
  1111. #define FUNC(x) x##_270
  1112. #define FA_XMASK GXVA_FETCH_A_PREDY_MASK
  1113. #define FA_YMASK GXVA_FETCH_A_PREDX_MASK
  1114. #define FA_XSHIFT GXVA_FETCH_A_PREDY_SHIFT
  1115. #define FA_YSHIFT GXVA_FETCH_A_PREDX_SHIFT
  1116. #define IW_XSHIFT GXVA_IMAGE_WRITE_Y_SHIFT
  1117. #define IW_YSHIFT GXVA_IMAGE_WRITE_X_SHIFT
  1118. #define MIRRORXY y=PVR(p)->Height16-y;
  1119. #define IZZDATA   if (v & 8) { d=-d; } v = ((v & 7) << 4)|((v & 56) >> 2);
  1120. #define MVDIRX +
  1121. #define MVDIRY -
  1122. #define MVPOS_00 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_0
  1123. #define MVIDX_00 4
  1124. #define MVPOS_01 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_0
  1125. #define MVIDX_01 6
  1126. #define MVPOS_10 GXVA_FETCH_B_ACC_Y_POS_0|GXVA_FETCH_B_ACC_X_POS_8
  1127. #define MVIDX_10 0
  1128. #define MVPOS_11 GXVA_FETCH_B_ACC_Y_POS_8|GXVA_FETCH_B_ACC_X_POS_8
  1129. #define MVIDX_11 2
  1130. #define IDCT_00 GXVA_IDCT_MODE_BLK_TOP_RGHT
  1131. #define IDCT_01 GXVA_IDCT_MODE_BLK_BOT_RGHT
  1132. #define IDCT_10 GXVA_IDCT_MODE_BLK_TOP_LEFT
  1133. #define IDCT_11 GXVA_IDCT_MODE_BLK_BOT_LEFT
  1135. #include "intel2700g_idct420.h"
  1137. //------------------------------------------------------------
  1139. #include "intel2700g_idct422.h"
  1141. //------------------------------------------------------------
  1143. static idctmcomp const IDCTMComp16x16[2][4] =
  1144. {{
  1145. (idctmcomp)IDCTMComp16x16Back_0,
  1146. (idctmcomp)IDCTMComp16x16Back_90,
  1147. (idctmcomp)IDCTMComp16x16Back_180,
  1148. (idctmcomp)IDCTMComp16x16Back_270
  1149. },{
  1150. (idctmcomp)IDCTMComp16x16BackFwd_0,
  1151. (idctmcomp)IDCTMComp16x16BackFwd_90,
  1152. (idctmcomp)IDCTMComp16x16BackFwd_180,
  1153. (idctmcomp)IDCTMComp16x16BackFwd_270
  1154. }};
  1156. static idctmcomp const IDCTMComp8x8[2][4] =
  1157. {{
  1158. (idctmcomp)IDCTMComp8x8Back_0,
  1159. (idctmcomp)IDCTMComp8x8Back_90,
  1160. (idctmcomp)IDCTMComp8x8Back_180,
  1161. (idctmcomp)IDCTMComp8x8Back_270
  1162. },{
  1163. (idctmcomp)IDCTMComp8x8BackFwd_0,
  1164. (idctmcomp)IDCTMComp8x8BackFwd_90,
  1165. (idctmcomp)IDCTMComp8x8BackFwd_180,
  1166. (idctmcomp)IDCTMComp8x8BackFwd_270
  1167. }};
  1169. static idctinter const IDCTInter8x8[2][4] =
  1170. {{
  1171. (idctinter) IDCTInter8x8Back_0,
  1172. (idctinter) IDCTInter8x8Back_90,
  1173. (idctinter) IDCTInter8x8Back_180,
  1174. (idctinter) IDCTInter8x8Back_270
  1175. },{
  1176. (idctinter) IDCTInter8x8BackFwd_0,
  1177. (idctinter) IDCTInter8x8BackFwd_90,
  1178. (idctinter) IDCTInter8x8BackFwd_180,
  1179. (idctinter) IDCTInter8x8BackFwd_270
  1180. }};
  1182. static idctprocess const IDCTProcess[4] = 
  1183. { 
  1184. (idctprocess)IDCTProcess_0,
  1185. (idctprocess)IDCTProcess_90,
  1186. (idctprocess)IDCTProcess_180,
  1187. (idctprocess)IDCTProcess_270 
  1188. };
  1189. static idctcopy const IDCTCopy16x16[4] = 
  1190. { 
  1191. (idctcopy)IDCTCopy16x16_0,
  1192. (idctcopy)IDCTCopy16x16_90,
  1193. (idctcopy)IDCTCopy16x16_180,
  1194. (idctcopy)IDCTCopy16x16_270 
  1195. };
  1196. static idctintra const IDCTIntra8x8[4] = 
  1197. { 
  1198. (idctintra)IDCTIntra8x8_0,
  1199. (idctintra)IDCTIntra8x8_90,
  1200. (idctintra)IDCTIntra8x8_180,
  1201. (idctintra)IDCTIntra8x8_270 
  1202. };
  1204. //------------------------------------------------------------
  1206. static int IDCTOutputFormat(pvr* p, const void* Data, int Size )
  1207. {
  1208. packetformat Format;
  1209. int Result;
  1210. p->IDCTInit = 1;
  1212. if (Size == sizeof(video))
  1213. {
  1214. memset(&Format,0,sizeof(Format));
  1215. Format.Type = PACKET_VIDEO;
  1216. Format.Format.Video = *(const video*)Data;
  1217. Data = &Format;
  1218. Size = sizeof(packetformat);
  1220. //IDCTWidth or IDCTHeight could have changes so invalidate current input format
  1221. memset(&p->p.Input.Format.Video,0,sizeof(video));
  1222. }
  1224. Result = p->p.Node.Set((node*)p,OUT_INPUT|PIN_FORMAT,Data,Size);
  1226. if (Size && Result != ERR_NONE)
  1227. p->p.Node.Set((node*)p,OUT_INPUT|PIN_FORMAT,NULL,0);
  1229. p->IDCTInit = 0;
  1230. return Result;
  1231. }
  1233. static int IDCTSend(void* p,tick_t RefTime,const flowstate* State);
  1235. static int IDCTPVRRestore(pvr* p, idctbackup* Backup)
  1236. {
  1237. int No;
  1238. if (p && Backup->Format.Pixel.Flags)
  1239. {
  1240. planes Planes;
  1241. blitfx FX;
  1243. memset(&FX,0,sizeof(FX));
  1244. FX.ScaleX = SCALE_ONE;
  1245. FX.ScaleY = SCALE_ONE;
  1247. p->IDCTWidth = Backup->Width;
  1248. p->IDCTHeight = Backup->Height;
  1250. for (No=0;No<Backup->Count;++No)
  1251. {
  1252. idctbufferbackup* Buffer = Backup->Buffer+No;
  1253. if (Buffer->Buffer[0] && Buffer->Format.Pixel.FourCC==FOURCC_IMC4)
  1254. p->BufMem[No][0] = Buffer->Buffer[0];
  1255. else
  1256. {
  1257. video Format;
  1258. memset(&Format,0,sizeof(Format));
  1259. Format.Pixel.Flags = PF_FOURCC;
  1260. Format.Pixel.FourCC = FOURCC_IMC4;
  1261. Format.Aspect = ASPECT_ONE;
  1262. Format.Width = p->IDCTWidth;
  1263. Format.Height = p->IDCTHeight;
  1264. DefaultPitch(&Format);
  1265. SurfaceAlloc(p->BufMem[No],&Format);
  1266. }
  1267. }
  1269. p->IDCTMemInit = Backup->Count;
  1270. IDCTOutputFormat(p,&Backup->Format,sizeof(video));
  1271. p->IDCTMemInit = 0;
  1273. for (No=0;No<Backup->Count;++No)
  1274. {
  1275. idctbufferbackup* Buffer = Backup->Buffer+No;
  1277. p->BufFrameNo[No] = Buffer->FrameNo;
  1279. if (Buffer->Buffer[0] && Lock(p,No,Planes,1) == ERR_NONE)
  1280. {
  1281. FX.Direction = CombineDir(Buffer->Format.Direction, 0, p->Overlay.Direction);
  1282. FX.Brightness = -Buffer->Brightness;
  1283. SurfaceCopy(&Buffer->Format,&p->Overlay,Buffer->Buffer,Planes,&FX);
  1284. Unlock(p,No);
  1285. }
  1287. if (Buffer->Buffer[0] == p->BufMem[No][0])
  1288. memset(Buffer->Buffer,0,sizeof(planes));
  1289. }
  1291. p->FirstUpdate = 1;
  1293. p->ShowNext = Backup->Show;
  1294. if (p->ShowNext >= p->BufCount)
  1295. p->ShowNext = -1;
  1296. }
  1298. for (No=0;No<Backup->Count;++No)
  1299. SurfaceFree(Backup->Buffer[No].Buffer);
  1301. memset(Backup,0,sizeof(idctbackup));
  1302. return ERR_NONE;
  1303. }
  1305. static int IDCTPVRBackup(pvr* p, idctbackup* Backup)
  1306. {
  1307. int No;
  1308. planes Planes;
  1309. memset(Backup,0,sizeof(idctbackup));
  1311. if (!p->IDCT)
  1312. return ERR_INVALID_DATA;
  1314. Backup->Format = p->p.Input.Format.Video;
  1315. Backup->Width = p->IDCTWidth;
  1316. Backup->Height = p->IDCTHeight;
  1317. Backup->Count = p->BufCount;
  1318. Backup->Show = p->ShowNext;
  1320. p->Initing = 1; // do not ReInit here
  1322. for (No=0;No<Backup->Count;++No)
  1323. {
  1324. idctbufferbackup* Buffer = Backup->Buffer+No;
  1326. Buffer->FrameNo = p->BufFrameNo[No];
  1328. BufferFormat(p,&Buffer->Format);
  1329. Buffer->Buffer[0] = p->BufMem[No][0];
  1330. memset(p->BufMem[No],0,sizeof(planes));
  1332. if (Buffer->Buffer[0])
  1333. if (Lock(p,No,Planes,0)==ERR_NONE)
  1334. {
  1335. SurfaceCopy(&p->Overlay,&Buffer->Format,Planes,Buffer->Buffer,NULL);
  1336. Unlock(p,No);
  1337. }
  1338. else
  1339. ClearIMC4(Buffer->Buffer[0],&Buffer->Format);
  1340. }
  1342. p->Initing = 0;
  1344. IDCTOutputFormat(p,NULL,0);
  1345. return ERR_NONE;
  1347. }
  1349. static int IDCTSet(void* p, int No, const void* Data, int Size )
  1350. {
  1351. flowstate State;
  1352. int Result = ERR_INVALID_PARAM;
  1353. switch (No)
  1354. {
  1355. case IDCT_BACKUP: 
  1356. if (Size == sizeof(idctbackup))
  1357. Result = IDCTPVRRestore(PVR(p),(idctbackup*)Data);
  1358. break;
  1360. case IDCT_MODE: if (*(int*)Data==0) Result = ERR_NONE; break;
  1361. case IDCT_BUFFERWIDTH: SETVALUE(PVR(p)->IDCTWidth,int,ERR_NONE); break;
  1362. case IDCT_BUFFERHEIGHT: SETVALUE(PVR(p)->IDCTHeight,int,ERR_NONE); break;
  1363. case IDCT_FORMAT:
  1364. assert(Size == sizeof(video) || !Data);
  1365. Result = IDCTOutputFormat(PVR(p),Data,Size);
  1366. break;
  1368. case IDCT_ROUNDING: SETVALUE(PVR(p)->IDCTRounding,bool_t,ERR_NONE); break;
  1370. case IDCT_SHOW: 
  1371. SETVALUE(PVR(p)->ShowNext,int,ERR_NONE); 
  1372. if (PVR(p)->ShowNext >= PVR(p)->BufCount) PVR(p)->ShowNext = -1;
  1373. break;
  1375. case IDCT_BUFFERCOUNT:
  1376. assert(Size == sizeof(int));
  1377. Result = ERR_NONE;
  1378. if (PVR(p)->BufCount != *(const int*)Data)
  1379. Result = UpdateAlloc(PVR(p),*(const int*)Data,0,PVR(p)->AllCount);
  1380. break;
  1382. case FLOW_FLUSH:
  1383. PVR(p)->ShowNext = -1;
  1384. Result = ERR_NONE;
  1385. break;
  1387. case FLOW_RESEND:
  1388. State.CurrTime = TIME_RESEND;
  1389. State.DropLevel = 0;
  1390. Result = IDCTSend(p,-1,&State);
  1391. Sleep(20);
  1392. break;
  1393. }
  1394. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+PVR(p)->AllCount)
  1395. SETVALUE(PVR(p)->BufFrameNo[No-IDCT_FRAMENO],int,ERR_NONE);
  1396. return Result;
  1397. }
  1399. static int IDCTEnumPVR(void* p, int* No, datadef* Param)
  1400. {
  1401. int Result = IDCTEnum(p,No,Param);
  1402. if (Result == ERR_NONE && Param->No == IDCT_OUTPUT)
  1403. Param->Flags |= DF_RDONLY;
  1404. return Result;
  1405. }
  1407. static int IDCTGet(void* p, int No, void* Data, int Size )
  1408. {
  1409. int Result = ERR_INVALID_PARAM;
  1410. switch (No)
  1411. {
  1412. case FLOW_BUFFERED: GETVALUE(1,bool_t); break;
  1413. case NODE_PARTOF: GETVALUE(PVR(p),pvr*); break;
  1414. case IDCT_FORMAT: GETVALUECOND(PVR(p)->p.Input.Format.Video,video,PVR(p)->IDCT); break;
  1415. case IDCT_OUTPUT|PIN_FORMAT: GETVALUECOND(PVR(p)->p.Input,packetformat,PVR(p)->IDCT); break;
  1416. case IDCT_OUTPUT|PIN_PROCESS: GETVALUE(NULL,packetprocess); break;
  1417. case IDCT_OUTPUT: GETVALUE(PVR(p)->IDCTOutput,pin); break;
  1418. case IDCT_ROUNDING: GETVALUE(PVR(p)->IDCTRounding,bool_t); break;
  1419. case IDCT_MODE: GETVALUE(0,int); break;
  1420. case IDCT_BUFFERCOUNT: GETVALUE(PVR(p)->BufCount,int); break;
  1421. case IDCT_BUFFERWIDTH: GETVALUE(PVR(p)->IDCTWidth,int); break;
  1422. case IDCT_BUFFERHEIGHT: GETVALUE(PVR(p)->IDCTHeight,int); break;
  1423. case IDCT_SHOW: GETVALUE(PVR(p)->ShowNext,int); break;
  1424. case IDCT_BACKUP: 
  1425. assert(Size == sizeof(idctbackup));
  1426. Result = IDCTPVRBackup(PVR(p),(idctbackup*)Data);
  1427. break;
  1428. }
  1429. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+PVR(p)->AllCount)
  1430. GETVALUE(PVR(p)->BufFrameNo[No-IDCT_FRAMENO],int);
  1431. return Result;
  1432. }
  1434. static int IDCTNull(void* p,const flowstate* State,bool_t Empty)
  1435. {
  1436. if (Empty)
  1437. ++PVR(p)->p.Total;
  1438. if (!State || State->DropLevel)
  1439. ++PVR(p)->p.Dropped;
  1440. return ERR_NONE;
  1441. }
  1443. static int IDCTLock(void* p,int No,planes Planes,int* Brightness,video* Format)
  1444. {
  1445. if (Brightness)
  1446. *Brightness = 0;
  1447. if (Format)
  1448. *Format = PVR(p)->Overlay;
  1449. return Lock(PVR(p),No,Planes,1);
  1450. }
  1452. static void IDCTUnlock(void* p,int No)
  1453. {
  1454. Unlock(PVR(p),No);
  1455. }
  1457. static void SwapPtr(pvr* p,int a,int b,int SwapShow)
  1458. {
  1459. SMSurface t;
  1460. void* u;
  1462. t = p->Buf[a];
  1463. p->Buf[a] = p->Buf[b];
  1464. p->Buf[b] = t;
  1466. u = p->BufMem[a][0];
  1467. p->BufMem[a][0] = p->BufMem[b][0];
  1468. p->BufMem[b][0] = u;
  1470. if (SwapShow)
  1471. {
  1472. SwapInt(&p->BufFrameNo[a],&p->BufFrameNo[b]);
  1474. if (p->ShowNext == a)
  1475. p->ShowNext = b;
  1476. else
  1477. if (p->ShowNext == b)
  1478. p->ShowNext = a;
  1480. if (p->ShowLast == a)
  1481. p->ShowLast = b;
  1482. else
  1483. if (p->ShowLast == b)
  1484. p->ShowLast = a;
  1486. if (p->ShowCurr == a)
  1487. p->ShowCurr = b;
  1488. else
  1489. if (p->ShowCurr == b)
  1490. p->ShowCurr = a;
  1491. }
  1492. }
  1494. static int IDCTFrameStart(void* p,int FrameNo,int* OldFrameNo,int DstNo,int BackNo,int FwdNo,int ShowNo,bool_t Drop)
  1495. {
  1496. bool_t ReTry = 0;
  1497. GXVAError Result;
  1499. retry:
  1501. if (!PVR(p)->M24VA)
  1502. return ERR_DEVICE_ERROR;
  1504. // we will try to avoid overwrite currently displayed buffers:
  1505. //   ShowCurr currently displayed
  1506. //   ShowLast may be still on screen (because flip occurs only during vblank)
  1508. if (PVR(p)->ShowLast == DstNo || PVR(p)->ShowCurr == DstNo)
  1509. {
  1510. // try to find a free buffer
  1511. int SwapNo;
  1512. for (SwapNo=0;SwapNo<PVR(p)->AllCount;++SwapNo)
  1513. if (SwapNo != PVR(p)->ShowLast && SwapNo != PVR(p)->ShowCurr && 
  1514. SwapNo != BackNo && SwapNo != FwdNo && SwapNo != ShowNo)
  1515. break; 
  1517. if (SwapNo < PVR(p)->AllCount || UpdateAlloc(PVR(p),PVR(p)->BufCount,PVR(p)->TempCount+1,PVR(p)->AllCount)==ERR_NONE)
  1518. {
  1519. // use free buffer
  1520. SwapPtr(PVR(p),SwapNo,DstNo,1);
  1521. }
  1522. else
  1523. if (PVR(p)->ShowLast >= 0 && PVR(p)->ShowCurr != PVR(p)->ShowLast &&
  1524. PVR(p)->ShowLast != BackNo && PVR(p)->ShowLast != FwdNo) 
  1525. {
  1526. // no free buffer found and couldn't allocate new temp buffer
  1527. // so we wait for vblank and use ShowLast
  1528. if (DstNo != PVR(p)->ShowLast)
  1529. SwapPtr(PVR(p),PVR(p)->ShowLast,DstNo,1);
  1530. }
  1531. }
  1533. Result = PVR(p)->M24VA_BeginFrame(PVR(p)->Buf[DstNo],1);
  1534. if (Result == GXVAError_OK)
  1535. {
  1536. if (BackNo >= 0)
  1537. Result = PVR(p)->M24VA_SetReferenceFrameAddress(1,PVR(p)->Buf[BackNo]);
  1539. if (FwdNo >= 0 && Result == GXVAError_OK)
  1540. Result = PVR(p)->M24VA_SetReferenceFrameAddress(2,PVR(p)->Buf[FwdNo]);
  1542. if (Result != GXVAError_OK)
  1543. PVR(p)->M24VA_EndFrame(1);
  1544. }
  1546. if (Result == GXVAError_HardwareNotAvailable && !ReTry)
  1547. {
  1548. ReInit(PVR(p));
  1549. ReTry = 1;
  1550. goto retry;
  1551. }
  1552. else
  1553. if (Result == GXVAError_OK)
  1554. {
  1555. if (PVR(p)->YUV422)
  1556. {
  1557. PVR(p)->IdctVMT.Process = IDCTProcess_422;
  1558. PVR(p)->IdctVMT.Intra8x8 = (idctintra)IDCTIntra8x8_422;
  1559. PVR(p)->IdctVMT.Copy16x16 = NULL;
  1560. PVR(p)->IdctVMT.MComp16x16 = NULL;
  1561. PVR(p)->IdctVMT.MComp8x8 = NULL;
  1562. PVR(p)->IdctVMT.Inter8x8 = NULL;
  1563. }
  1564. else
  1565. {
  1566. int Degree;
  1567. if (PVR(p)->SoftFX.Direction & DIR_SWAPXY)
  1568. Degree = (PVR(p)->SoftFX.Direction & DIR_MIRRORUPDOWN) ? 1:3;
  1569. else
  1570. Degree = (PVR(p)->SoftFX.Direction & DIR_MIRRORUPDOWN) ? 2:0;
  1572. PVR(p)->IdctVMT.Process = IDCTProcess[Degree];
  1573. PVR(p)->IdctVMT.Copy16x16 = IDCTCopy16x16[Degree];
  1574. PVR(p)->IdctVMT.MComp16x16 = (idctmcomp)IDCTMComp16x16[FwdNo>=0][Degree];
  1575. PVR(p)->IdctVMT.MComp8x8 = (idctmcomp)IDCTMComp8x8[FwdNo>=0][Degree];
  1576. PVR(p)->IdctVMT.Intra8x8 = IDCTIntra8x8[Degree];
  1577. PVR(p)->IdctVMT.Inter8x8 = IDCTInter8x8[FwdNo>=0][Degree];
  1578. }
  1579. }
  1580. else
  1581. return ERR_DEVICE_ERROR;
  1583. PVR(p)->ShowNext = ShowNo;
  1585. if (OldFrameNo)
  1586. *OldFrameNo = PVR(p)->BufFrameNo[DstNo];
  1587. PVR(p)->BufFrameNo[DstNo] = FrameNo;
  1589. PVR(p)->MCompType = GXVA_CMD_MC_OPP_TYPE;
  1590. if (PVR(p)->IDCTRounding)
  1591. PVR(p)->MCompType |= GXVA_MC_TYPE_INTR_RND_MODE;
  1593. PVR(p)->GXVA_SetIZZMode(GXVA_RasterScanOrder);
  1595. return ERR_NONE;
  1596. }
  1598. static void IDCTFrameEnd(void* p)
  1599. {
  1600. PVR(p)->M24VA_EndFrame(1);
  1601. }
  1603. static void IDCTDrop(void* p)
  1604. {
  1605. int No;
  1606. for (No=0;No<PVR(p)->AllCount;++No)
  1607. PVR(p)->BufFrameNo[No] = -1;
  1608. }
  1610. static bool_t IDCTTiming(pvr* p, tick_t CurrTime, tick_t RefTime)
  1611. {
  1612. if (CurrTime >= 0)
  1613. {
  1614. tick_t Diff;
  1616. if (!p->p.Play && CurrTime == p->p.LastTime)
  1617. return 0;
  1619. Diff = RefTime - (CurrTime + SHOWAHEAD);
  1620. if (Diff >= 0)
  1621. {
  1622. #ifdef VSYNC_WORKAROUND
  1623. bool_t Tried;
  1624. int Last;
  1625. int Same;
  1626. int Start;
  1628. if (p->DisableVSync || !p->VSyncPtr || Diff>(TICKSPERSEC*20/1000))
  1629. return 0;
  1631. Start = *p->VSyncPtr & 4095;
  1633. if (Scale(p->VSyncRefresh,p->VSyncBottom - Start,p->VSyncTotal) > (TICKSPERSEC*8/1000))
  1634. return 0;
  1636. // wait for vsync
  1638. Tried = 0;
  1639. Last = -1;
  1640. Same = 0;
  1642. for (;;)
  1643. {
  1644. int Pos = *p->VSyncPtr & 4095;
  1646. // fail safe for stuck scanline counter
  1647. if (Pos == Last)
  1648. {
  1649. if (++Same == 10000000)
  1650. break;
  1651. }
  1652. else
  1653. {
  1654. Last = Pos;
  1655. Same = 0;
  1656. }
  1658. // we got interrupted and missed the vsync. 
  1659. if (Pos < Start) 
  1660. {
  1661. if (Tried) 
  1662. break;
  1664. Start = Pos;
  1665. Tried = 1; // try again, but only one more time
  1666. }
  1668. Pos = p->VSyncBottom - Pos;
  1669. if (Pos <= 0) 
  1670. break;
  1672. if (Pos >= 2*p->VSyncLimit) 
  1673. Sleep(Pos/p->VSyncLimit-1); // sleep few msec
  1674. }
  1675. #else
  1676. return 0;
  1677. #endif
  1678. }
  1680. p->p.LastTime = CurrTime;
  1681. }
  1682. else
  1683. p->p.LastTime = RefTime;
  1685. p->p.CurrTime = CurrTime;
  1686. return 1;
  1687. }
  1689. static int IDCTSend(void* p,tick_t RefTime,const flowstate* State)
  1690. {
  1691. // no dropping check, because flipping costs no time
  1693. if (PVR(p)->ShowNext < 0)
  1694. return ERR_NEED_MORE_DATA;
  1696. if (!IDCTTiming(PVR(p),State->CurrTime,RefTime))
  1697. return ERR_BUFFER_FULL;
  1699. if (State->CurrTime != TIME_RESEND)
  1700. ++PVR(p)->p.Total;
  1702. if (State->CurrTime<0 && RefTime>=0)
  1703. {
  1704. // it would just stall unneccessary the benchmark and
  1705. // can crash the 2700G driver with too frequent flipping
  1707. int t = GetTimeTick();
  1708. if (t-PVR(p)->FlipLastTime<16)  
  1709. return ERR_NONE;
  1710. PVR(p)->FlipLastTime = t;
  1711. }
  1713. PVR(p)->ShowLast = PVR(p)->ShowCurr;
  1714. PVR(p)->ShowCurr = PVR(p)->ShowNext;
  1716. if (PVR(p)->Attribs.bOverlayOn)
  1717. PVR(p)->VDISP_OverlayFlipSurface(PVR(p)->Buf[PVR(p)->ShowCurr],VDISP_NONE);
  1718. return ERR_NONE;
  1719. }
  1721. //------------------------------------------------------------
  1723. static int Create(pvr* p)
  1724. {
  1725. p->p.Module = LoadLibrary(T("PVRVADD.DLL"));
  1727. GetProc(&p->p.Module,&p->M24VA_FrameDimensions,T("M24VA_FrameDimensions"),0);
  1728. GetProc(&p->p.Module,&p->M24VA_FrameAllocate,T("M24VA_FrameAllocate"),0);
  1729. GetProc(&p->p.Module,&p->M24VA_FrameFree,T("M24VA_FrameFree"),0);
  1730. GetProc(&p->p.Module,&p->M24VA_BeginFrame,T("M24VA_BeginFrame"),0);
  1731. GetProc(&p->p.Module,&p->M24VA_EndFrame,T("M24VA_EndFrame"),0);
  1732. GetProc(&p->p.Module,&p->M24VA_SetReferenceFrameAddress,T("M24VA_SetReferenceFrameAddress"),0);
  1733. GetProc(&p->p.Module,&p->M24VA_FCFrameAllocate,T("M24VA_FCFrameAllocate"),0);
  1734. GetProc(&p->p.Module,&p->M24VA_FrameConvert,T("M24VA_FrameConvert"),0);
  1735. GetProc(&p->p.Module,&p->M24VA_FrameBeginAccess,T("M24VA_FrameBeginAccess"),0);
  1736. GetProc(&p->p.Module,&p->M24VA_FrameEndAccess,T("M24VA_FrameEndAccess"),0);
  1737. GetProc(&p->p.Module,&p->M24VA_WriteIZZBlock,T("M24VA_WriteIZZBlock"),0);
  1738. GetProc(&p->p.Module,&p->M24VA_WriteIZZData,T("M24VA_WriteIZZData"),0);
  1739. GetProc(&p->p.Module,&p->M24VA_SetIZZMode,T("M24VA_SetIZZMode"),0);
  1740. GetProc(&p->p.Module,&p->M24VA_WriteResidualDifferenceData,T("M24VA_WriteResidualDifferenceData"),0);
  1741. GetProc(&p->p.Module,&p->M24VA_WriteMCCmdData,T("M24VA_WriteMCCmdData"),0);
  1742. GetProc(&p->p.Module,&p->M24VA_Initialise,T("M24VA_Initialise"),0);
  1743. GetProc(&p->p.Module,&p->M24VA_Deinitialise,T("M24VA_Deinitialise"),0);
  1744. GetProc(&p->p.Module,&p->M24VA_Reset,T("M24VA_Reset"),0);
  1745. GetProc(&p->p.Module,&p->VDISP_Initialise,T("VDISP_Initialise"),0);
  1746. GetProc(&p->p.Module,&p->VDISP_Deinitialise,T("VDISP_Deinitialise"),0);
  1747. GetProc(&p->p.Module,&p->VDISP_OverlaySetAttributes,T("VDISP_OverlaySetAttributes"),0);
  1748. GetProc(&p->p.Module,&p->VDISP_OverlayFlipSurface,T("VDISP_OverlayFlipSurface"),0);
  1749. GetProc(&p->p.Module,&p->VDISP_OverlayContrast,T("VDISP_OverlayContrast"),0);
  1750. GetProc(&p->p.Module,&p->VDISP_OverlayGamma,T("VDISP_OverlayGamma"),0);
  1751. GetProc(&p->p.Module,&p->VDISP_OverlayBrightness,T("VDISP_OverlayBrightness"),0);
  1752. GetProc(&p->p.Module,&p->VDISP_OverlaySetColorspaceConversion,T("VDISP_OverlaySetColorspaceConversion"),0);
  1754. if (!p->p.Module)
  1755. return ERR_NOT_SUPPORTED;
  1757. #ifdef VSYNC_WORKAROUND
  1758. {
  1759. tchar_t Path[MAXPATH];
  1760. GetModuleFileName(p->p.Module,Path,MAXPATH);
  1761. if (FileDate(Path) < 20041205) // just guessing when vsync was corrected
  1762. p->SetupVSync = 1;
  1763. }
  1764. #endif
  1766. p->p.Node.Enum = (nodeenum)Enum;
  1767. p->p.Node.Get = (nodeget)Get;
  1768. p->p.Node.Set = (nodeset)Set;
  1769. p->p.Init = (ovlfunc)Init;
  1770. p->p.Done = (ovldone)Done;
  1771. p->p.Blit = (ovlblit)Blit;
  1772. p->p.Update = (ovlfunc)Update;
  1773. p->p.UpdateShow = (ovlfunc)UpdateShow;
  1774. p->p.Reset = (ovlfunc)Reset;
  1776. p->IdctVMT.Class = INTEL2700G_IDCT_ID;
  1777. p->IdctVMT.Enum = IDCTEnumPVR;
  1778. p->IdctVMT.Get = IDCTGet;
  1779. p->IdctVMT.Set = IDCTSet;
  1780. p->IdctVMT.Send = IDCTSend;
  1781. p->IdctVMT.Null = IDCTNull;
  1782. p->IdctVMT.Drop = IDCTDrop;
  1783. p->IdctVMT.Lock = IDCTLock;
  1784. p->IdctVMT.Unlock = IDCTUnlock;
  1785. p->IdctVMT.FrameStart = IDCTFrameStart;
  1786. p->IdctVMT.FrameEnd = IDCTFrameEnd;
  1788. p->p.AccelIDCT = &p->IdctVMT;
  1789. p->p.Overlay = 1;
  1790. p->p.DoPowerOff = 1;
  1791. p->FirstUpdateTime = GetTimeTick() - 10000;
  1793. p->SetupIDCTRotate = 1;
  1794. p->CloseWMP = 1;
  1795. return ERR_NONE;
  1796. }
  1798. static const nodedef PVR =
  1799. {
  1800. sizeof(pvr)|CF_GLOBAL|CF_SETTINGS,
  1801. INTEL2700G_ID,
  1802. OVERLAY_CLASS,
  1803. PRI_DEFAULT+210,
  1804. (nodecreate)Create,
  1805. };
  1807. static const nodedef PVRIDCT =
  1808. {
  1809. CF_ABSTRACT,
  1810. INTEL2700G_IDCT_ID,
  1811. IDCT_CLASS,
  1812. PRI_DEFAULT+50,
  1813. };
  1815. void Intel2700G_Init()
  1816. {
  1817. NodeRegisterClass(&PVR);
  1818. NodeRegisterClass(&PVRIDCT);
  1819. }
  1821. void Intel2700G_Done()
  1822. {
  1823. NodeUnRegisterClass(INTEL2700G_ID);
  1824. NodeUnRegisterClass(INTEL2700G_IDCT_ID);
  1825. }
  1827. #else
  1828. void Intel2700G_Init() {}
  1829. void Intel2700G_Done() {}
  1830. #endif