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

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

Windows CE

开发平台：

C/C++

ati3200.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: ati3200.c 624 2006-02-01 17:48:42Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "stdafx.h"
  26. #if defined(ARM)
  28. #define CLIENTVERSION "1.29.031201.07700" 
  29. #define MAXSCALE 2
  30. #define SCALE MAXIDCTBUF
  32. #define DCFACTOR 8
  34. static const char DevOpenName[0x50] = "TCPMP";
  36. enum
  37. {
  38. PLANE_Y = 0x10000000,
  39. PLANE_U = 0x20000000,
  40. PLANE_V = 0x40000000,
  41. SUCCESS = 0,
  42. FAIL = 1,
  43. ENDENUM = 5,
  45. FORMAT_PAL4 = 1,
  46. FORMAT_PAL8 = 2,
  47. FORMAT_RGB444 = 3,
  48. FORMAT_RGB555 = 4,
  49. FORMAT_RGB565 = 5,
  50. FORMAT_YUYV = 6,
  51. FORMAT_YVYU = 7,
  52. FORMAT_YUV422 = 8,
  53. FORMAT_YUV420 = 9,
  54. FORMAT_UYVY = 10,
  55. FORMAT_VYUY = 11,
  56. FORMAT_PAL2 = 12,
  58. MIRROR_UPDOWN = 1,
  59. MIRROR_LEFTRIGHT= 2,
  61. MEM_EXTERNAL = 0x20,
  62. MEM_INTERNAL = 0x40,
  64. MEM_ANY_INT = -1, // prefer internal
  65. MEM_ANY_EXT = -2, // prefer external
  66. MEM_ANY_CHG = -3, // even:external odd:internal
  67. MEM_PRIMARY = -4, // reused primary surface
  69. PROP_SCANTYPE = 0,
  70. PROP_PADDING = 1,
  71. PROP_BIAS = 2,
  72. PROP_ROUNDING = 3,
  73. PROP_FRAMENO = 4,
  74. PROP_CODING = 5,
  75. PROP_DEBUG = 6,
  76. };
  78. //---------------------------------------------------------------
  79. // ati format
  80. //
  81. // input is idct_ati_t[length] array
  82. // 8x8 idct matrix reconstruction:
  83. //
  84. // clear block
  85. // for (pos=0;length>0;--length,++data)
  86. //   repeat X=0..3
  87. //     if (data->skipX==-1) break;
  88. //     pos += data->skipX
  89. //     block[scan[pos++]] = data->dataX
  91. typedef struct idct_ati
  92. {
  93. char skip3,skip2,skip1,skip0;
  94. short data1,data0,data3,data2;
  95. } idct_ati;
  97. typedef struct devinfo
  98. {
  99. char Name[0x50];
  100. char Version[0x50];
  101. int Revision;
  102. int ChipId;
  103. int RevisionId;
  104. int TotalMemory;
  105. int BusInterfaceMode;
  106. int InternalMemSize;
  107. int ExternalMemSize;
  108. int Caps1;
  109. int Caps2;
  110. int Caps3;
  111. int Caps4;
  112. char Pad[128];
  113. } devinfo;
  115. typedef struct modeinfo
  116. {
  117. int Width;
  118. int Height;
  119. int PixelFormat;
  120. int Freq;
  121. int Rotation;
  122. int Mirror;
  123. } modeinfo;
  125. typedef struct surfinfo
  126. {
  127. int Width;
  128. int Height;
  129. void* Addr;
  130. int Pitch;
  131. int Size;
  132. int Class;
  133. int One;
  134. } surfinfo;
  136. typedef struct planeinfo
  137. {
  138. int Width;
  139. int Height;
  140. void* Addr;
  141. int Pitch;
  142. int One;
  143. } planeinfo;
  145. typedef struct ahirect
  146. {
  147. int Left;
  148. int Top;
  149. int Right;
  150. int Bottom;
  151. } ahirect;
  153. typedef struct ahipoint
  154. {
  155. int x;
  156. int y;
  157. } ahipoint;
  159. typedef void* ahidevice;
  160. typedef void* ahicontext;
  161. typedef void* ahisurface;
  162. typedef void* ahiidct;
  164. typedef struct ahioverlay
  165. {
  166. ahirect DstRect; //0x00
  167. ahirect SrcRect; //0x10
  168. int ColorKey;    //0x20
  169. int ColorMask;   //0x24
  170. int Rotate;      //0x28
  171. int Mirror;      //0x2C
  172. int Zero;        //0x30
  173. } ahioverlay;
  175. typedef struct ahi
  176. {
  177. overlay p;
  178. idct IdctVMT;
  180. bool_t Shrink;
  181. bool_t Stretch;
  182. bool_t StretchOnlyInternal;
  183. bool_t BlitMode;
  184. bool_t BlitDownScale;
  185. rect OverlayRect;
  186. video Overlay;
  187. blitfx SoftFX;
  189. int OvlFormat;
  190. int OvlUVX2;
  191. int OvlUVY2;
  192. int OvlPlaneY;
  193. int OvlPlaneU;
  194. int OvlPlaneV;
  196. // should be in the first part for lower offset
  197. int (*AhiIDCTMComp8x8)(ahiidct* IDCT, const idct_ati* Data, int Len, int* Back, int* Fwd, int No, int ZigZagType);
  198. int (*AhiIDCTMComp)(ahiidct* IDCT, int* Back, int* Fwd, int No);
  199. int (*AhiIDCT8x8)(ahiidct* IDCT, const idct_ati* Data, int Len, int No, int ZigZagType);
  201. ahiidct* IDCT;
  202. int DCAdd;
  203. //int DCAdj;
  204. int MacroWidth;
  205. int MacroNo;
  206. int MacroSubNo;
  208. int* MVBack;
  209. int* MVFwd;
  210. int MVBackTab[6];
  211. int MVFwdTab[6];
  212. idct_ati Data[16+2]; //+2 as safe because convert can write -1 after last item
  214. int SaveCount;
  215. int SaveScanType;
  216. idct_ati SaveData[16];
  218. int IDCTWidth;
  219. int IDCTHeight;
  220. int OverlayRPitch;
  221. int ScaleWidth;
  222. int ScaleHeight;
  223. int ScaleCurr;
  224. devinfo DevInfo;
  225. modeinfo ModeInfo;
  226. ahidevice* Device;
  227. ahicontext* Context;
  228. int MaxCount;
  229. int AllCount; //BufCount + TempCount
  230. int BufCount;
  231. int TempCount;
  232. int ShowNext;
  233. int ShowCurr;
  234. int ShowLast;
  235. bool_t ShowNextIdle;
  236. ahisurface* Primary; // only for blit mode
  237. ahisurface* Buf[MAXIDCTBUF+MAXSCALE];  
  238. ahisurface* BufR[MAXIDCTBUF+MAXSCALE]; 
  239. int BufMode[MAXIDCTBUF+MAXSCALE]; 
  240. int BufFrameNo[MAXIDCTBUF+MAXSCALE];
  241. ahioverlay Param;
  242. tchar_t Version[128];
  244. //idct
  245. pin IDCTOutput;
  246. int FrameNo;
  247. int Zero;
  248. bool_t IDCTRounding;
  250. idct_block_t Block[8*8];
  252. int (*AhiInit)(int Version);
  253. int (*AhiTerm)();
  255. int (*AhiDevEnum)(ahidevice** Device, devinfo* Info, int No);
  256. int (*AhiDevOpen)(ahicontext** ContextOut, ahidevice* Device, const char* Name, int v);
  257. int (*AhiDevClose)(ahicontext* Context);
  258. int (*AhiDevClientVersion)(ahicontext* Context, const char* s);
  260. int (*AhiDispModeGet)(ahicontext* Context, modeinfo* Info);
  261. int (*AhiDispModeEnum)(ahicontext* Context, modeinfo* Info, int No);
  262. int (*AhiDispModeClip)(ahicontext* Context, const ahirect*); //not sure
  263. int (*AhiDispSurfGet)(ahicontext* Context, ahisurface** SurfaceOut);
  265. int (*AhiSurfGetLargestFreeBlockSize)(ahicontext* Context, int Format, int* a, int* b, int Mem);
  266. int (*AhiSurfAlloc)(ahicontext* Context, ahisurface** SurfaceOut, int* Size, int Format, int Mem);
  267. int (*AhiSurfReuse)(ahicontext* Context, ahisurface** SurfaceOut, ahisurface* SurfaceReuse, int* Size, int Format, int Zero);
  268. int (*AhiSurfFree)(ahicontext* Context, ahisurface* s);
  269. int (*AhiSurfLock)(ahicontext* Context, ahisurface* s, void** Ptr, int Plane);
  270. int (*AhiSurfUnlock)(ahicontext* Context, ahisurface* s, int Plane);
  271. int (*AhiSurfInfo)(ahicontext* Context, ahisurface* s, surfinfo* Info);
  272. int (*AhiSurfPlaneInfo)(ahicontext* Context, ahisurface* s, planeinfo* Info, int Plane);
  274. int (*AhiDrawRopSet)(ahicontext* Context, int ROP);
  275. int (*AhiDrawSurfSrcSet)(ahicontext* Context, ahisurface* Src, int Plane);
  276. int (*AhiDrawSurfDstSet)(ahicontext* Context, ahisurface* Dst, int Plane);
  277. int (*AhiDrawIdle)(ahicontext* Context, int v);
  278. int (*AhiDispWaitVBlank)(ahicontext* Context, int v);
  279. int (*AhiDrawBitBlt)(ahicontext* Context, const ahirect* DstRect, const ahipoint* SrcPos);
  280. int (*AhiDrawStretchBlt)(ahicontext* Context, const ahirect* DstRect, const ahirect* SrcRect, int Mode);
  281. int (*AhiDrawRotateBlt)(ahicontext* Context, const ahirect* DstRect, const ahipoint* SrcPos, int Rotate, int Mirror, int Zero);
  283. int (*AhiDispOverlayCaps)(ahicontext* Context, int Mode, int* Caps);
  284. int (*AhiDispOverlayState)(ahicontext* Context, int State, int Zero);
  285. int (*AhiDispOverlayPos)(ahicontext* Context, const ahirect* Rect, int Zero);
  286. int (*AhiDispOverlaySurf)(ahicontext* Context, ahisurface* Surface, ahioverlay* Info, int Mode);
  288. int (*AhiIDCTOpen)(ahicontext* Context, ahiidct** IDCTOut, int Zero);
  289. int (*AhiIDCTClose)(ahiidct* IDCT);
  290. int (*AhiIDCTPropGet)(ahiidct* IDCT, int No, int* Data, int Size);
  291. int (*AhiIDCTPropSet)(ahiidct* IDCT, int No, const int* Data, int Size);
  292. int (*AhiIDCTFrameStart)(ahiidct* IDCT, ahisurface* Dst, ahisurface* Back, ahisurface* Fwd, int Frame, int Zero);
  293. int (*AhiIDCTFrameEnd)(ahiidct* IDCT, int Frame);
  295. int (*AhiUnmap)();
  297. bool_t TmpInited;
  298. bool_t NoRelease;
  299. bool_t AllowStretchFlip;
  300. bool_t AllowPrimaryReUse;
  301. bool_t AllowLowBitdepth;
  302. bool_t FullScreenOverlay;   // overlay covers fullscreen
  303. bool_t PrimaryReUse;
  304. bool_t LowBitdepth;
  305. bool_t Internal;   // IDCT is using internal memory (it's faster, but less memory)
  306. bool_t Landscape;   // avoid external memory overlays in landscape mode
  307. bool_t IDCTBug;
  308. bool_t IDCTInit;
  309. bool_t ErrorMemory;
  311. } ahi;
  313. const datatable AHIParams[] = 
  314. {
  315. { AHI_DEVICEBITMAP, TYPE_BOOL, DF_SETUP|DF_SOFTRESET|DF_NOSAVE|DF_CHECKLIST },
  316. { AHI_IDCTBUG, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  317. { AHI_PRIMARYREUSE, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  318. { AHI_LOWBITDEPTH, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  319. { AHI_STRETCHFLIP, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  320. { AHI_NORELEASE, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  321. { AHI_NAME, TYPE_STRING, DF_SETUP | DF_RDONLY|DF_GAP },
  322. { AHI_VERSION, TYPE_STRING, DF_SETUP | DF_RDONLY },
  323. { AHI_REVISION, TYPE_INT, DF_SETUP | DF_RDONLY },
  324. { AHI_CHIPID, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX },
  325. { AHI_REVISIONID, TYPE_INT, DF_SETUP | DF_RDONLY },
  326. { AHI_TOTALMEMORY, TYPE_INT, DF_SETUP | DF_RDONLY },
  327. { AHI_INTERNALTOTALMEM, TYPE_INT, DF_SETUP | DF_RDONLY },
  328. { AHI_INTERNALFREEMEM, TYPE_INT, DF_SETUP | DF_RDONLY },
  329. { AHI_EXTERNALTOTALMEM, TYPE_INT, DF_SETUP | DF_RDONLY },
  330. { AHI_EXTERNALFREEMEM, TYPE_INT, DF_SETUP | DF_RDONLY },
  331. { AHI_CAPS1, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX },
  332. { AHI_CAPS2, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX },
  333. { AHI_CAPS3, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX },
  334. { AHI_CAPS4, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX },
  335. { AHI_UNMAP, TYPE_INT, DF_SETUP | DF_RDONLY|DF_HEX },
  337. DATATABLE_END(AHI_ID)
  338. };
  340. const tchar_t* ATIBase = T("System\GDI\Drivers\ATI");
  341. const tchar_t* DisableDevice = T("DisableDeviceBitmap");
  343. static bool_t Ahi2PixelFormat(int Format, pixel* p)
  344. {
  345. switch (Format)
  346. {
  347. case FORMAT_PAL2:
  348. p->Flags = PF_PALETTE;
  349. p->BitCount = 2;
  350. break;
  351. case FORMAT_PAL4:
  352. p->Flags = PF_PALETTE;
  353. p->BitCount = 2;
  354. break;
  355. case FORMAT_PAL8:
  356. p->Flags = PF_PALETTE;
  357. p->BitCount = 2;
  358. break;
  359. case FORMAT_RGB444:
  360. DefaultRGB(p,16,4,4,4,0,0,0);
  361. break;
  362. case FORMAT_RGB555:
  363. DefaultRGB(p,16,5,5,5,0,0,0);
  364. break;
  365. case FORMAT_RGB565:
  366. DefaultRGB(p,16,5,6,5,0,0,0);
  367. break;
  368. case FORMAT_YUYV:
  369. p->Flags = PF_FOURCC;
  370. p->FourCC = FOURCC_YUYV;
  371. break;
  372. case FORMAT_YVYU:
  373. p->Flags = PF_FOURCC;
  374. p->FourCC = FOURCC_YVYU;
  375. break;
  376. case FORMAT_YUV420:
  377. p->Flags = PF_FOURCC;
  378. p->FourCC = FOURCC_I420;
  379. break;
  380. case FORMAT_UYVY:
  381. p->Flags = PF_FOURCC;
  382. p->FourCC = FOURCC_UYVY;
  383. break;
  384. case FORMAT_VYUY:
  385. p->Flags = PF_FOURCC;
  386. p->FourCC = FOURCC_VYUY;
  387. break;
  388. case FORMAT_YUV422:
  389. p->Flags = PF_FOURCC;
  390. p->FourCC = FOURCC_YV16;
  391. break;
  392. default:
  393. return 0;
  394. }
  395. return 1;
  396. }
  398. static void ClearPrimary(ahi* p)
  399. {
  400. ahisurface* Primary = NULL;
  401. p->AhiDispSurfGet(p->Context,&Primary);
  402. if (Primary)
  403. {
  404. void* Ptr;
  405. surfinfo Info;
  406. pixel Pixel;
  408. p->AhiSurfInfo(p->Context,Primary,&Info);
  409. if (p->AhiSurfLock(p->Context,Primary,&Ptr,0)==SUCCESS)
  410. {
  411. Ahi2PixelFormat(Info.Class,&Pixel);
  412. FillColor(Ptr,Info.Pitch,0,0,Info.Width,Info.Height,Pixel.BitCount,0);
  413. p->AhiSurfUnlock(p->Context,Primary,0);
  414. }
  415. }
  416. }
  418. static void SetLowBitdepth(ahi* p,bool_t Value)
  419. {
  420. if (p->LowBitdepth != Value && p->AllowLowBitdepth && p->DevInfo.ChipId == 0x57441002)
  421. {
  422. volatile int* Regs = ((int**)p->Context)[7];
  423. int Ctrl;
  425. p->LowBitdepth = Value;
  427. if (Value && !p->PrimaryReUse)
  428. ClearPrimary(p);
  430. while ((Regs[0x153] & 0x400)==0); // wait until not in vblank 
  431. while ((Regs[0x153] & 0x400)!=0); // wait until in vblank
  432. Ctrl = Regs[0x105];
  433. Ctrl &= ~7;
  434. Ctrl |= Value ? 2:6;
  435. Regs[0x105] = Ctrl;
  436. }
  437. }
  439. static bool_t Hide(ahi* p)
  440. {
  441. if (p->p.Show && p->AllCount)
  442. {
  443. SetLowBitdepth(p,0);
  444. p->AhiDispOverlayState(p->Context,0,0);
  445. p->AhiDispWaitVBlank(p->Context,0);
  446. }
  447. return 1;
  448. }
  450. static void FreeScale(ahi* p,bool_t* Hidden)
  451. {
  452. int No;
  453. for (No=SCALE;No<SCALE+2;++No)
  454. if (p->Buf[No])
  455. {
  456. if (Hidden && !*Hidden)
  457. *Hidden = Hide(p);
  459. p->AhiSurfFree(p->Context,p->Buf[No]);
  460. p->Buf[No] = NULL;
  461. if (p->BufMode[No] == MEM_PRIMARY)
  462. {
  463. p->PrimaryReUse = 0;
  464. WaitDisable(0);
  465. }
  466. p->BufMode[No] = 0;
  467. }
  469. p->ScaleWidth = 0;
  470. p->ScaleHeight = 0;
  471. p->ScaleCurr = 0;
  472. }
  474. static void FreeBuffer(ahi* p,int No,bool_t* Hidden)
  475. {
  476. if (Hidden && !*Hidden && p->ShowCurr == No)
  477. *Hidden = Hide(p);
  479. if (p->Buf[No])
  480. p->AhiSurfFree(p->Context,p->Buf[No]);
  481. p->Buf[No] = NULL;
  483. if (p->BufR[No])
  484. p->AhiSurfFree(p->Context,p->BufR[No]);
  485. p->BufR[No] = NULL;
  487. if (p->BufMode[No] == MEM_PRIMARY)
  488. {
  489. p->PrimaryReUse = 0;
  490. WaitDisable(0);
  491. }
  492. p->BufMode[No] = 0;
  493. }
  495. static int Lock(ahi* p,int No,planes Planes,bool_t Force)
  496. {
  497. if (!Force && (No<0 || No>=p->BufCount))
  498. {
  499. Planes[0] = NULL;
  500. Planes[1] = NULL;
  501. Planes[2] = NULL;
  502. return ERR_INVALID_PARAM;
  503. }
  505. p->AhiDrawIdle(p->Context,0);
  507. if (p->AhiSurfLock(p->Context,p->Buf[No],&Planes[0],p->OvlPlaneY)==SUCCESS)
  508. {
  509. if (!p->OvlPlaneU || p->AhiSurfLock(p->Context,p->Buf[No],&Planes[1],p->OvlPlaneU)==SUCCESS)
  510. {
  511. if (!p->OvlPlaneV || p->AhiSurfLock(p->Context,p->Buf[No],&Planes[2],p->OvlPlaneV)==SUCCESS)
  512. return ERR_NONE;
  513. if (p->OvlPlaneU) p->AhiSurfUnlock(p->Context,p->Buf[No],p->OvlPlaneU);
  514. }
  515. p->AhiSurfUnlock(p->Context,p->Buf[No],p->OvlPlaneY);
  516. }
  517. return ERR_DEVICE_ERROR;
  518. }
  520. static void Unlock(ahi* p,int No)
  521. {
  522. p->AhiSurfUnlock(p->Context,p->Buf[No],p->OvlPlaneY);
  523. if (p->OvlPlaneU) p->AhiSurfUnlock(p->Context,p->Buf[No],p->OvlPlaneU);
  524. if (p->OvlPlaneV) p->AhiSurfUnlock(p->Context,p->Buf[No],p->OvlPlaneV);
  525. }
  527. static bool_t CheckVersion(ahi* p,bool_t IDCT)
  528. {
  529. int c = IDCT?27:24;
  530. int a,b;
  532. StrToTcs(p->Version,TSIZEOF(p->Version),p->DevInfo.Version);
  533. if (sscanf(p->DevInfo.Version,"%d.%d",&a,&b)!=2)
  534. a = 2; // force true 
  535. return a>1 || (a==1 && b>=c);
  536. }
  538. static void GetMode(ahi* p)
  539. {
  540. // get current mode parameters
  541. p->AhiDispModeGet(p->Context,&p->ModeInfo);
  543. memset(&p->p.Output.Format.Video,0,sizeof(video));
  544. p->p.Output.Format.Video.Width = p->ModeInfo.Width;
  545. p->p.Output.Format.Video.Height = p->ModeInfo.Height;
  546. p->p.Output.Format.Video.Direction = 0;
  547. p->p.Output.Format.Video.Aspect = ASPECT_ONE;
  549. if (p->ModeInfo.Rotation!=0 && p->ModeInfo.Rotation!=2)
  550. p->p.Output.Format.Video.Direction ^= DIR_SWAPXY;
  552. switch (p->ModeInfo.Rotation)
  553. {
  554. case 1:
  555. p->p.Output.Format.Video.Direction ^= DIR_MIRRORLEFTRIGHT;
  556. break;
  557. case 2:
  558. p->p.Output.Format.Video.Direction ^= DIR_MIRRORLEFTRIGHT|DIR_MIRRORUPDOWN;
  559. break;
  560. case 3:
  561. p->p.Output.Format.Video.Direction ^= DIR_MIRRORUPDOWN;
  562. break;
  563. }
  565. if (p->ModeInfo.Mirror & MIRROR_LEFTRIGHT)
  566. p->p.Output.Format.Video.Direction ^= DIR_MIRRORLEFTRIGHT;
  568. if (p->ModeInfo.Mirror & MIRROR_UPDOWN)
  569. p->p.Output.Format.Video.Direction ^= DIR_MIRRORUPDOWN;
  571. Ahi2PixelFormat(p->ModeInfo.PixelFormat,&p->p.Output.Format.Video.Pixel);
  572. FillInfo(&p->p.Output.Format.Video.Pixel);
  574. AdjustOrientation(&p->p.Output.Format.Video,0);
  575. }
  577. static bool_t UpdateOverlay(ahi* p,int BufCount,int TempCount);
  578. static int IDCTUpdateFunc(ahi* p);
  579. static void Done(ahi* p);
  581. static bool_t SafeAhiInit(ahi* p)
  582. {
  583. if (p->TmpInited)
  584. {
  585. p->TmpInited = 0;
  586. return 1;
  587. }
  588. return p->AhiInit(0)==SUCCESS;
  589. }
  591. static void SafeAhiTerm(ahi* p)
  592. {
  593. if (p->NoRelease)
  594. p->TmpInited = 1;
  595. else
  596. {
  597. p->AhiTerm();
  598. if (p->AhiUnmap)
  599. p->AhiUnmap();
  600. }
  601. }
  603. static int UpdateNoRelease(ahi* p)
  604. {
  605. if (p->TmpInited && !p->NoRelease)
  606. {
  607. p->TmpInited = 0;
  608. SafeAhiTerm(p);
  609. }
  610. return ERR_NONE;
  611. }
  613. static int Enum(ahi* p, int* No, datadef* Param)
  614. {
  615. if (OverlayEnum(&p->p,No,Param)==ERR_NONE)
  616. return ERR_NONE;
  617. return NodeEnumTable(No,Param,AHIParams);
  618. }
  620. static int Set(ahi* p,int No,const void* Data,int Size)
  621. {
  622. int Result = OverlaySet(&p->p,No,Data,Size);
  623. switch (No)
  624. {
  625. case NODE_CRASH:
  626. Done(p);
  627. break;
  629. case AHI_DEVICEBITMAP:
  630. if (Size==sizeof(bool_t))
  631. {
  632. DWORD Disp;
  633. DWORD Value;
  634. HKEY Key;
  635. if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, ATIBase, 0, NULL, 0, 0, NULL, &Key, &Disp) == ERROR_SUCCESS)
  636. {
  637. Value = *(bool_t*)Data;
  638. RegSetValueEx(Key, DisableDevice, 0, REG_DWORD, (LPBYTE)&Value, sizeof(Value));
  639. RegCloseKey(Key);
  640. Result = ERR_NONE;
  641. }
  642. }
  643. break;
  645. case AHI_STRETCHFLIP: SETVALUE(p->AllowStretchFlip,bool_t,ERR_NONE); break;
  646. case AHI_LOWBITDEPTH: SETVALUE(p->AllowLowBitdepth,bool_t,ERR_NONE); break;
  647. case AHI_PRIMARYREUSE: SETVALUE(p->AllowPrimaryReUse,bool_t,ERR_NONE); break;
  648. case AHI_NORELEASE: SETVALUE(p->NoRelease,bool_t,UpdateNoRelease(p)); break; // no compare
  649. case AHI_IDCTBUG: SETVALUE(p->IDCTBug,bool_t,IDCTUpdateFunc(p)); break;
  650. }
  652. return Result;
  653. }
  655. static int GetFreeMemory(ahi* p,int Mem)
  656. {
  657. int a=0;
  658. int b;
  659. if (p->AhiSurfGetLargestFreeBlockSize)
  660. {
  661. if (p->Context)
  662. p->AhiSurfGetLargestFreeBlockSize(p->Context,FORMAT_YUV420,&a,&b,Mem);
  663. else
  664. if (SafeAhiInit(p))
  665. {
  666. int No;
  667. for (No=0;;No++)
  668. {
  669. int Result = p->AhiDevEnum(&p->Device,&p->DevInfo,No);
  670. if (Result == SUCCESS && CheckVersion(p,0))
  671. {
  672. if (p->AhiDevOpen(&p->Context,p->Device,DevOpenName,2)==SUCCESS)
  673. {
  674. p->AhiDevClientVersion(p->Context,CLIENTVERSION);
  675. p->AhiSurfGetLargestFreeBlockSize(p->Context,FORMAT_YUV420,&a,&b,Mem);
  676. p->AhiDevClose(p->Context);
  677. }
  678. p->Context = NULL;
  679. break;
  680. }
  681. if (Result == ENDENUM)
  682. break;
  683. }
  685. SafeAhiTerm(p);
  686. }
  688. a = (a * 3) >> 1; // 12bit/pixel
  689. }
  690. return a;
  691. }
  693. static int Get(ahi* p,int No,void* Data,int Size)
  694. {
  695. int Result = OverlayGet(&p->p,No,Data,Size);
  696. switch (No)
  697. {
  698. case AHI_NAME: 
  699. StrToTcs((tchar_t*)Data,Size/sizeof(tchar_t),p->DevInfo.Name);
  700. Result = ERR_NONE;
  701. break;
  703. case AHI_VERSION: 
  704. StrToTcs((tchar_t*)Data,Size/sizeof(tchar_t),p->DevInfo.Version);
  705. Result = ERR_NONE;
  706. break;
  708. case AHI_DEVICEBITMAP:
  709. if (Size==sizeof(bool_t))
  710. {
  711. HKEY Key;
  713. Result = ERR_NONE;
  714. *(bool_t*)Data = 0;
  716. if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, ATIBase, 0, 0, &Key) == ERROR_SUCCESS)
  717. {
  718. DWORD Value;
  719. DWORD RegSize = sizeof(Value);
  720. DWORD RegType;
  722. if (RegQueryValueEx(Key, DisableDevice, 0, &RegType, (LPBYTE)&Value, &RegSize) == ERROR_SUCCESS && 
  723. RegType == REG_DWORD && Value!=0)
  724. *(bool_t*)Data = 1;
  726. RegCloseKey(Key);
  727. }
  728. }
  729. break;
  731. case AHI_STRETCHFLIP: GETVALUE(p->AllowStretchFlip,bool_t); break;
  732. case AHI_LOWBITDEPTH: GETVALUE(p->AllowLowBitdepth,bool_t); break;
  733. case AHI_PRIMARYREUSE: GETVALUE(p->AllowPrimaryReUse,bool_t); break;
  734. case AHI_NORELEASE: GETVALUE(p->NoRelease,bool_t); break;
  735. case AHI_IDCTBUG: GETVALUE(p->IDCTBug,bool_t); break;
  736. case AHI_REVISION: GETVALUE(p->DevInfo.Revision,int); break;
  737. case AHI_CHIPID: GETVALUE(p->DevInfo.ChipId,int); break;
  738. case AHI_REVISIONID: GETVALUE(p->DevInfo.RevisionId,int); break;
  739. case AHI_TOTALMEMORY: GETVALUE(p->DevInfo.TotalMemory,int); break;
  740. case AHI_INTERNALTOTALMEM: GETVALUE(p->DevInfo.InternalMemSize,int); break;
  741. case AHI_EXTERNALTOTALMEM: GETVALUE(p->DevInfo.ExternalMemSize,int); break;
  742. case AHI_INTERNALFREEMEM: GETVALUE(GetFreeMemory(p,MEM_INTERNAL),int); break;
  743. case AHI_EXTERNALFREEMEM: GETVALUE(GetFreeMemory(p,MEM_EXTERNAL),int); break;
  744. case AHI_CAPS1: GETVALUE(p->DevInfo.Caps1,int); break;
  745. case AHI_CAPS2: GETVALUE(p->DevInfo.Caps2,int); break;
  746. case AHI_CAPS3: GETVALUE(p->DevInfo.Caps3,int); break;
  747. case AHI_CAPS4: GETVALUE(p->DevInfo.Caps4,int); break;
  748. case AHI_UNMAP: GETVALUE((int)p->AhiUnmap,int); break;
  749. }
  750. return Result;
  751. }
  753. static int GetPitch(ahi* p,ahisurface* Surf)
  754. {
  755. planeinfo Info;
  756. surfinfo SInfo;
  758. if (p->OvlPlaneY)
  759. {
  760. p->AhiSurfPlaneInfo(p->Context,Surf,&Info,p->OvlPlaneY);
  761. return Info.Pitch;
  762. }
  763. else
  764. {
  765. p->AhiSurfInfo(p->Context,Surf,&SInfo);
  766. return SInfo.Pitch;
  767. }
  768. }
  770. static bool_t AllocBuffer(ahi* p,int No,int Width,int Height,int Mode)
  771. {
  772. int FirstMode;
  773. int SecondMode;
  774. ahisurface* Surf = NULL;
  775. ahisurface* SurfR = NULL;
  776. int FinalMode = 0;
  778. int Size[2];
  779. Size[0] = Width;
  780. Size[1] = Height;
  782. if (Mode == MEM_ANY_CHG)
  783. Mode = (No & 1) ? MEM_ANY_INT : MEM_ANY_EXT;
  785. if (Mode == MEM_ANY_INT)
  786. {
  787. FirstMode = MEM_INTERNAL;
  788. SecondMode = MEM_EXTERNAL;
  789. }
  790. else
  791. if (Mode == MEM_ANY_EXT)
  792. {
  793. FirstMode = MEM_EXTERNAL;
  794. SecondMode = MEM_INTERNAL;
  795. }
  796. else
  797. {
  798. FirstMode = Mode;
  799. SecondMode = 0;
  800. }
  802. p->AhiSurfAlloc(p->Context,&Surf,Size,p->OvlFormat,FirstMode);
  803. if (Surf)
  804. FinalMode = FirstMode;
  806. if (!Surf && SecondMode)
  807. {
  808. p->AhiSurfAlloc(p->Context,&Surf,Size,p->OvlFormat,SecondMode);
  809. if (Surf)
  810. FinalMode = SecondMode;
  811. }
  813. if (!Surf && p->FullScreenOverlay && !p->Landscape && !p->PrimaryReUse && p->AllowPrimaryReUse)
  814. {
  815. ahisurface* Primary = NULL;
  816. p->AhiDispSurfGet(p->Context,&Primary);
  817. if (Primary)
  818. {
  819. p->AhiSurfReuse(p->Context,&Surf,Primary,Size,p->OvlFormat,0);
  820. if (Surf)
  821. {
  822. FinalMode = MEM_PRIMARY;
  823. p->PrimaryReUse = 1;
  824. WaitDisable(1);
  825. }
  826. }
  827. }
  829. DEBUG_MSG4(DEBUG_VIDEO,T("AHIALLOC %d: %d,%d %d"),No,Size[0],Size[1],FinalMode);
  831. if (Surf)
  832. {
  833. void* Ptr;
  835. if (No < SCALE)
  836. {
  837. p->Overlay.Pitch = GetPitch(p,Surf);
  838. Size[0] = Height;
  839. Size[1] = Width;
  841. p->AhiSurfReuse(p->Context,&SurfR,Surf,Size,p->OvlFormat,0);
  843. if (!SurfR)
  844. {
  845. // this shouldn't happen
  846. p->AhiSurfFree(p->Context,Surf);
  847. return 0;
  848. }
  850. p->OverlayRPitch = GetPitch(p,SurfR);
  851. }
  853. p->Buf[No] = Surf;
  854. p->BufR[No] = SurfR;
  855. p->BufMode[No] = FinalMode;
  856. p->BufFrameNo[No] = -1;
  858. if (p->OvlPlaneY)
  859. {
  860. planeinfo Info;
  861. p->AhiSurfPlaneInfo(p->Context,Surf,&Info,p->OvlPlaneY);
  862. if (p->AhiSurfLock(p->Context,Surf,&Ptr,p->OvlPlaneY)==SUCCESS)
  863. {
  864. FillColor(Ptr,Info.Pitch,0,0,Info.Width,Info.Height,8,0);
  865. p->AhiSurfUnlock(p->Context,Surf,p->OvlPlaneY);
  866. }
  867. p->AhiSurfPlaneInfo(p->Context,Surf,&Info,p->OvlPlaneU);
  868. if (p->AhiSurfLock(p->Context,Surf,&Ptr,p->OvlPlaneU)==SUCCESS)
  869. {
  870. FillColor(Ptr,Info.Pitch,0,0,Info.Width,Info.Height,8,128);
  871. p->AhiSurfUnlock(p->Context,Surf,p->OvlPlaneU);
  872. }
  873. p->AhiSurfPlaneInfo(p->Context,Surf,&Info,p->OvlPlaneV);
  874. if (p->AhiSurfLock(p->Context,Surf,&Ptr,p->OvlPlaneV)==SUCCESS)
  875. {
  876. FillColor(Ptr,Info.Pitch,0,0,Info.Width,Info.Height,8,128);
  877. p->AhiSurfUnlock(p->Context,Surf,p->OvlPlaneV);
  878. }
  879. }
  880. else
  881. {
  882. surfinfo SInfo;
  883. p->AhiSurfInfo(p->Context,Surf,&SInfo);
  884. if (p->AhiSurfLock(p->Context,Surf,&Ptr,0)==SUCCESS)
  885. {
  886. FillColor(Ptr,SInfo.Pitch,0,0,SInfo.Width,SInfo.Height,16,0);
  887. p->AhiSurfUnlock(p->Context,Surf,0);
  888. }
  889. }
  890. return 1;
  891. }
  892. return 0;
  893. }
  895. static void UpdateOverlaySurf(ahi* p,bool_t Idle)
  896. {
  897. int Show = p->ShowCurr;
  898. if (p->Buf[SCALE])
  899. {
  900. Show = SCALE + p->ScaleCurr;
  901. Idle = 1; // is this needed?
  902. }
  903. if (p->Buf[Show])
  904. {
  905. if (Idle) p->AhiDrawIdle(p->Context,0);
  906. p->AhiDispOverlaySurf(p->Context,p->Buf[Show],&p->Param,0);
  907. //DEBUG_MSG1(DEBUG_VIDEO,T("ATI %08x"),p->Buf[Show]);
  908. }
  909. }
  911. static void Stretch(ahi* p,bool_t Update,bool_t Flip)
  912. {
  913. ahisurface* Src;
  914. ahisurface* Dst;
  915. ahirect DstRect;
  916. ahirect SrcRect;
  917. int ScaleMode = (p->p.FX.Flags & (BLITFX_ARITHSTRETCH50|BLITFX_ARITHSTRETCHALWAYS)) ? 5:1;
  919. if (p->Buf[SCALE+1] && Flip)
  920. p->ScaleCurr ^= 1;
  922. Src = p->Buf[p->ShowCurr];
  923. Dst = p->Buf[SCALE+p->ScaleCurr];
  925. DstRect.Left = 0;
  926. DstRect.Top = 0;
  927. DstRect.Right = p->ScaleWidth >> p->OvlUVX2;
  928. DstRect.Bottom = p->ScaleHeight >> p->OvlUVY2;
  930. SrcRect.Left = p->OverlayRect.x >> p->OvlUVX2;
  931. SrcRect.Top = p->OverlayRect.y >> p->OvlUVY2;
  932. SrcRect.Right = (p->OverlayRect.x + p->OverlayRect.Width) >> p->OvlUVX2;
  933. SrcRect.Bottom = (p->OverlayRect.y + p->OverlayRect.Height) >> p->OvlUVY2;
  935. if (p->OvlPlaneU)
  936. {
  937. if (p->Shrink) p->AhiDrawIdle(p->Context,0);
  938. p->AhiDrawSurfSrcSet(p->Context,Src,p->OvlPlaneU);
  939. p->AhiDrawSurfDstSet(p->Context,Dst,p->OvlPlaneU);
  940. if (p->Stretch)
  941. p->AhiDrawStretchBlt(p->Context,&DstRect,&SrcRect,ScaleMode);
  942. else
  943. p->AhiDrawBitBlt(p->Context,&DstRect,(ahipoint*)&SrcRect.Left);
  944. }
  946. if (p->OvlPlaneV)
  947. {
  948. if (p->Shrink) p->AhiDrawIdle(p->Context,0);
  949. p->AhiDrawSurfSrcSet(p->Context,Src,p->OvlPlaneV);
  950. p->AhiDrawSurfDstSet(p->Context,Dst,p->OvlPlaneV);
  951. if (p->Stretch)
  952. p->AhiDrawStretchBlt(p->Context,&DstRect,&SrcRect,ScaleMode);
  953. else
  954. p->AhiDrawBitBlt(p->Context,&DstRect,(ahipoint*)&SrcRect.Left);
  955. }
  957. DstRect.Left <<= p->OvlUVX2;
  958. DstRect.Top <<= p->OvlUVY2;
  959. DstRect.Right <<= p->OvlUVX2;
  960. DstRect.Bottom <<= p->OvlUVY2;
  962. SrcRect.Left <<= p->OvlUVX2;
  963. SrcRect.Top <<= p->OvlUVY2;
  964. SrcRect.Right <<= p->OvlUVX2;
  965. SrcRect.Bottom <<= p->OvlUVY2;
  967. if (p->Shrink) p->AhiDrawIdle(p->Context,0);
  968. p->AhiDrawSurfSrcSet(p->Context,Src,p->OvlPlaneY);
  969. p->AhiDrawSurfDstSet(p->Context,Dst,p->OvlPlaneY);
  970. if (p->Stretch)
  971. p->AhiDrawStretchBlt(p->Context,&DstRect,&SrcRect,ScaleMode);
  972. else
  973. p->AhiDrawBitBlt(p->Context,&DstRect,(ahipoint*)&SrcRect.Left);
  975. if (p->Buf[SCALE+1] && Update && Flip)
  976. UpdateOverlaySurf(p,1);
  977. }
  979. static void SwapPtr(ahi* p,int a,int b,int SwapShow)
  980. {
  981. ahisurface* t;
  983. t = p->Buf[a];
  984. p->Buf[a] = p->Buf[b];
  985. p->Buf[b] = t;
  987. t = p->BufR[a];
  988. p->BufR[a] = p->BufR[b];
  989. p->BufR[b] = t;
  991. SwapInt(&p->BufMode[a],&p->BufMode[b]);
  993. if (SwapShow)
  994. {
  995. SwapInt(&p->BufFrameNo[a],&p->BufFrameNo[b]);
  997. if (p->ShowNext == a)
  998. p->ShowNext = b;
  999. else
  1000. if (p->ShowNext == b)
  1001. p->ShowNext = a;
  1003. if (p->ShowLast == a)
  1004. p->ShowLast = b;
  1005. else
  1006. if (p->ShowLast == b)
  1007. p->ShowLast = a;
  1009. if (p->ShowCurr == a)
  1010. p->ShowCurr = b;
  1011. else
  1012. if (p->ShowCurr == b)
  1013. p->ShowCurr = a;
  1014. }
  1015. }
  1017. static void MoveBuf(ahi* p,int Src,int Dst)
  1018. {
  1019. ahirect DstRect;
  1020. ahipoint SrcPos;
  1022. DstRect.Left = DstRect.Top = 0;
  1023. DstRect.Right = p->Overlay.Width;
  1024. DstRect.Bottom = p->Overlay.Height;
  1025. SrcPos.x = SrcPos.y = 0;
  1027. p->AhiDrawSurfSrcSet(p->Context,p->Buf[Src],p->OvlPlaneY);
  1028. p->AhiDrawSurfDstSet(p->Context,p->Buf[Dst],p->OvlPlaneY);
  1029. p->AhiDrawBitBlt(p->Context,&DstRect,&SrcPos);
  1031. DstRect.Right >>= p->OvlUVX2;
  1032. DstRect.Bottom >>= p->OvlUVY2;
  1034. if (p->OvlPlaneU)
  1035. {
  1036. p->AhiDrawSurfSrcSet(p->Context,p->Buf[Src],p->OvlPlaneU);
  1037. p->AhiDrawSurfDstSet(p->Context,p->Buf[Dst],p->OvlPlaneU);
  1038. p->AhiDrawBitBlt(p->Context,&DstRect,&SrcPos);
  1039. }
  1040. if (p->OvlPlaneV)
  1041. {
  1042. p->AhiDrawSurfSrcSet(p->Context,p->Buf[Src],p->OvlPlaneV);
  1043. p->AhiDrawSurfDstSet(p->Context,p->Buf[Dst],p->OvlPlaneV);
  1044. p->AhiDrawBitBlt(p->Context,&DstRect,&SrcPos);
  1045. }
  1046. }
  1048. static void SwapBuf(ahi* p,int a,int b)
  1049. {
  1050. planes s,Tmp;
  1052. if (SurfaceAlloc(Tmp,&p->Overlay)==ERR_NONE)
  1053. {
  1054. if (Lock(p,a,s,0)==ERR_NONE)
  1055. {
  1056. SurfaceCopy(&p->Overlay,&p->Overlay,s,Tmp,NULL); // save from a
  1057. Unlock(p,a);
  1059. MoveBuf(p,b,a); // move b->a
  1061. if (Lock(p,b,s,0)==ERR_NONE)
  1062. {
  1063. SurfaceCopy(&p->Overlay,&p->Overlay,Tmp,s,NULL); // restore to b
  1064. Unlock(p,b);
  1065. }
  1067. SwapPtr(p,a,b,0); // swap pointers
  1068. }
  1069. SurfaceFree(Tmp);
  1070. }
  1071. }
  1073. static void Optimize(ahi* p)
  1074. {
  1075. if (p->Buf[SCALE] && p->BufCount==3 && 
  1076. !(p->BufMode[0] == p->BufMode[1] && p->BufMode[1] == p->BufMode[2]))
  1077. {
  1078. // we have one buffer in different pool
  1079. // b-frame motion compensation is faster if the two reference frames
  1080. // are in different pool as the b-frame
  1082. if (p->BufMode[1] == p->BufMode[2])
  1083. SwapBuf(p,0,2);
  1084. else
  1085. if (p->BufMode[0] == p->BufMode[2])
  1086. SwapBuf(p,1,2);
  1087. }
  1088. }
  1090. static void UpdateBrightness(ahi* p,int Brightness)
  1091. {
  1092. int Delta,No;
  1093. int DCAdd = Brightness * DCFACTOR;
  1095. if (p->DCAdd != DCAdd)
  1096. {
  1097. Delta = DCAdd - p->DCAdd;
  1098. p->DCAdd = DCAdd;
  1100. if (p->IDCT)
  1101. {
  1102. planes s,Tmp;
  1103. int ValidTmp = 0;
  1104. int SwapNo = p->TempCount ? p->BufCount : 0;
  1105. int MacroNo;
  1106. int MacroCount = (p->Overlay.Width >> 4)*(p->Overlay.Height >> 4);
  1108. // we need to save one buffer and adjust manually (if there are no temp buffers)
  1109. if (p->BufCount && !p->TempCount && Lock(p,SwapNo,s,0)==ERR_NONE)
  1110. {
  1111. if (SurfaceAlloc(Tmp,&p->Overlay)==ERR_NONE)
  1112. {
  1113. ValidTmp = 1;
  1114. SurfaceCopy(&p->Overlay,&p->Overlay,s,Tmp,NULL);
  1115. }
  1116. Unlock(p,SwapNo);
  1117. }
  1119. *(int32_t*)&p->Data[0] = -1;
  1120. p->Data[0].skip0 = 0;
  1121. p->Data[0].data0 = (idct_block_t)Delta;
  1123. for (No=p->TempCount ? 0:1;No<p->BufCount;++No)
  1124. {
  1125. // swap context
  1126. p->AhiIDCTFrameStart(p->IDCT,p->Buf[SwapNo],p->Buf[No],NULL,p->FrameNo,0);
  1127. for (MacroNo=0;MacroNo<MacroCount;++MacroNo)
  1128. {
  1129. p->AhiIDCTMComp8x8(p->IDCT,p->Data,1,&p->Zero,NULL,MacroNo,1);
  1130. p->AhiIDCTMComp8x8(p->IDCT,p->Data,1,&p->Zero,NULL,MacroNo,1);
  1131. p->AhiIDCTMComp8x8(p->IDCT,p->Data,1,&p->Zero,NULL,MacroNo,1);
  1132. p->AhiIDCTMComp8x8(p->IDCT,p->Data,1,&p->Zero,NULL,MacroNo,1);
  1133. p->AhiIDCTMComp8x8(p->IDCT,NULL,0,&p->Zero,NULL,MacroNo,0);
  1134. p->AhiIDCTMComp8x8(p->IDCT,NULL,0,&p->Zero,NULL,MacroNo,0);
  1135. }
  1136. p->AhiIDCTFrameEnd(p->IDCT,p->FrameNo++);
  1138. // swap pointer
  1139. SwapPtr(p,No,SwapNo,0);
  1140. }
  1142. if (ValidTmp)
  1143. {
  1144. if (Lock(p,SwapNo,s,0)==ERR_NONE)
  1145. {
  1146. blitfx FX;
  1147. memset(&FX,0,sizeof(FX));
  1148. FX.ScaleX = SCALE_ONE;
  1149. FX.ScaleY = SCALE_ONE;
  1150. FX.Brightness = Delta / DCFACTOR;
  1151. SurfaceCopy(&p->Overlay,&p->Overlay,Tmp,s,&FX);
  1152. Unlock(p,SwapNo);
  1153. }
  1154. SurfaceFree(Tmp);
  1155. }
  1156. }
  1157. }
  1158. }
  1160. static void FreePrimaryReUse(ahi* p);
  1162. static void UpdateDirection(ahi* p,int Dir)
  1163. {
  1164. int No;
  1165. if (p->Overlay.Direction != Dir)
  1166. {
  1167. planes s,Tmp;
  1168. video TmpSurface;
  1169. int ValidTmp = 0;
  1170. int SwapNo;
  1172. // hide overlay
  1173. if (p->p.Show && p->AllCount)
  1174. {
  1175. if (p->PrimaryReUse)
  1176. FreePrimaryReUse(p);
  1177. p->AhiDispOverlayState(p->Context,0,0);
  1178. p->AhiDispWaitVBlank(p->Context,0);
  1179. }
  1181. SwapNo = p->TempCount ? p->BufCount : 0;
  1183. // we need to save one buffer and swap manually (if there are no temp buffers)
  1184. if (p->BufCount && !p->TempCount && Lock(p,SwapNo,s,0)==ERR_NONE)
  1185. {
  1186. if (SurfaceAlloc(Tmp,&p->Overlay)==ERR_NONE)
  1187. {
  1188. ValidTmp = 1;
  1189. TmpSurface = p->Overlay;
  1190. SurfaceCopy(&p->Overlay,&p->Overlay,s,Tmp,NULL);
  1191. }
  1192. Unlock(p,SwapNo);
  1193. }
  1195. p->Overlay.Direction = Dir;
  1196. SwapInt(&p->Overlay.Width,&p->Overlay.Height);
  1197. SwapInt(&p->Overlay.Pitch,&p->OverlayRPitch);
  1198. IDCTUpdateFunc(p);
  1200. // swap buffer pointers
  1202. for (No=0;No<p->AllCount;++No)
  1203. {
  1204. ahisurface* t = p->Buf[No];
  1205. p->Buf[No] = p->BufR[No];
  1206. p->BufR[No] = t;
  1207. }
  1209. // swapxy content of buffers
  1211. for (No=p->TempCount ? 0:1;No<p->BufCount;++No)
  1212. {
  1213. ahirect DstRect;
  1214. ahipoint SrcPos;
  1216. DstRect.Left = DstRect.Top = 0;
  1217. DstRect.Right = p->Overlay.Width;
  1218. DstRect.Bottom = p->Overlay.Height;
  1219. SrcPos.x = SrcPos.y = 0;
  1221. p->AhiDrawSurfSrcSet(p->Context,p->BufR[No],p->OvlPlaneY);
  1222. p->AhiDrawSurfDstSet(p->Context,p->Buf[SwapNo],p->OvlPlaneY);
  1223. p->AhiDrawRotateBlt(p->Context,&DstRect,&SrcPos,1,1,0);
  1225. DstRect.Right >>= p->OvlUVX2;
  1226. DstRect.Bottom >>= p->OvlUVY2;
  1228. if (p->OvlPlaneU)
  1229. {
  1230. p->AhiDrawSurfSrcSet(p->Context,p->BufR[No],p->OvlPlaneU);
  1231. p->AhiDrawSurfDstSet(p->Context,p->Buf[SwapNo],p->OvlPlaneU);
  1232. p->AhiDrawRotateBlt(p->Context,&DstRect,&SrcPos,1,1,0);
  1233. }
  1234. if (p->OvlPlaneV)
  1235. {
  1236. p->AhiDrawSurfSrcSet(p->Context,p->BufR[No],p->OvlPlaneV);
  1237. p->AhiDrawSurfDstSet(p->Context,p->Buf[SwapNo],p->OvlPlaneV);
  1238. p->AhiDrawRotateBlt(p->Context,&DstRect,&SrcPos,1,1,0);
  1239. }
  1241. SwapPtr(p,No,SwapNo,0);
  1242. }
  1244. if (ValidTmp)
  1245. {
  1246. if (Lock(p,SwapNo,s,0)==ERR_NONE)
  1247. {
  1248. SurfaceRotate(&TmpSurface,&p->Overlay,Tmp,s,DIR_SWAPXY);
  1249. Unlock(p,SwapNo);
  1250. }
  1251. SurfaceFree(Tmp);
  1252. }
  1254. if (p->ShowNext >= 0)
  1255. p->ShowCurr = p->ShowNext;
  1256. if (p->ShowCurr<0 || p->ShowCurr>=p->BufCount)
  1257. p->ShowCurr = 0;
  1258. }
  1259. }
  1261. static void UpdateColorKey(ahi* p)
  1262. {
  1263. int No;
  1265. p->p.ColorKey = COLORKEY; // use colorkey by default
  1266. if (p->p.FullScreenViewport)
  1267. p->p.ColorKey = CRGB(0,0,0); // black colorkey because of lowbitdepth
  1268. if (p->PrimaryReUse || p->OvlFormat != FORMAT_YUV420)
  1269. p->p.ColorKey = RGB_NULL;
  1271. if (p->Landscape)
  1272. {
  1273. // disable colorkey for external overlays in landscape mode
  1274. if (p->Buf[SCALE])
  1275. {
  1276. if (p->BufMode[SCALE] == MEM_EXTERNAL)
  1277. p->p.ColorKey = RGB_NULL;
  1279. if (p->BufMode[SCALE+1] == MEM_EXTERNAL)
  1280. p->p.ColorKey = RGB_NULL;
  1281. }
  1282. else
  1283. {
  1284. for (No=0;No<p->AllCount;++No)
  1285. if (p->BufMode[No] == MEM_EXTERNAL)
  1286. {
  1287. p->p.ColorKey = RGB_NULL;
  1288. break;
  1289. }
  1290. }
  1291. }
  1292. }
  1294. static void FreePrimaryReUse(ahi* p)
  1295. {
  1296. int No;
  1297. if (p->BufMode[SCALE] == MEM_PRIMARY || p->BufMode[SCALE+1] == MEM_PRIMARY)
  1298. FreeScale(p,NULL);
  1300. for (No=0;No<p->AllCount;++No)
  1301. if (p->BufMode[No] == MEM_PRIMARY)
  1302. {
  1303. if (No != p->AllCount-1)
  1304. {
  1305. MoveBuf(p,No,p->AllCount-1);
  1306. SwapPtr(p,No,p->AllCount-1,0);
  1307. }
  1309. FreeBuffer(p,p->AllCount-1,NULL);
  1310. p->AllCount--;
  1311. p->TempCount = p->AllCount - p->BufCount;
  1312. if (p->TempCount < 0)
  1313. {
  1314. p->BufCount = p->AllCount;
  1315. p->TempCount = 0;
  1316. }
  1317. }
  1319. ClearPrimary(p);
  1320. }
  1322. static void UpdateLowBitdepth(ahi* p)
  1323. {
  1324. SetLowBitdepth(p,p->p.Show && p->p.FullScreenViewport && !p->BlitMode);
  1325. }
  1327. static void UpdateAlign(ahi* p,int ScaleMode)
  1328. {
  1329. blitfx OvlFX = p->p.FX;
  1330. bool_t FullScreenOverlay;
  1331. rect FullScreen;
  1332. rect OverlayRect;
  1334. PhyToVirt(NULL,&FullScreen,&p->p.Output.Format.Video);
  1336. VirtToPhy(&p->p.Viewport,&p->p.DstAlignedRect,&p->p.Output.Format.Video);
  1337. VirtToPhy(NULL,&p->OverlayRect,&p->p.Input.Format.Video);
  1339. if (OvlFX.Direction & DIR_SWAPXY)
  1340. {
  1341. SwapInt(&p->OverlayRect.Width,&p->OverlayRect.Height);
  1342. SwapInt(&OvlFX.ScaleX,&OvlFX.ScaleY);
  1343. }
  1345. OvlFX.Direction &= ~DIR_SWAPXY;
  1346. if (!ScaleMode ||
  1347. (OvlFX.ScaleX == OvlFX.ScaleY &&
  1348.  OvlFX.ScaleX >= (SCALE_ONE*98)/100 && OvlFX.ScaleX < (SCALE_ONE*103)/100))
  1349. OvlFX.ScaleX = OvlFX.ScaleY = SCALE_ONE;
  1351. p->Stretch = OvlFX.ScaleX != SCALE_ONE || OvlFX.ScaleY != SCALE_ONE;
  1352. p->StretchOnlyInternal = (p->Stretch && ScaleMode==2);
  1353. p->Shrink = OvlFX.ScaleX < SCALE_ONE || OvlFX.ScaleY < SCALE_ONE;
  1355. if ((p->p.FX.Flags & (BLITFX_ARITHSTRETCH50|BLITFX_ARITHSTRETCHALWAYS)) && p->Stretch)
  1356. {
  1357. // avoid bilinear scale overrun (shrink source)
  1358. if (p->OverlayRect.Width>2) 
  1359. {
  1360. OvlFX.ScaleX = Scale(OvlFX.ScaleX,p->OverlayRect.Width,p->OverlayRect.Width-2);
  1361. p->OverlayRect.Width -= 2;
  1362. }
  1363. if (p->OverlayRect.Height>2) 
  1364. {
  1365. OvlFX.ScaleY = Scale(OvlFX.ScaleY,p->OverlayRect.Height,p->OverlayRect.Height-2);
  1366. p->OverlayRect.Height -= 2;
  1367. }
  1368. }
  1370. AnyAlign(&p->p.DstAlignedRect, &p->OverlayRect, &OvlFX, 2, 1, SCALE_ONE>>1,SCALE_ONE*16);
  1372. PhyToVirt(&p->p.DstAlignedRect,&p->p.GUIAlignedRect,&p->p.Output.Format.Video);
  1374. FullScreenOverlay = EqRect(&FullScreen,&p->p.GUIAlignedRect);
  1376. if (FullScreenOverlay != p->FullScreenOverlay)
  1377. {
  1378. p->FullScreenOverlay = FullScreenOverlay;
  1379. p->p.Overlay = !FullScreenOverlay;
  1380. p->MaxCount = MAXIDCTBUF;
  1381. }
  1383. if (p->PrimaryReUse && !p->FullScreenOverlay)
  1384. FreePrimaryReUse(p);
  1386. // if (ScaleMode>0 && p->IDCT && !p->Internal && p->Stretch && OvlFX.ScaleX < (SCALE_ONE*13/10))
  1387. // {
  1388. // external idct buffer with external scale buffer would be very slow
  1389. // not too much scale factor -> fall back to 100% if internal scale buffer not available
  1390. // p->StretchOnlyInternal = 1;
  1391. // }
  1393. if (ScaleMode>0 && p->IDCT && p->Landscape && !p->Stretch && !p->FullScreenOverlay)
  1394. {
  1395. // using idct with external memory and 100% zoom in landscape mode
  1396. // this means external overlay in landscape mode -> try internal scale buffer (100% scale)
  1397. // (except when the overlay covers the full screen)
  1398. p->Stretch = 1;
  1399. p->StretchOnlyInternal = 1; // but don't use external memory (it would make no sense)
  1400. }
  1402. if (p->Stretch)
  1403. {
  1404. p->SoftFX.Flags &= ~(BLITFX_AVOIDTEARING|BLITFX_VMEMROTATED|BLITFX_VMEMUPDOWN);
  1405. }
  1406. else
  1407. {
  1408. // no BLITFX_VMEMROTATED needed because overlay is always in lcd space
  1409. // (just the primary RGB surface is rotated)
  1410. p->SoftFX.Flags |= BLITFX_AVOIDTEARING;
  1411. if (p->p.FX.Direction & DIR_MIRRORUPDOWN)
  1412. p->SoftFX.Flags |= BLITFX_VMEMUPDOWN;
  1413. }
  1415. BlitRelease(p->p.Soft);
  1416. p->p.Soft = BlitCreate(&p->Overlay,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  1418. if (p->IDCT)
  1419. p->p.Caps = VC_BRIGHTNESS;
  1421. // because blit might use alignment enlarge the dest area
  1422. OverlayRect = p->OverlayRect;
  1423. OverlayRect.Width = (OverlayRect.Width + (OverlayRect.x & 15) + 15) & ~15;
  1424. OverlayRect.Height = (OverlayRect.Height + (OverlayRect.y & 15) + 15) & ~15;
  1425. OverlayRect.x &= ~15;
  1426. OverlayRect.y &= ~15;
  1428. VirtToPhy(NULL,&p->p.SrcAlignedRect,&p->p.Input.Format.Video);
  1429. BlitAlign(p->p.Soft, &OverlayRect, &p->p.SrcAlignedRect);
  1430. }
  1432. // build ahi overlay param
  1433. static void UpdateAHI(ahi* p)
  1434. {
  1435. if (p->Buf[SCALE])
  1436. {
  1437. p->Param.SrcRect.Left = 0;
  1438. p->Param.SrcRect.Top = 0;
  1439. }
  1440. else
  1441. {
  1442. p->Param.SrcRect.Left = p->OverlayRect.x;
  1443. p->Param.SrcRect.Top = p->OverlayRect.y;
  1444. }
  1445. p->Param.SrcRect.Right = p->Param.SrcRect.Left + p->p.DstAlignedRect.Width;
  1446. p->Param.SrcRect.Bottom = p->Param.SrcRect.Top + p->p.DstAlignedRect.Height;
  1448. p->Param.DstRect.Left = p->p.DstAlignedRect.x;
  1449. p->Param.DstRect.Top = p->p.DstAlignedRect.y;
  1450. p->Param.DstRect.Right = p->p.DstAlignedRect.x + p->p.DstAlignedRect.Width;
  1451. p->Param.DstRect.Bottom = p->p.DstAlignedRect.y + p->p.DstAlignedRect.Height;
  1453. DEBUG_MSG4(DEBUG_VIDEO,T("UpdateAHI %d,%d,%d,%d"),
  1454. p->Param.SrcRect.Left,
  1455. p->Param.SrcRect.Top,
  1456. p->Param.SrcRect.Right,
  1457. p->Param.SrcRect.Bottom);
  1459. p->Param.Mirror = 0;
  1460. if (p->p.FX.Direction & DIR_MIRRORLEFTRIGHT)
  1461. p->Param.Mirror |= MIRROR_LEFTRIGHT;
  1462. if (p->p.FX.Direction & DIR_MIRRORUPDOWN)
  1463. p->Param.Mirror |= MIRROR_UPDOWN;
  1465. if (p->p.ColorKey == CRGB(0,0,0)) {
  1466. // lowbitdepth
  1467. p->Param.ColorMask = 0xF;
  1468. p->Param.ColorKey = 0;
  1469. }
  1470. else
  1471. if (p->p.ColorKey != RGB_NULL) {
  1472. p->Param.ColorMask = 
  1473. p->p.Output.Format.Video.Pixel.BitMask[0] | 
  1474. p->p.Output.Format.Video.Pixel.BitMask[1] |
  1475. p->p.Output.Format.Video.Pixel.BitMask[2];
  1476. p->Param.ColorKey = RGBToFormat(p->p.ColorKey,&p->p.Output.Format.Video.Pixel);
  1477. }
  1478. else
  1479. {
  1480. p->Param.ColorMask = 0;
  1481. p->Param.ColorKey = 0;
  1482. }
  1483. }
  1485. static void UpdateAlloc(ahi* p,int BufCount,int AllCount,int ScaleMode,bool_t* Hidden)
  1486. {
  1487. int No;
  1488. int Mode;
  1490. if (ScaleMode==2)
  1491. Mode = MEM_EXTERNAL; // only accept external
  1492. else
  1493. if (p->IDCT)
  1494. Mode = MEM_ANY_CHG;
  1495. else
  1496. Mode = MEM_ANY_INT; // prefer internal memory transfer
  1498. if (!p->IDCT && p->Landscape && p->AllCount)
  1499. {
  1500. // try to reallocate buffer if it's not in the right memory
  1502. if ((Mode == MEM_EXTERNAL && p->BufMode[0] != MEM_EXTERNAL) ||
  1503. (Mode == MEM_ANY_INT && p->BufMode[0] != MEM_INTERNAL))
  1504. {
  1505. // free surfaces
  1507. FreeScale(p,Hidden);
  1508. for (No=p->AllCount-1;No>=0;--No)
  1509. FreeBuffer(p,No,Hidden);
  1510. p->AllCount = 0;
  1511. }
  1512. }
  1514. if (AllCount != p->AllCount)
  1515. {
  1516. FreeScale(p,Hidden);
  1518. if (AllCount < p->AllCount && p->PrimaryReUse)
  1519. FreePrimaryReUse(p);
  1521. //try to keep same number of internal and external buffers
  1522. if (Mode == MEM_ANY_CHG)
  1523. {
  1524. int Ext = 0;
  1525. int Int = 0;
  1526. for (No=0;No<AllCount;++No)
  1527. {
  1528. if (p->BufMode[No] == MEM_EXTERNAL)
  1529. Ext++;
  1530. if (p->BufMode[No] == MEM_INTERNAL)
  1531. Int++;
  1532. }
  1534. for (No=AllCount;No<p->AllCount;++No)
  1535. {
  1536. int Search = 0;
  1537. if (p->BufMode[No] == MEM_EXTERNAL && Ext<Int)
  1538. Search = MEM_INTERNAL;
  1539. if (p->BufMode[No] == MEM_INTERNAL && Int<Ext)
  1540. Search = MEM_EXTERNAL;
  1542. if (Search)
  1543. {
  1544. int No2;
  1545. for (No2=0;No2<AllCount;++No2)
  1546. if (p->BufMode[No2] == Search)
  1547. {
  1548. MoveBuf(p,No2,No);
  1549. SwapPtr(p,No2,No,0);
  1550. if (Search == MEM_EXTERNAL)
  1551. {
  1552. Ext--;
  1553. Int++;
  1554. }
  1555. else
  1556. {
  1557. Ext++;
  1558. Int--;
  1559. }
  1560. break;
  1561. }
  1562. }
  1563. }
  1564. }
  1566. //free unneccessary buffers
  1567. for (No=p->AllCount-1;No>=AllCount;--No)
  1568. FreeBuffer(p,No,Hidden);
  1570. if (p->AllCount > AllCount)
  1571. p->AllCount = AllCount;
  1573. if (p->IDCT && p->Internal)
  1574. {
  1575. //allocate neccessary buffers in internal memory (if possible)
  1576. for (No=p->AllCount;No<AllCount;++No)
  1577. {
  1578. if (!AllocBuffer(p,No,p->Overlay.Width,p->Overlay.Height,MEM_INTERNAL))
  1579. {
  1580. // failed? need use to external? (temp buffers doesn't count)
  1581. if (p->AllCount < BufCount && p->DevInfo.ExternalMemSize) 
  1582. {
  1583. p->Internal = 0;
  1585. // free all buffers, so they can be realloced as external
  1586. for (No=0;No<p->AllCount;++No)
  1587. FreeBuffer(p,No,Hidden);
  1588. p->AllCount = 0;
  1589. }
  1590. break;
  1591. }
  1592. p->AllCount = No+1;
  1593. }
  1594. }
  1596. //allocate neccessary buffers
  1597. for (No=p->AllCount;No<AllCount;++No)
  1598. {
  1599. if (!AllocBuffer(p,No,p->Overlay.Width,p->Overlay.Height,Mode))
  1600. {
  1601. p->MaxCount = max(1,p->AllCount);
  1602. break;
  1603. }
  1604. p->AllCount = No+1;
  1605. }
  1607. if (p->ShowCurr >= p->AllCount)
  1608. p->ShowCurr = 0;
  1609. if (p->ShowNext >= p->AllCount)
  1610. p->ShowNext = -1;
  1611. if (p->ShowLast >= p->AllCount)
  1612. p->ShowLast = -1;
  1613. p->BufCount = min(p->AllCount,BufCount);
  1614. p->TempCount = p->AllCount - p->BufCount;
  1615. }
  1616. }
  1618. static bool_t UpdateOverlay(ahi* p,int BufCount,int TempCount)
  1619. {
  1620. int ScaleMode;
  1621. bool_t Hidden = 0;
  1622. int AllCount = BufCount + TempCount;
  1623. if (AllCount>p->MaxCount) return 0;
  1625. p->SoftFX.Flags = 0;
  1626. p->SoftFX.Brightness = p->p.FX.Brightness;
  1627. p->SoftFX.Contrast = p->p.FX.Contrast;
  1628. p->SoftFX.Saturation = p->p.FX.Saturation;
  1629. p->SoftFX.Direction = p->p.FX.Direction & DIR_SWAPXY;
  1630. p->SoftFX.RGBAdjust[0] = p->p.FX.RGBAdjust[0];
  1631. p->SoftFX.RGBAdjust[1] = p->p.FX.RGBAdjust[1];
  1632. p->SoftFX.RGBAdjust[2] = p->p.FX.RGBAdjust[2];
  1634. ScaleMode = 1;
  1635. if (!p->IDCT && p->Landscape && (p->p.FX.ScaleX != SCALE_ONE || p->p.FX.ScaleY != SCALE_ONE))
  1636. ScaleMode = 2; // first try normal=external scale=internal
  1638. scaletry:
  1640. // alloc buffers
  1641. UpdateAlloc(p,BufCount,AllCount,ScaleMode,&Hidden);
  1643. // align
  1644. UpdateAlign(p,ScaleMode);
  1646. // allocate/free scale surface
  1647. if (p->AllCount && p->Stretch)
  1648. {
  1649. if (p->ScaleWidth != p->p.DstAlignedRect.Width ||
  1650. p->ScaleHeight != p->p.DstAlignedRect.Height)
  1651. {
  1652. int Mode;
  1654. FreeScale(p,&Hidden);
  1656. if (p->StretchOnlyInternal)
  1657. Mode = MEM_INTERNAL; // only accept internal
  1658. else
  1659. if (p->BufMode[0] == MEM_INTERNAL) // try opposite of normal buffer
  1660. Mode = MEM_ANY_EXT;  
  1661. else
  1662. Mode = MEM_ANY_INT;
  1664. AllocBuffer(p,SCALE,p->p.DstAlignedRect.Width,p->p.DstAlignedRect.Height,Mode);
  1665. if (p->AllowStretchFlip)
  1666. AllocBuffer(p,SCALE+1,p->p.DstAlignedRect.Width,p->p.DstAlignedRect.Height,Mode);
  1668. if (p->Buf[SCALE])
  1669. {
  1670. p->ScaleCurr = 0;
  1671. p->ScaleWidth = p->p.DstAlignedRect.Width;
  1672. p->ScaleHeight = p->p.DstAlignedRect.Height;
  1674. Optimize(p);
  1675. Stretch(p,0,0);
  1676. }
  1677. }
  1678. }
  1679. else
  1680. FreeScale(p,&Hidden);
  1682. if (p->Stretch && !p->Buf[SCALE] && p->AllCount)
  1683. {
  1684. --ScaleMode;
  1685. goto scaletry; // no memory for scale buffer -> try again
  1686. }
  1688. UpdateColorKey(p);
  1689. OverlayUpdateShow(&p->p,1);
  1691. if (p->p.ColorKey != RGB_NULL)
  1692. WinInvalidate(&p->p.Viewport,1);
  1694. UpdateAHI(p);
  1695. UpdateOverlaySurf(p,1);
  1697. if ((p->p.Show || p->PrimaryReUse) && p->BufCount)
  1698. {
  1699. p->AhiDispOverlayState(p->Context,p->p.Show || p->PrimaryReUse,0);
  1700. UpdateLowBitdepth(p);
  1701. }
  1703. if (!TempCount && p->AllCount != AllCount && p->BufCount<2 && !p->ErrorMemory)
  1704. {
  1705. p->ErrorMemory = 1;
  1706. ShowError(AHI_ID,AHI_ID,AHI_OUT_OF_MEMORY);
  1707. }
  1709. return p->AllCount == AllCount;
  1710. }
  1712. static int UpdateBlit(ahi* p)
  1713. {
  1714. blitfx OvlFX = p->p.FX;
  1715. video Overlay;
  1716. int BufWidth,BufHeight;
  1718. p->p.ColorKey = RGB_NULL;
  1720. ReTry:
  1722. p->SoftFX = p->p.FX;
  1723. p->SoftFX.ScaleX = SCALE_ONE; // scale handled by hardware
  1724. p->SoftFX.ScaleY = SCALE_ONE;
  1725. OvlFX.Direction = 0;
  1727. if (p->BlitDownScale)
  1728. {
  1729. p->SoftFX.ScaleX >>= 1;
  1730. p->SoftFX.ScaleY >>= 1;
  1731. OvlFX.ScaleX <<= 1;
  1732. OvlFX.ScaleY <<= 1;
  1733. }
  1735. //align to 100%
  1736. if (OvlFX.ScaleX > SCALE_ONE-(SCALE_ONE/16) && OvlFX.ScaleX < SCALE_ONE+(SCALE_ONE/16) &&
  1737. OvlFX.ScaleY > SCALE_ONE-(SCALE_ONE/16) && OvlFX.ScaleY < SCALE_ONE+(SCALE_ONE/16))
  1738. {
  1739. OvlFX.ScaleX = SCALE_ONE;
  1740. OvlFX.ScaleY = SCALE_ONE;
  1741. }
  1743. if (p->SoftFX.Direction & DIR_SWAPXY)
  1744. SwapInt(&OvlFX.ScaleX,&OvlFX.ScaleY);
  1746. p->Overlay.Direction = CombineDir(p->p.InputDirection,p->p.OrigFX.Direction,p->p.Output.Format.Video.Direction);
  1747. Overlay = p->Overlay;
  1748. Overlay.Width = p->p.Input.Format.Video.Width;
  1749. Overlay.Height = p->p.Input.Format.Video.Height;
  1750. if (p->BlitDownScale)
  1751. {
  1752. Overlay.Width >>= 1;
  1753. Overlay.Height >>= 1;
  1754. }
  1755. if (Overlay.Direction & DIR_SWAPXY)
  1756. SwapInt(&Overlay.Width,&Overlay.Height);
  1758. VirtToPhy(&p->p.Viewport,&p->p.DstAlignedRect,&p->p.Output.Format.Video);
  1759. VirtToPhy(NULL,&p->OverlayRect,&Overlay);
  1761. AnyAlign(&p->p.DstAlignedRect, &p->OverlayRect, &OvlFX, 2, 1, SCALE_ONE>>1,SCALE_ONE*16);
  1763. p->Stretch = (OvlFX.ScaleX != SCALE_ONE || OvlFX.ScaleY != SCALE_ONE) && 
  1764. (p->p.DstAlignedRect.Width != p->OverlayRect.Width && p->p.DstAlignedRect.Height != p->OverlayRect.Height);
  1766. VirtToPhy(NULL,&p->p.SrcAlignedRect,&p->p.Input.Format.Video);
  1768. BlitRelease(p->p.Soft);
  1769. p->p.Soft = BlitCreate(&Overlay,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  1770. BlitAlign(p->p.Soft,&p->OverlayRect,&p->p.SrcAlignedRect);
  1772. // pitch has to 16byte aligned, so to be able to rotate width we must align 8 pixels (16bit RGB)
  1773. BufWidth = (p->OverlayRect.Width+7) & ~7;
  1774. BufHeight = (p->OverlayRect.Height+7) & ~7;
  1776. if (!p->Buf[0] || p->Overlay.Width != BufWidth || p->Overlay.Height != BufHeight)
  1777. {
  1778. FreeBuffer(p,0,NULL);
  1779. p->Overlay.Width = BufWidth;
  1780. p->Overlay.Height = BufHeight;
  1781. if (!AllocBuffer(p,0,BufWidth,BufHeight,MEM_ANY_INT))
  1782. {
  1783. if (!p->BlitDownScale)
  1784. {
  1785. p->BlitDownScale = 1;
  1786. goto ReTry;
  1787. }
  1788. return ERR_OUT_OF_MEMORY;
  1789. }
  1790. }
  1792. BlitRelease(p->p.Soft);
  1793. p->p.Soft = BlitCreate(&p->Overlay,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  1794. BlitAlign(p->p.Soft,&p->OverlayRect,&p->p.SrcAlignedRect);
  1796. if (!p->Stretch) // no scaling -> adjust dst rectangle with soft yuv blitting alignement
  1797. {
  1798. p->p.DstAlignedRect.x += (p->p.DstAlignedRect.Width - p->OverlayRect.Width) >> 1;
  1799. p->p.DstAlignedRect.y += (p->p.DstAlignedRect.Height - p->OverlayRect.Height) >> 1;
  1800. p->p.DstAlignedRect.Width = p->OverlayRect.Width;
  1801. p->p.DstAlignedRect.Height = p->OverlayRect.Height;
  1802. }
  1804. PhyToVirt(&p->p.DstAlignedRect,&p->p.GUIAlignedRect,&p->p.Output.Format.Video);
  1805. return ERR_NONE;
  1806. }
  1808. static int Reset(ahi* p)
  1809. {
  1810. if (p->Context)
  1811. GetMode(p);
  1812. return ERR_NONE;
  1813. }
  1815. static int Orientation(void* This)
  1816. {
  1817. ahi* p = (ahi*)This;
  1818. if (!p->Context)
  1819. {
  1820. p->p.Output.Format.Video.Direction = -1;
  1822. if (SafeAhiInit(p))
  1823. {
  1824. int No;
  1825. for (No=0;;No++)
  1826. {
  1827. int Result = p->AhiDevEnum(&p->Device,&p->DevInfo,No);
  1828. if (Result == SUCCESS && CheckVersion(p,0))
  1829. {
  1830. if (p->AhiDevOpen(&p->Context,p->Device,DevOpenName,2)==SUCCESS)
  1831. {
  1832. p->AhiDevClientVersion(p->Context,CLIENTVERSION);
  1833. GetMode(p);
  1834. p->AhiDevClose(p->Context);
  1835. }
  1836. p->Context = NULL;
  1837. break;
  1838. }
  1839. if (Result == ENDENUM)
  1840. break;
  1841. }
  1843. SafeAhiTerm(p);
  1844. }
  1845. }
  1847. return p->p.Output.Format.Video.Direction;
  1848. }
  1850. static int Blit(ahi* p, const constplanes Data, const constplanes DataLast);
  1851. static int BlitOverlay(ahi* p, const constplanes Data, const constplanes DataLast);
  1852. static int Update(ahi* p);
  1853. static int UpdateShow(ahi* p);
  1855. /*
  1856. static void CheckMem(const tchar_t* s)
  1857. {
  1858. MEMORYSTATUS Status;
  1859. Status.dwLength = sizeof(Status);
  1860. GlobalMemoryStatus(&Status); 
  1861. DebugMessage(T("%s %d %d"),s,Status.dwAvailPhys,Status.dwAvailVirtual);
  1862. }
  1863. */
  1865. static int Init(ahi* p)
  1866. {
  1867. int No;
  1868. int Result = ERR_DEVICE_ERROR;
  1870. p->Device = NULL;
  1871. p->Context = NULL;
  1872. memset(&p->Param,0,sizeof(p->Param));
  1874. for (No=0;No<MAXIDCTBUF+MAXSCALE;++No)
  1875. {
  1876. p->Buf[No] = NULL;
  1877. p->BufR[No] = NULL;
  1878. p->BufMode[No] = 0;
  1879. p->BufFrameNo[No] = -1;
  1880. }
  1882. if (SafeAhiInit(p))
  1883. {
  1884. p->SoftFX = p->p.FX;
  1885. p->SoftFX.ScaleX = SCALE_ONE;
  1886. p->SoftFX.ScaleY = SCALE_ONE;
  1887. p->SoftFX.Direction = 0;
  1889. memset(&p->Overlay,0,sizeof(video));
  1890. p->Overlay.Width = ALIGN16(p->IDCTInit ? p->IDCTWidth:p->p.Input.Format.Video.Width);
  1891. p->Overlay.Height = ALIGN16(p->IDCTInit ? p->IDCTHeight:p->p.Input.Format.Video.Height);
  1892. p->Overlay.Direction = p->IDCTInit ? 0:p->p.Input.Format.Video.Direction;
  1893. p->Overlay.Aspect = ASPECT_ONE;
  1894. p->BlitDownScale = 0;
  1896. if (p->IDCTInit && !PlanarYUV420(&p->p.Input.Format.Video.Pixel))
  1897. {
  1898. SafeAhiTerm(p);
  1899. return ERR_NOT_SUPPORTED;
  1900. }
  1902. p->ErrorMemory = p->Overlay.Width==0 || p->Overlay.Height==0;
  1903. p->Landscape = 0;
  1904. p->Internal = 1;
  1905. p->ScaleWidth = 0;
  1906. p->ScaleHeight = 0;
  1907. p->ScaleCurr = 0;
  1908. p->ShowCurr = 0;
  1909. p->ShowNext = -1;
  1910. p->ShowNextIdle = 0;
  1911. p->ShowLast = -1;
  1912. p->MaxCount = MAXIDCTBUF;
  1913. p->AllCount = 0;
  1914. p->BufCount = 0;
  1915. p->TempCount = 0;
  1916. p->Zero = 0;
  1917. p->FrameNo = 0;
  1918. p->LowBitdepth = 0;
  1919. p->PrimaryReUse = 0;
  1920. p->Primary = NULL;
  1922. WaitDisable(0);
  1924. for (No=0;;No++)
  1925. {
  1926. int AtiResult = p->AhiDevEnum(&p->Device,&p->DevInfo,No);
  1927. if (AtiResult == SUCCESS)
  1928. {
  1929. if (!CheckVersion(p,p->IDCTInit))
  1930. {
  1931. ShowError(AHI_ID,AHI_ID,AHI_OLDVERSION,p->Version);
  1932. p->Context = NULL;
  1933. Result = ERR_NOT_SUPPORTED; // don't show device error message afterwards
  1934. break;
  1935. }
  1937. AtiResult = FAIL;
  1938. TRY_BEGIN
  1939. AtiResult = p->AhiDevOpen(&p->Context,p->Device,DevOpenName,2);
  1940. TRY_END;
  1942. if (AtiResult != SUCCESS)
  1943. {
  1944. ShowError(AHI_ID,AHI_ID,AHI_OPEN_ERROR);
  1945. p->Context = NULL;
  1946. Result = ERR_NOT_SUPPORTED; // don't show device error message afterwards
  1947. break;
  1948. }
  1950. p->AhiDevClientVersion(p->Context,CLIENTVERSION);
  1952. p->AhiDrawRopSet(p->Context,0xCCCC);
  1953. p->AhiDispOverlayState(p->Context,0,0);
  1954. p->AhiDispSurfGet(p->Context,&p->Primary);
  1956. GetMode(p);
  1958. if (p->DevInfo.ExternalMemSize>0 &&
  1959. PlanarYUV(&p->p.Input.Format.Video.Pixel,NULL,NULL,NULL))
  1960. {
  1961. // because of software rotation we can't use YUV422 
  1962. // even if the source is in this format. so we are using
  1963. // YUV420 with all YUV planar formats
  1965. p->Overlay.Pixel.Flags = PF_YUV420;
  1966. p->p.Overlay = 1;
  1967. p->BlitMode = 0;
  1968. p->OvlFormat = FORMAT_YUV420;
  1969. p->OvlUVX2 = 1;
  1970. p->OvlUVY2 = 1;
  1971. p->OvlPlaneY = PLANE_Y;
  1972. p->OvlPlaneU = PLANE_U;
  1973. p->OvlPlaneV = PLANE_V;
  1974. p->p.Blit = (ovlblit)BlitOverlay;
  1975. p->p.Update = (ovlfunc)Update;
  1976. p->p.UpdateShow = (ovlfunc)UpdateShow;
  1977. }
  1978. else
  1979. {
  1980. if (p->IDCTInit) // this shouldn't happen
  1981. {
  1982. p->AhiDevClose(p->Context);
  1983. p->Context = NULL;
  1984. break;
  1985. }
  1987. DefaultRGB(&p->Overlay.Pixel,16,5,6,5,0,0,0);
  1988. p->p.Overlay = 0;
  1989. p->BlitMode = 1;
  1990. p->OvlFormat = FORMAT_RGB565;
  1991. p->OvlUVX2 = 0;
  1992. p->OvlUVY2 = 0;
  1993. p->OvlPlaneY = 0;
  1994. p->OvlPlaneU = 0;
  1995. p->OvlPlaneV = 0;
  1996. p->p.Blit = (ovlblit)Blit;
  1997. p->p.Update = (ovlfunc)UpdateBlit;
  1998. p->p.UpdateShow = (ovlfunc)NULL;
  1999. }
  2001. // landscape mode doesn't like external memory overlays, 
  2002. // probably reading the external primary framebuffer conflicts with overlay readings
  2004. if ((p->ModeInfo.Rotation!=0 && p->ModeInfo.Rotation!=2) && p->DevInfo.ExternalMemSize>0)
  2005. {
  2006. p->Landscape = 1;
  2007. p->Internal = 0;
  2008. }
  2010. if (p->IDCTInit)
  2011. {
  2012. p->AhiIDCTOpen(p->Context,&p->IDCT,0);
  2014. if (!p->IDCT)
  2015. {
  2016. p->AhiDevClose(p->Context);
  2017. p->Context = NULL;
  2018. ShowError(AHI_ID,AHI_ID,AHI_OPEN_ERROR);
  2019. Result = ERR_NOT_SUPPORTED; // don't show device error message afterwards
  2020. break;
  2021. }
  2023. p->IDCTRounding = 1;
  2024. IDCTUpdateFunc(p);
  2025. p->AhiIDCTPropSet(p->IDCT,PROP_ROUNDING,&p->IDCTRounding,sizeof(int));
  2026. p->AhiIDCTPropSet(p->IDCT,PROP_BIAS,&p->Zero,sizeof(int));
  2028. }
  2030. Result = ERR_NONE;
  2031. break;
  2032. }
  2033. if (AtiResult == ENDENUM)
  2034. break;
  2035. }
  2037. if (!p->Context)
  2038. SafeAhiTerm(p);
  2039. }
  2041. return Result;
  2042. }
  2044. static void Done(ahi* p)
  2045. {
  2046. int No;
  2048. if (p->Context && p->IDCT)
  2049. {
  2050. p->AhiIDCTClose(p->IDCT);
  2051. p->IDCT = NULL;
  2052. }
  2054. FreeScale(p,NULL);
  2055. for (No=MAXIDCTBUF-1;No>=0;--No)
  2056. FreeBuffer(p,No,NULL);
  2057. p->TempCount = p->AllCount = p->BufCount = 0;
  2059. if (p->Context)
  2060. {
  2061. SetLowBitdepth(p,0);
  2062. p->AhiDispOverlayState(p->Context,0,0);
  2063. p->AhiDevClose(p->Context);
  2064. SafeAhiTerm(p);
  2065. p->Context = NULL;
  2066. }
  2067. }
  2069. static int Update(ahi* p)
  2070. {
  2071. UpdateDirection(p,(p->p.FX.Direction ^ p->p.Input.Format.Video.Direction) & DIR_SWAPXY);
  2072. UpdateBrightness(p,p->p.FX.Brightness);
  2073. if (!UpdateOverlay(p,p->IDCT?p->BufCount:1,0)) // temp buffers are freed!
  2074. return ERR_OUT_OF_MEMORY;
  2075. return ERR_NONE;
  2076. }
  2078. static int UpdateShow(ahi* p)
  2079. {
  2080. UpdateLowBitdepth(p);
  2081. p->AhiDispOverlayState(p->Context,p->p.Show,0);
  2082. return ERR_NONE;
  2083. }
  2085. static int Blit(ahi* p, const constplanes Data, const constplanes DataLast)
  2086. {
  2087. ahisurface* Src = p->Buf[0];
  2088. ahisurface* Dst = p->Primary;
  2089. ahirect DstRect;
  2090. ahirect SrcRect;
  2091. int ScaleMode = (p->p.FX.Flags & (BLITFX_ARITHSTRETCH50|BLITFX_ARITHSTRETCHALWAYS)) ? 5:1;
  2092. planes Planes;
  2094. p->AhiDrawIdle(p->Context,0);
  2095. if (Src && Dst && p->AhiSurfLock(p->Context,Src,&Planes[0],0)==SUCCESS)
  2096. {
  2097. BlitImage(p->p.Soft,Planes,Data,DataLast,-1,-1);
  2098. p->AhiSurfUnlock(p->Context,Src,0);
  2100. DstRect.Left = p->p.DstAlignedRect.x;
  2101. DstRect.Top = p->p.DstAlignedRect.y;
  2102. DstRect.Right = p->p.DstAlignedRect.x + p->p.DstAlignedRect.Width;
  2103. DstRect.Bottom = p->p.DstAlignedRect.y + p->p.DstAlignedRect.Height;
  2105. SrcRect.Left = p->OverlayRect.x;
  2106. SrcRect.Top = p->OverlayRect.y;
  2107. SrcRect.Right = p->OverlayRect.x + p->OverlayRect.Width;
  2108. SrcRect.Bottom = p->OverlayRect.y + p->OverlayRect.Height;
  2110. p->AhiDrawSurfSrcSet(p->Context,Src,0);
  2111. p->AhiDrawSurfDstSet(p->Context,Dst,0);
  2112. if (p->Stretch)
  2113. p->AhiDrawStretchBlt(p->Context,&DstRect,&SrcRect,ScaleMode);
  2114. else
  2115. p->AhiDrawBitBlt(p->Context,&DstRect,(ahipoint*)&SrcRect.Left);
  2116. }
  2117. return ERR_NONE;
  2118. }
  2120. static int BlitOverlay(ahi* p, const constplanes Data, const constplanes DataLast)
  2121. {
  2122. planes Planes;
  2123. int Result;
  2125. Result = Lock(p,p->ShowCurr,Planes,0);
  2126. if (Result == ERR_NONE)
  2127. {
  2128. BlitImage(p->p.Soft,Planes,Data,DataLast,-1,-1);
  2130. Unlock(p,p->ShowCurr);
  2132. if (p->Buf[SCALE])
  2133. Stretch(p,1,0);
  2134. }
  2135. return Result;
  2136. }
  2138. //**********************
  2139. //* IDCT               *
  2140. //**********************
  2142. const uint8_t ScanTable[3][64] = {
  2143. {
  2144.  0,  1,  8, 16,  9,  2,  3, 10, 
  2145. 17, 24, 32, 25, 18, 11,  4,  5,
  2146. 12, 19, 26, 33, 40, 48, 41, 34, 
  2147. 27, 20, 13,  6,  7, 14, 21, 28, 
  2148. 35, 42, 49, 56, 57, 50, 43, 36, 
  2149. 29, 22, 15, 23, 30, 37, 44, 51, 
  2150. 58, 59, 52, 45, 38, 31, 39, 46, 
  2151. 53, 60, 61, 54, 47, 55, 62, 63
  2152. },
  2153. {
  2154.    0,  1,  2,  3,  8,  9, 16, 17, 
  2155. 10, 11,  4,  5,  6,  7, 15, 14,
  2156. 13, 12, 19, 18, 24, 25, 32, 33, 
  2157. 26, 27, 20, 21, 22, 23, 28, 29,
  2158. 30, 31, 34, 35, 40, 41, 48, 49, 
  2159. 42, 43, 36, 37, 38, 39, 44, 45,
  2160. 46, 47, 50, 51, 56, 57, 58, 59, 
  2161. 52, 53, 54, 55, 60, 61, 62, 63
  2162. },
  2163. {
  2164.  0,  8, 16, 24,  1,  9,  2, 10, 
  2165. 17, 25, 32, 40, 48, 56, 57, 49,
  2166. 41, 33, 26, 18,  3, 11,  4, 12, 
  2167. 19, 27, 34, 42, 50, 58, 35, 43,
  2168. 51, 59, 20, 28,  5, 13,  6, 14, 
  2169. 21, 29, 36, 44, 52, 60, 37, 45,
  2170. 53, 61, 22, 30,  7, 15, 23, 31, 
  2171. 38, 46, 54, 62, 39, 47, 55, 63
  2172. }};
  2173. const uint8_t ZigZagSwap[64] = {
  2174.  0,  8,  1,  2,  9, 16, 24, 17, 
  2175. 10,  3,  4, 11, 18, 25, 32, 40,
  2176. 33, 26, 19, 12,  5,  6, 13, 20, 
  2177. 27, 34, 41, 48, 56, 49, 42, 35, 
  2178. 28, 21, 14,  7, 15, 22, 29, 36, 
  2179. 43, 50, 57, 58, 51, 44, 37, 30, 
  2180. 23, 31, 38, 45, 52, 59, 60, 53, 
  2181. 46, 39, 47, 54, 61, 62, 55, 63
  2182. };
  2183. const uint8_t ZigZagSwapLength[64] = {
  2184. 1,   3,  3,  6,  6,  6, 10, 10,
  2185. 10, 10, 15, 15, 15, 15, 15, 21, 
  2186. 21, 21, 21, 21, 21, 28, 28, 28,
  2187. 28, 28, 28, 28, 36, 36, 36, 36, 
  2188. 36, 36, 36, 36, 43, 43, 43, 43, 
  2189. 43, 43, 43, 49, 49, 49, 49, 49,
  2190. 49, 54, 54, 54, 54, 54, 58, 58, 
  2191. 58, 58, 61, 61, 61, 63, 63, 64
  2192. };
  2194. #define AHI(p) ((ahi*)((char*)(p)-(int)&(((ahi*)0)->IdctVMT)))
  2196. // input: Block, Length
  2197. #define AHIDCBLOCK(Offset)
  2198. {
  2199. if (Length < 1)
  2200. {
  2201. Block[0] = (idct_block_t)(Offset);
  2202. Length = 1;
  2203. }
  2204. else
  2205. Block[0] = (idct_block_t)(Block[0] + (Offset));
  2206. }
  2208. #define AHIMVINC
  2209. if (AHI(p)->MVBack) AHI(p)->MVBack++;
  2210. if (AHI(p)->MVFwd) AHI(p)->MVFwd++;
  2212. // ADJUST: don't care about MVFwd (only in b-frames which are not accumulated)
  2213. #define AHIMVADJBLOCK
  2214. if (AHI(p)->MVBack && (AHI(p)->MVBack[0] & 0x00020002)==0x00020002)
  2215. AHIDCBLOCK(2);
  2217. // Block, Length -> Dst, Count
  2218. #define AHIPACK(Dst)
  2219. ScanEnd = Scan + Length;
  2220. for (Data=Dst;;++Data)
  2221. {
  2222. int v;
  2223. *(int32_t*)Data = -1;
  2225. Last = Scan;
  2226. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  2227. if (Scan == ScanEnd) break;
  2228. v = *Scan;
  2229. Data->skip0 = (char)(Scan++ - Last);
  2230. Data->data0 = Block[v];
  2232. Count++;
  2233. Last = Scan;
  2234. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  2235. if (Scan == ScanEnd) break;
  2236. v = *Scan;
  2237. Data->skip1 = (char)(Scan++ - Last);
  2238. Data->data1 = Block[v];
  2240. Last = Scan;
  2241. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  2242. if (Scan == ScanEnd) break;
  2243. v = *Scan;
  2244. Data->skip2 = (char)(Scan++ - Last);
  2245. Data->data2 = Block[v];
  2247. Last = Scan;
  2248. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  2249. if (Scan == ScanEnd) break;
  2250. v = *Scan;
  2251. Data->skip3 = (char)(Scan++ - Last);
  2252. Data->data3 = Block[v];
  2253. }
  2255. #define AHIPACKNORMAL(ScanType)
  2256. {
  2257. const unsigned char *Scan = ScanTable[ScanType];
  2258. const unsigned char *ScanEnd;
  2259. const unsigned char *Last;
  2260. idct_ati *Data;
  2261. AHIPACK(AHI(p)->Data)
  2262. }
  2264. #define AHIPACKSWAP(Dst,ScanType)
  2265. {
  2266. const unsigned char *Scan;
  2267. const unsigned char *ScanEnd;
  2268. const unsigned char *Last;
  2269. idct_ati *Data;
  2270. if (ScanType == IDCTSCAN_ZIGZAG)
  2271. {
  2272. Scan = ZigZagSwap;
  2273. Length = ZigZagSwapLength[Length-1];
  2274. }
  2275. else
  2276. {
  2277. Scan = ScanTable[ScanType];
  2278. ScanType = 3 - ScanType;
  2279. }
  2280. AHIPACK(Dst)
  2281. }
  2283. #define AHIPACKSWAPZIGZAG(Dst)
  2284. {
  2285. const unsigned char *Scan;
  2286. const unsigned char *ScanEnd;
  2287. const unsigned char *Last;
  2288. idct_ati *Data;
  2289. Scan = ZigZagSwap;
  2290. Length = ZigZagSwapLength[Length-1];
  2291. AHIPACK(Dst)
  2292. }
  2294. #define AHIBLOCKSWAP(ScanType)
  2295. {
  2296. if (SubNo <= 4)
  2297. AHIDCBLOCK(AHI(p)->DCAdd)
  2298. Count = 0;
  2299. if (SubNo == 2)
  2300. {
  2301. if (Length>0 && Length<=64)
  2302. AHIPACKSWAP(AHI(p)->SaveData,ScanType)
  2303. AHI(p)->SaveCount = Count;
  2304. AHI(p)->SaveScanType = ScanType;
  2305. }
  2306. else
  2307. {
  2308. if (Length>0 && Length<=64)
  2309. AHIPACKSWAP(AHI(p)->Data,ScanType)
  2310. AHI(p)->AhiIDCT8x8(AHI(p)->IDCT,AHI(p)->Data,Count,AHI(p)->MacroNo,1 << ScanType); 
  2311. AHIMVINC;
  2312. if (SubNo == 3)
  2313. {
  2314. AHI(p)->AhiIDCT8x8(AHI(p)->IDCT,AHI(p)->SaveData,AHI(p)->SaveCount,AHI(p)->MacroNo,1 << AHI(p)->SaveScanType); 
  2315. AHIMVINC;
  2316. }
  2317. }
  2318. }
  2320. #define AHIMCOMPBLOCKSWAP
  2321. {
  2322. Count = 0;
  2323. if (SubNo == 2)
  2324. {
  2325. if (Length>0 && Length<=64)
  2326. AHIPACKSWAPZIGZAG(AHI(p)->SaveData)
  2327. AHI(p)->SaveCount = Count;
  2328. }
  2329. else
  2330. {
  2331. if (Length>0 && Length<=64)
  2332. AHIPACKSWAPZIGZAG(AHI(p)->Data)
  2333. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,AHI(p)->Data,Count,AHI(p)->MVBack,AHI(p)->MVFwd,AHI(p)->MacroNo,1 << IDCTSCAN_ZIGZAG);
  2334. AHIMVINC;
  2335. if (SubNo == 3)
  2336. {
  2337. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,AHI(p)->SaveData,AHI(p)->SaveCount,AHI(p)->MVBack,AHI(p)->MVFwd,AHI(p)->MacroNo,1 << IDCTSCAN_ZIGZAG);
  2338. AHIMVINC;
  2339. }
  2340. }
  2341. }
  2343. #define AHIQPEL(MVPtr)
  2344. MV = *(MVPtr++);
  2345. MV <<= 1;
  2346. MV &= ~0x00010000;
  2348. #define AHIQPELSWAP(MVPtr)
  2349. MV = *(MVPtr++);
  2350. MV = (MV << 17) |
  2351.  ((uint32_t)MV >> 15);
  2352. MV &= ~0x00010001;
  2354. static void IDCTMComp(void* p,const int* MVBack,const int* MVFwd)
  2355. {
  2356. if (MVBack)
  2357. {
  2358. int MV;
  2359. AHI(p)->MVBack = AHI(p)->MVBackTab;
  2360. AHIQPEL(MVBack); AHI(p)->MVBackTab[0] = MV;
  2361. AHIQPEL(MVBack); AHI(p)->MVBackTab[1] = MV;
  2362. AHIQPEL(MVBack); AHI(p)->MVBackTab[2] = MV;
  2363. AHIQPEL(MVBack); AHI(p)->MVBackTab[3] = MV;
  2364. AHIQPEL(MVBack); AHI(p)->MVBackTab[4] = MV;
  2365. AHIQPEL(MVBack); AHI(p)->MVBackTab[5] = MV;
  2366. }
  2367. else
  2368. AHI(p)->MVBack = NULL;
  2370. if (MVFwd)
  2371. {
  2372. int MV;
  2373. AHI(p)->MVFwd = AHI(p)->MVFwdTab;
  2374. AHIQPEL(MVFwd); AHI(p)->MVFwdTab[0] = MV;
  2375. AHIQPEL(MVFwd); AHI(p)->MVFwdTab[1] = MV;
  2376. AHIQPEL(MVFwd); AHI(p)->MVFwdTab[2] = MV;
  2377. AHIQPEL(MVFwd); AHI(p)->MVFwdTab[3] = MV;
  2378. AHIQPEL(MVFwd); AHI(p)->MVFwdTab[4] = MV;
  2379. AHIQPEL(MVFwd); AHI(p)->MVFwdTab[5] = MV;
  2380. }
  2381. else
  2382. AHI(p)->MVFwd = NULL;
  2383. }
  2385. static void IDCTMCompSwap(void* p,const int* MVBack,const int* MVFwd)
  2386. {
  2387. if (MVBack)
  2388. {
  2389. int MV;
  2390. AHI(p)->MVBack = AHI(p)->MVBackTab;
  2391. AHIQPELSWAP(MVBack); AHI(p)->MVBackTab[0] = MV;
  2392. AHIQPELSWAP(MVBack); AHI(p)->MVBackTab[2] = MV;
  2393. AHIQPELSWAP(MVBack); AHI(p)->MVBackTab[1] = MV;
  2394. AHIQPELSWAP(MVBack); AHI(p)->MVBackTab[3] = MV;
  2395. AHIQPELSWAP(MVBack); AHI(p)->MVBackTab[4] = MV;
  2396. AHIQPELSWAP(MVBack); AHI(p)->MVBackTab[5] = MV;
  2397. }
  2398. else
  2399. AHI(p)->MVBack = NULL;
  2401. if (MVFwd)
  2402. {
  2403. int MV;
  2404. AHI(p)->MVFwd = AHI(p)->MVFwdTab;
  2405. AHIQPELSWAP(MVFwd); AHI(p)->MVFwdTab[0] = MV;
  2406. AHIQPELSWAP(MVFwd); AHI(p)->MVFwdTab[2] = MV;
  2407. AHIQPELSWAP(MVFwd); AHI(p)->MVFwdTab[1] = MV;
  2408. AHIQPELSWAP(MVFwd); AHI(p)->MVFwdTab[3] = MV;
  2409. AHIQPELSWAP(MVFwd); AHI(p)->MVFwdTab[4] = MV;
  2410. AHIQPELSWAP(MVFwd); AHI(p)->MVFwdTab[5] = MV;
  2411. }
  2412. else
  2413. AHI(p)->MVFwd = NULL;
  2414. }
  2416. static void IDCTProcess(void* p,int x,int y)
  2417. {
  2418. AHI(p)->MacroSubNo = 0;
  2419. AHI(p)->MacroNo = x + y*AHI(p)->MacroWidth;
  2420. }
  2422. static void IDCTProcessSwap(void* p,int x,int y)
  2423. {
  2424. AHI(p)->MacroSubNo = 0;
  2425. AHI(p)->MacroNo = y + x*AHI(p)->MacroWidth;
  2426. }
  2428. static void IDCTIntra(void* p,idct_block_t *Block,int Length,int ScanType)
  2429. {
  2430. int Count = 0;
  2431. int SubNo = ++AHI(p)->MacroSubNo;
  2432. if (SubNo <= 4)
  2433. AHIDCBLOCK(AHI(p)->DCAdd)
  2435. if (Length>0 && Length<=64)
  2436. AHIPACKNORMAL(ScanType)
  2438. AHI(p)->AhiIDCT8x8(AHI(p)->IDCT,AHI(p)->Data,Count,AHI(p)->MacroNo,1 << ScanType);
  2439. }
  2441. static void IDCTInter(void* p,idct_block_t *Block,int Length)
  2442. {
  2443. int Count = 0;
  2445. if (Length>0 && Length<=64)
  2446. AHIPACKNORMAL(IDCTSCAN_ZIGZAG)
  2448. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,AHI(p)->Data,Count,AHI(p)->MVBack,AHI(p)->MVFwd,AHI(p)->MacroNo,1 << IDCTSCAN_ZIGZAG);
  2449. AHIMVINC
  2450. }
  2452. static void IDCTInterAdj(void* p,idct_block_t *Block,int Length)
  2453. {
  2454. int Count = 0;
  2455. AHIMVADJBLOCK
  2457. if (Length>0 && Length<=64)
  2458. AHIPACKNORMAL(IDCTSCAN_ZIGZAG)
  2460. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,AHI(p)->Data,Count,AHI(p)->MVBack,AHI(p)->MVFwd,AHI(p)->MacroNo,1 << IDCTSCAN_ZIGZAG);
  2461. AHIMVINC
  2462. }
  2464. static void IDCTIntraSwap(void* p,idct_block_t *Block,int Length,int ScanType)
  2465. {
  2466. int Count;
  2467. int SubNo = ++AHI(p)->MacroSubNo;
  2469. AHIBLOCKSWAP(ScanType);
  2470. }
  2472. static void IDCTInterSwap(void* p,idct_block_t *Block,int Length)
  2473. {
  2474. int Count;
  2475. int SubNo = ++AHI(p)->MacroSubNo;
  2477. AHIMCOMPBLOCKSWAP;
  2478. }
  2480. static void IDCTInterSwapAdj(void* p,idct_block_t *Block,int Length)
  2481. {
  2482. int Count;
  2483. int SubNo = ++AHI(p)->MacroSubNo;
  2485. AHIMVADJBLOCK
  2486. AHIMCOMPBLOCKSWAP
  2487. }
  2489. static void IDCTCopy16x16(void* p,int x,int y,int Forward)
  2490. {
  2491. int MacroNo = x + y*AHI(p)->MacroWidth;
  2492. int* Back = NULL;
  2493. int* Fwd = NULL;
  2495. if (Forward)
  2496. Fwd = &AHI(p)->Zero;
  2497. else
  2498. Back = &AHI(p)->Zero;
  2500. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2501. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2502. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2503. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2504. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2505. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2506. }
  2508. static void IDCTCopy16x16Swap(void* p,int x,int y,int Forward)
  2509. {
  2510. int MacroNo = y + x*AHI(p)->MacroWidth;
  2511. int* Back = NULL;
  2512. int* Fwd = NULL;
  2514. if (Forward)
  2515. Fwd = &AHI(p)->Zero;
  2516. else
  2517. Back = &AHI(p)->Zero;
  2519. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2520. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2521. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2522. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2523. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2524. AHI(p)->AhiIDCTMComp8x8(AHI(p)->IDCT,NULL,0,Back,Fwd,MacroNo,0);
  2525. }
  2527. static int IDCTUpdateFunc(ahi* p)
  2528. {
  2529. if (p->Overlay.Direction)
  2530. {
  2531. p->IdctVMT.Copy16x16 = IDCTCopy16x16Swap;
  2532. p->IdctVMT.Process = IDCTProcessSwap;
  2533. p->IdctVMT.MComp8x8 = IDCTMCompSwap;
  2534. p->IdctVMT.MComp16x16 = IDCTMCompSwap;
  2535. p->IdctVMT.Intra8x8 = (idctintra)IDCTIntraSwap;
  2536. p->IdctVMT.Inter8x8 = (idctinter)(p->IDCTBug ? IDCTInterSwapAdj : IDCTInterSwap);
  2537. }
  2538. else 
  2539. {
  2540. p->IdctVMT.Copy16x16 = IDCTCopy16x16;
  2541. p->IdctVMT.Process = IDCTProcess;
  2542. p->IdctVMT.MComp8x8 = IDCTMComp;
  2543. p->IdctVMT.MComp16x16 = IDCTMComp;
  2544. p->IdctVMT.Intra8x8 = (idctintra)IDCTIntra;
  2545. p->IdctVMT.Inter8x8 = (idctinter)(p->IDCTBug ? IDCTInterAdj : IDCTInter);
  2546. }
  2547. return ERR_NONE;
  2548. }
  2550. static int IDCTOutputFormat(ahi* p, const void* Data, int Size)
  2551. {
  2552. packetformat Format;
  2553. int Result;
  2554. p->IDCTInit = 1;
  2556. if (Size == sizeof(video))
  2557. {
  2558. memset(&Format,0,sizeof(Format));
  2559. Format.Type = PACKET_VIDEO;
  2560. Format.Format.Video = *(const video*)Data;
  2561. Data = &Format;
  2562. Size = sizeof(packetformat);
  2564. //IDCTWidth or IDCTHeight could have changes so invalidate current input format
  2565. memset(&p->p.Input.Format.Video,0,sizeof(video));
  2566. }
  2568. Result = p->p.Node.Set((node*)p,OUT_INPUT|PIN_FORMAT,Data,Size);
  2570. if (Size && Result != ERR_NONE)
  2571. p->p.Node.Set((node*)p,OUT_INPUT|PIN_FORMAT,NULL,0);
  2573. p->IDCTInit = 0;
  2574. return Result;
  2575. }
  2577. static int IDCTSend(void* p,tick_t RefTime,const flowstate* State);
  2579. static int IDCTSet(void* p, int No, const void* Data, int Size)
  2580. {
  2581. flowstate State;
  2582. int Result = ERR_INVALID_PARAM;
  2583. switch (No)
  2584. {
  2585. case IDCT_MODE: if (*(int*)Data==0) Result = ERR_NONE; break;
  2586. case IDCT_BUFFERWIDTH: SETVALUE(AHI(p)->IDCTWidth,int,ERR_NONE); break;
  2587. case IDCT_BUFFERHEIGHT: SETVALUE(AHI(p)->IDCTHeight,int,ERR_NONE); break;
  2588. case IDCT_FORMAT:
  2589. assert(Size == sizeof(video) || !Data);
  2590. Result = IDCTOutputFormat(AHI(p),Data,Size);
  2591. break;
  2593. case IDCT_BACKUP: 
  2594. if (Size == sizeof(idctbackup))
  2595. Result = IDCTRestore(p,(idctbackup*)Data);
  2596. break;
  2598. case IDCT_ROUNDING:
  2599. if (Size == sizeof(bool_t) && AHI(p)->IDCT)
  2600. {
  2601. AHI(p)->IDCTRounding = !*(const int*)Data;
  2602. AHI(p)->AhiIDCTPropSet(AHI(p)->IDCT,PROP_ROUNDING,&AHI(p)->IDCTRounding,sizeof(int));
  2603. Result = ERR_NONE;
  2604. }
  2605. break;
  2607. case IDCT_SHOW: 
  2608. SETVALUE(AHI(p)->ShowNext,int,ERR_NONE); 
  2609. if (AHI(p)->ShowNext >= AHI(p)->BufCount) AHI(p)->ShowNext = -1;
  2610. break;
  2612. case IDCT_BUFFERCOUNT:
  2613. assert(Size == sizeof(int));
  2614. Result = ERR_NONE;
  2615. if (AHI(p)->BufCount != *(const int*)Data &&
  2616. !UpdateOverlay(AHI(p),*(const int*)Data,0))
  2617. Result = ERR_OUT_OF_MEMORY;
  2618. break;
  2620. case FLOW_FLUSH:
  2621. AHI(p)->ShowNext = -1;
  2622. Result = ERR_NONE;
  2623. break;
  2625. case FLOW_RESEND:
  2626. State.CurrTime = TIME_RESEND;
  2627. State.DropLevel = 0;
  2628. Result = IDCTSend(p,-1,&State);
  2629. break;
  2630. }
  2631. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+AHI(p)->AllCount)
  2632. SETVALUE(AHI(p)->BufFrameNo[No-IDCT_FRAMENO],int,ERR_NONE);
  2633. return Result;
  2634. }
  2636. static int IDCTEnumAHI(void* p, int* No, datadef* Param)
  2637. {
  2638. int Result = IDCTEnum(p,No,Param);
  2639. if (Result == ERR_NONE && Param->No == IDCT_OUTPUT)
  2640. Param->Flags |= DF_RDONLY;
  2641. return Result;
  2642. }
  2644. static int IDCTGet(void* p, int No, void* Data, int Size)
  2645. {
  2646. int Result = ERR_INVALID_PARAM;
  2647. switch (No)
  2648. {
  2649. case FLOW_BUFFERED: GETVALUE(1,bool_t); break;
  2650. case NODE_PARTOF: GETVALUE(AHI(p),ahi*); break;
  2651. case IDCT_OUTPUT|PIN_FORMAT: GETVALUECOND(AHI(p)->p.Input,packetformat,AHI(p)->IDCT); break;
  2652. case IDCT_OUTPUT|PIN_PROCESS: GETVALUE(NULL,packetprocess); break;
  2653. case IDCT_OUTPUT: GETVALUE(AHI(p)->IDCTOutput,pin); break;
  2654. case IDCT_FORMAT: 
  2655. assert(Size==sizeof(video));
  2656. if (AHI(p)->IDCT)
  2657. {
  2658. video* i = (video*)Data;
  2659. *i = AHI(p)->p.Input.Format.Video;
  2660. if ((AHI(p)->Overlay.Direction ^ i->Direction) & DIR_SWAPXY)
  2661. {
  2662. i->Direction ^= DIR_SWAPXY;
  2663. SwapInt(&i->Width,&i->Height);
  2664. }
  2665. Result = ERR_NONE;
  2666. }
  2667. break;
  2668. case IDCT_MODE: GETVALUE(0,int); break;
  2669. case IDCT_ROUNDING: GETVALUE(!AHI(p)->IDCTRounding,bool_t); break;
  2670. case IDCT_BUFFERCOUNT: GETVALUE(AHI(p)->IDCT?AHI(p)->BufCount:0,int); break;
  2671. case IDCT_BUFFERWIDTH: GETVALUE(AHI(p)->IDCTWidth,int); break;
  2672. case IDCT_BUFFERHEIGHT: GETVALUE(AHI(p)->IDCTHeight,int); break;
  2673. case IDCT_SHOW: GETVALUE(AHI(p)->ShowNext,int); break;
  2674. case IDCT_BACKUP: 
  2675. assert(Size == sizeof(idctbackup));
  2676. Result = IDCTBackup(p,(idctbackup*)Data);
  2677. break;
  2678. }
  2679. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+AHI(p)->AllCount)
  2680. GETVALUE(AHI(p)->BufFrameNo[No-IDCT_FRAMENO],int);
  2681. return Result;
  2682. }
  2684. static int IDCTLock(void* p,int No,planes Planes,int* Brightness,video* Format)
  2685. {
  2686. if (Brightness)
  2687. *Brightness = AHI(p)->p.FX.Brightness;
  2688. if (Format)
  2689. *Format = AHI(p)->Overlay;
  2690. return Lock(AHI(p),No,Planes,0);
  2691. }
  2693. static void IDCTUnlock(void* p,int No)
  2694. {
  2695. Unlock(AHI(p),No);
  2696. }
  2698. static int IDCTFrameStart(void* p,int FrameNo,int *OldFrameNo,int DstNo,int BackNo,int FwdNo,int ShowNo,bool_t Drop)
  2699. {
  2700. ahisurface* Back;
  2701. ahisurface* Fwd;
  2702. ahisurface* Dst;
  2704. if (!AHI(p)->IDCT)
  2705. return ERR_DEVICE_ERROR;
  2707. // we will try to avoid overwrite currently displayed buffers:
  2708. //   ShowCurr currently displayed
  2709. //   ShowLast may be still on screen (because flip occurs only during vblank)
  2711. DEBUG_MSG6(DEBUG_VIDEO,T("ATI FrameStart %d,%d,%d (%d,%d,%d)"),DstNo,BackNo,FwdNo,ShowNo,AHI(p)->ShowCurr,AHI(p)->ShowLast);
  2713. if (!AHI(p)->Buf[SCALE] && (AHI(p)->ShowLast == DstNo || AHI(p)->ShowCurr == DstNo))
  2714. {
  2715. // try to find a free buffer
  2716. int SwapNo;
  2717. for (SwapNo=0;SwapNo<AHI(p)->AllCount;++SwapNo)
  2718. if (SwapNo != AHI(p)->ShowLast && SwapNo != AHI(p)->ShowCurr && 
  2719. SwapNo != BackNo && SwapNo != FwdNo && SwapNo != ShowNo)
  2720. break; 
  2722. if (SwapNo < AHI(p)->AllCount || UpdateOverlay(AHI(p),AHI(p)->BufCount,AHI(p)->TempCount+1))
  2723. {
  2724. // use free buffer
  2725. SwapPtr(AHI(p),SwapNo,DstNo,1);
  2727. DEBUG_MSG2(DEBUG_VIDEO,T("ATI Swap %d,%d"),DstNo,SwapNo);
  2728. }
  2729. else
  2730. if (AHI(p)->ShowLast >= 0 && AHI(p)->ShowCurr != AHI(p)->ShowLast &&
  2731. AHI(p)->ShowLast != BackNo && AHI(p)->ShowLast != FwdNo) 
  2732. {
  2733. // no free buffer found and couldn't allocate new temp buffer
  2734. // so we wait for vblank and use ShowLast
  2735. if (!Drop)
  2736. AHI(p)->AhiDispWaitVBlank(AHI(p)->Context,0);
  2738. DEBUG_MSG2(DEBUG_VIDEO,T("ATI VBlank %d,%d"),DstNo,AHI(p)->ShowLast);
  2740. if (DstNo != AHI(p)->ShowLast)
  2741. SwapPtr(AHI(p),AHI(p)->ShowLast,DstNo,1);
  2742. }
  2743. }
  2745. AHI(p)->ShowNext = ShowNo;
  2746. AHI(p)->ShowNextIdle = ShowNo == DstNo;
  2748. if (OldFrameNo)
  2749. *OldFrameNo = AHI(p)->BufFrameNo[DstNo];
  2750. AHI(p)->BufFrameNo[DstNo] = FrameNo;
  2752. Back = NULL;
  2753. Fwd = NULL;
  2754. Dst = AHI(p)->Buf[DstNo];
  2755. if (BackNo >= 0)
  2756. Back = AHI(p)->Buf[BackNo];
  2757. if (FwdNo >= 0)
  2758. Fwd = AHI(p)->Buf[FwdNo];
  2760. AHI(p)->MacroWidth = AHI(p)->Overlay.Width >> 4;
  2761. AHI(p)->AhiIDCTFrameStart(AHI(p)->IDCT,Dst,Back,Fwd,AHI(p)->FrameNo,0);
  2763. return ERR_NONE;
  2764. }
  2766. static void IDCTFrameEnd(void* p)
  2767. {
  2768. AHI(p)->AhiIDCTFrameEnd(AHI(p)->IDCT,AHI(p)->FrameNo++);
  2769. }
  2771. static void IDCTDrop(void* p)
  2772. {
  2773. int No;
  2774. for (No=0;No<AHI(p)->AllCount;++No)
  2775. AHI(p)->BufFrameNo[No] = -1;
  2776. }
  2778. static int IDCTNull(void* p,const flowstate* State,bool_t Empty)
  2779. {
  2780. if (Empty)
  2781. ++AHI(p)->p.Total;
  2782. if (!State || State->DropLevel)
  2783. ++AHI(p)->p.Dropped;
  2784. return ERR_NONE;
  2785. }
  2787. static int IDCTSend(void* p,tick_t RefTime,const flowstate* State)
  2788. {
  2789. bool_t Flip = 0;
  2791. if (AHI(p)->ShowNext < 0)
  2792. return ERR_NEED_MORE_DATA;
  2794. if (State->CurrTime >= 0)
  2795. {
  2796. tick_t Diff;
  2798. if (!AHI(p)->p.Play && State->CurrTime == AHI(p)->p.LastTime)
  2799. return ERR_BUFFER_FULL;
  2801. Diff = RefTime - (State->CurrTime + SHOWAHEAD);
  2802. if (Diff >= 0)
  2803. {
  2804. if (!AHI(p)->Buf[SCALE+1] || Diff>(TICKSPERSEC*8/1000))
  2805. return ERR_BUFFER_FULL;
  2807. // we have time for scale flipping
  2808. Flip = 1;
  2809. }
  2811. AHI(p)->p.LastTime = State->CurrTime;
  2812. }
  2813. else
  2814. AHI(p)->p.LastTime = RefTime;
  2816. if (State->CurrTime != TIME_RESEND)
  2817. ++AHI(p)->p.Total;
  2819. AHI(p)->ShowLast = AHI(p)->ShowCurr;
  2820. AHI(p)->ShowCurr = AHI(p)->ShowNext;
  2822. if (AHI(p)->Buf[SCALE])
  2823. {
  2824. if (State->DropLevel)
  2825. ++AHI(p)->p.Dropped;
  2826. else
  2827. Stretch(AHI(p),1,Flip);
  2828. }
  2829. else
  2830. UpdateOverlaySurf(AHI(p),AHI(p)->ShowNextIdle);
  2832. return ERR_NONE;
  2833. }
  2835. static int Create(ahi* p);
  2836. static void Delete(ahi* p);
  2838. static const nodedef AHI =
  2839. {
  2840. sizeof(ahi)|CF_GLOBAL|CF_SETTINGS,
  2841. AHI_ID,
  2842. OVERLAY_CLASS,
  2843. PRI_DEFAULT+200,
  2844. (nodecreate)Create,
  2845. (nodedelete)Delete,
  2846. };
  2848. static const nodedef AHI_IDCT =
  2849. {
  2850. CF_ABSTRACT,
  2851. AHI_IDCT_ID,
  2852. IDCT_CLASS,
  2853. PRI_DEFAULT+50,
  2854. };
  2856. static void FindUnmap(ahi* p)
  2857. {
  2858. uint8_t* Min;
  2859. uint8_t* Max;
  2860. uint32_t* q;
  2861. bool_t Found = 0;
  2862. int i;
  2864. CodeFindPages((void*)(int)p->AhiInit,&Min,&Max,NULL);
  2866. if (Min && Max>Min)
  2867. {
  2868. Max -= 8*4;
  2869. for (q=(uint32_t*)Min;q<(uint32_t*)Max;++q)
  2870. if (q[0] == 0xE3A06A06) //mov r6,#0x6000
  2871. {
  2872. for (i=1;i<8;++i)
  2873. if (q[i] == 0xE3866002) // or r6,r6,#2
  2874. {
  2875. for (i=-1;i>-16;--i)
  2876. if ((q[i] & 0xFFFF0000)==0xE92D0000)
  2877. {
  2878. if (Found)
  2879. p->AhiUnmap = NULL;
  2880. else
  2881. {
  2882. p->AhiUnmap = (int(*)())(q+i);
  2883. Found = 1;
  2884. }
  2885. break;
  2886. }
  2887. break;
  2888. }
  2889. }
  2890. }
  2891. }
  2893. static int Create(ahi* p) 
  2894. { 
  2895. p->Context = NULL;
  2897. p->p.Node.Enum = (nodeenum)Enum;
  2898. p->p.Node.Get = (nodeget)Get;
  2899. p->p.Node.Set = (nodeset)Set;
  2900. p->p.Init = (ovlfunc)Init;
  2901. p->p.Done = (ovldone)Done;
  2902. p->p.Reset = (ovlfunc)Reset;
  2904. p->IdctVMT.Class = AHI_IDCT_ID;
  2905. p->IdctVMT.Enum = IDCTEnumAHI;
  2906. p->IdctVMT.Get = IDCTGet;
  2907. p->IdctVMT.Set = IDCTSet;
  2908. p->IdctVMT.Send = IDCTSend;
  2909. p->IdctVMT.Null = IDCTNull;
  2910. p->IdctVMT.Drop = IDCTDrop;
  2911. p->IdctVMT.Lock = IDCTLock;
  2912. p->IdctVMT.Unlock = IDCTUnlock;
  2913. p->IdctVMT.FrameStart = IDCTFrameStart;
  2914. p->IdctVMT.FrameEnd = IDCTFrameEnd;
  2916. p->IDCTOutput.Node = (node*)p;
  2917. p->IDCTOutput.No = OUT_INPUT;
  2918. p->IDCTBug = 0;
  2919. p->IDCTInit = 0;
  2920. p->AllowStretchFlip = 1;
  2921. p->AllowPrimaryReUse = 1;
  2922. p->AllowLowBitdepth = 1;
  2924. p->p.Module = LoadLibrary(T("ACE_DDI.DLL"));
  2925. GetProc(&p->p.Module,&p->AhiInit,T("AhiInit"),0);
  2926. GetProc(&p->p.Module,&p->AhiTerm,T("AhiTerm"),0);
  2928. GetProc(&p->p.Module,&p->AhiDevEnum,T("AhiDevEnum"),0);
  2929. GetProc(&p->p.Module,&p->AhiDevOpen,T("AhiDevOpen"),0);
  2930. GetProc(&p->p.Module,&p->AhiDevClose,T("AhiDevClose"),0);
  2931. GetProc(&p->p.Module,&p->AhiDevClientVersion,T("AhiDevClientVersion"),0);
  2933. GetProc(&p->p.Module,&p->AhiDispModeGet,T("AhiDispModeGet"),0);
  2934. GetProc(&p->p.Module,&p->AhiDispModeEnum,T("AhiDispModeEnum"),0);
  2935. GetProc(&p->p.Module,&p->AhiDispSurfGet,T("AhiDispSurfGet"),0);
  2937. GetProc(&p->p.Module,&p->AhiSurfGetLargestFreeBlockSize,T("AhiSurfGetLargestFreeBlockSize"),1);
  2938. GetProc(&p->p.Module,&p->AhiSurfAlloc,T("AhiSurfAlloc"),0);
  2939. GetProc(&p->p.Module,&p->AhiSurfReuse,T("AhiSurfReuse"),0);
  2940. GetProc(&p->p.Module,&p->AhiSurfFree,T("AhiSurfFree"),0);
  2941. GetProc(&p->p.Module,&p->AhiSurfLock,T("AhiSurfLock"),0);
  2942. GetProc(&p->p.Module,&p->AhiSurfUnlock,T("AhiSurfUnlock"),0);
  2943. GetProc(&p->p.Module,&p->AhiSurfInfo,T("AhiSurfInfo"),0);
  2944. GetProc(&p->p.Module,&p->AhiSurfPlaneInfo,T("AhiSurfPlaneInfo"),0);
  2946. GetProc(&p->p.Module,&p->AhiDrawRopSet,T("AhiDrawRopSet"),0);
  2947. GetProc(&p->p.Module,&p->AhiDrawSurfSrcSet,T("AhiDrawSurfSrcSet"),0);
  2948. GetProc(&p->p.Module,&p->AhiDrawSurfDstSet,T("AhiDrawSurfDstSet"),0);
  2949. GetProc(&p->p.Module,&p->AhiDrawIdle,T("AhiDrawIdle"),0);
  2950. GetProc(&p->p.Module,&p->AhiDispWaitVBlank,T("AhiDispWaitVBlank"),0);
  2951. GetProc(&p->p.Module,&p->AhiDrawBitBlt,T("AhiDrawBitBlt"),0);
  2952. GetProc(&p->p.Module,&p->AhiDrawStretchBlt,T("AhiDrawStretchBlt"),0);
  2953. GetProc(&p->p.Module,&p->AhiDrawRotateBlt,T("AhiDrawRotateBlt"),0);
  2955. GetProc(&p->p.Module,&p->AhiDispOverlayCaps,T("AhiDispOverlayCaps"),0);
  2956. GetProc(&p->p.Module,&p->AhiDispOverlayState,T("AhiDispOverlayState"),0);
  2957. GetProc(&p->p.Module,&p->AhiDispOverlayPos,T("AhiDispOverlayPos"),0);
  2958. GetProc(&p->p.Module,&p->AhiDispOverlaySurf,T("AhiDispOverlaySurf"),0);
  2960. GetProc(&p->p.Module,&p->AhiIDCTOpen,T("AhiIDCTOpen"),0);
  2961. GetProc(&p->p.Module,&p->AhiIDCTClose,T("AhiIDCTClose"),0);
  2962. GetProc(&p->p.Module,&p->AhiIDCTPropGet,T("AhiIDCTPropGet"),0);
  2963. GetProc(&p->p.Module,&p->AhiIDCTPropSet,T("AhiIDCTPropSet"),0);
  2964. GetProc(&p->p.Module,&p->AhiIDCTFrameStart,T("AhiIDCTFrameStart"),0);
  2965. GetProc(&p->p.Module,&p->AhiIDCTFrameEnd,T("AhiIDCTFrameEnd"),0);
  2966. GetProc(&p->p.Module,&p->AhiIDCTMComp8x8,T("AhiIDCTMComp8x8"),0);
  2967. GetProc(&p->p.Module,&p->AhiIDCTMComp,T("AhiIDCTMComp"),0);
  2968. GetProc(&p->p.Module,&p->AhiIDCT8x8,T("AhiIDCT8x8"),0);
  2970. if (!p->p.Module)
  2971. return ERR_NOT_SUPPORTED;
  2973. FindUnmap(p);
  2975. memset(&p->DevInfo,0,sizeof(p->DevInfo));
  2977. if (SafeAhiInit(p))
  2978. {
  2979. int No;
  2980. for (No=0;No<16;No++)
  2981. {
  2982. int Result = p->AhiDevEnum(&p->Device,&p->DevInfo,No);
  2983. if (Result == SUCCESS)
  2984. {
  2985. if (p->DevInfo.ChipId == 0x57441002)
  2986. p->IDCTBug = 1;
  2987. if (p->DevInfo.ExternalMemSize>0 && CheckVersion(p,1))
  2988. {
  2989. p->p.AccelIDCT = &p->IdctVMT;
  2990. NodeRegisterClass(&AHI_IDCT);
  2991. }
  2992. break;
  2993. }
  2994. if (Result == ENDENUM)
  2995. break;
  2996. }
  2998. p->TmpInited = 1; // assume NoRelease, later loading settings will call AhiTerm if needed
  2999. //SafeAhiTerm(p);
  3000. }
  3002. p->p.DoPowerOff = 1;
  3004. Context()->HwOrientation = Orientation;
  3005. Context()->HwOrientationContext = p;
  3006. return ERR_NONE;
  3007. }
  3009. static void Delete(ahi* p)
  3010. {
  3011. Context()->HwOrientation = NULL;
  3012. Context()->HwOrientationContext = NULL;
  3013. if (p->TmpInited)
  3014. {
  3015. p->TmpInited = 0;
  3016. p->AhiTerm();
  3017. // no unmap... maybe unmap casing problem too...
  3018. }
  3019. }
  3021. void ATI3200_Init()
  3022. {
  3023. NodeRegisterClass(&AHI);
  3024. }
  3026. void ATI3200_Done()
  3027. {
  3028. NodeUnRegisterClass(AHI_ID);
  3029. NodeUnRegisterClass(AHI_IDCT_ID);
  3030. }
  3032. #else
  3033. void ATI3200_Init() {}
  3034. void ATI3200_Done() {}
  3035. #endif