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

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

Windows CE

开发平台：

C/C++

ati4200.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: ati4200.c 545 2006-01-07 22:26:35Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  26. #if defined(TARGET_PALMOS)
  28. #if defined(_M_IX86)
  29. //#define ATIEMU
  30. #endif
  32. #if _MSC_VER > 1000
  33. #pragma warning(disable : 4127)
  34. #endif
  36. #include "../common/palmos/pace.h"
  38. #define ATI4200_ID FOURCC('A','T','I','4')
  39. #define ATI4200_IDCT_ID VOUT_IDCT_CLASS(ATI4200_ID)
  41. #define DCFACTOR 8
  43. #define RING_NOP2 0
  44. #define RING_NOP3 ((1|0x80000)<<11)
  46. #define BUFFER_COUNT 3
  47. #define ALL_COUNT 5
  48. #define SCALE_COUNT 3
  50. #define REG_BASE 0x010000
  51. #define INT_BASE 0x100000
  52. #define EXT_BASE 0x800000
  54. #define PWRMGT_CNTL (0x0098/4)
  55. #define GRAPHIC_CTRL        (0x0414/4)
  56. #define GRAPHIC_OFFSET      (0x0418/4)
  57. #define GRAPHIC_PITCH       (0x041C/4)
  58. #define GRAPHIC_H_DISP      (0x042C/4)
  59. #define GRAPHIC_V_DISP      (0x0430/4)
  60. #define GEN_STATUS (0x054C/4)
  61. #define ACTIVE_H_DISP (0x0424/4)
  62. #define ACTIVE_V_DISP (0x0428/4)
  63. #define DISP_BUF (0x04D8/4)
  64. #define DISP_DEBUG (0x04D4/4)
  65. #define DISP_DEBUG2 (0x0538/4)
  66. #define VIDEO_CTRL (0x0434/4)
  67. #define VIDEO_Y_OFFSET (0x043C/4)
  68. #define VIDEO_Y_PITCH (0x0440/4)
  69. #define VIDEO_U_OFFSET (0x0444/4)
  70. #define VIDEO_U_PITCH (0x0448/4)
  71. #define VIDEO_V_OFFSET (0x044C/4)
  72. #define VIDEO_V_PITCH (0x0450/4)
  73. #define VIDEO_H_POS (0x0454/4)
  74. #define VIDEO_V_POS (0x0458/4)
  76. #define RING_CNTL (0x0210/4)
  77. #define RING_BASE (0x0214/4)
  78. #define RING_RPTR_ADDR (0x0218/4)
  79. #define RING_RPTR (0x021C/4)
  80. #define RING_RPTR_WR (0x02F8/4)
  81. #define RING_WPTR (0x0220/4)
  82. #define RBBM_STATUS (0x0140/4)
  83. #define RBBM_CNTL (0x0144/4)
  85. #define REF1_PITCH_OFFSET (0x10B8/4)
  86. #define REF2_PITCH_OFFSET (0x10BC/4)
  87. #define REF3_PITCH_OFFSET (0x10C0/4)
  88. #define REF4_PITCH_OFFSET (0x10C4/4)
  89. #define REF5_PITCH_OFFSET (0x10C8/4)
  90. #define REF6_PITCH_OFFSET (0x10CC/4)
  91. #define SRC_SC_BOTTOM_RIGHT (0x11C4/4)
  92. #define IDCT_CONTROL        (0x0C3C/4)
  94. #define DP_GUI_MASTER_CNTL 0x41B 
  95. #define DP_CNTL 0x472 
  96. #define DP_MIX 0x4B2 
  97. #define DP_DATATYPE 0x4B1 
  98. #define SC_TOP_LEFT 0x46F 
  99. #define SC_BOTTOM_RIGHT 0x470 
  100. #define DST_OFFSET 0x401 
  101. #define DST_PITCH 0x402 
  102. #define SRC_OFFSET 0x46B 
  103. #define SRC_PITCH 0x46C 
  104. #define E2_ARITHMETIC_CNTL 0x488 
  106. #define SRC2_X_Y 0x416
  107. #define SRC2_OFFSET 0x418 
  108. #define SRC2_PITCH 0x419 
  109. #define SRC_WIDTH 0x410 
  110. #define SRC_HEIGHT 0x411 
  111. #define SRC_INC 0x412 
  112. #define SRC2_WIDTH 0x420 
  113. #define SRC2_HEIGHT 0x421 
  114. #define SRC2_INC 0x422 
  115. #define SRC_X_Y 0x464 
  116. #define DST_X_Y 0x465 
  117. #define DST_WIDTH_HEIGHT 0x466 
  119. typedef struct atisurf
  120. {
  121. planes Planes;
  122. int YOffset;
  123. int YPitch;
  124. int UOffset;
  125. int UPitch;
  126. int VOffset;
  127. int VPitch;
  129. } atisurf;
  131. typedef struct idct_atidata
  132. {
  133. int8_t skip3,skip2,skip1,skip0;
  134. int16_t data1,data0,data3,data2;
  136. } idct_atidata;
  138. typedef struct idct_ati
  139. {
  140. union
  141. {
  142. idct_atidata d;
  143. int32_t v[3];
  144. };
  146. } idct_ati;
  148. #define BACKUP_LEN 16
  150. static const int BackupRegs[BACKUP_LEN] = 
  151. {
  152. DP_GUI_MASTER_CNTL,
  153. DP_CNTL,
  154. DP_MIX,
  155. DP_DATATYPE,
  156. DST_OFFSET,
  157. DST_PITCH,
  158. SRC_OFFSET,
  159. SRC_PITCH,
  160. E2_ARITHMETIC_CNTL,
  161. IDCT_CONTROL,
  162. REF1_PITCH_OFFSET,
  163. REF2_PITCH_OFFSET,
  164. REF3_PITCH_OFFSET,
  165. REF4_PITCH_OFFSET,
  166. REF5_PITCH_OFFSET,
  167. REF6_PITCH_OFFSET,
  168. };
  170. typedef struct ati4200
  171. {
  172. overlay p;
  173. idct IdctVMT;
  175. int RingMask;
  176. int RingPos;
  177. int RingPos0;
  178. int RingRdPos;
  179. volatile int* Ring;
  181. int DCAdd;
  182. int SubNo;
  183. int MacroPos;
  184. int MacroCoord;
  185. int LastMode;
  186. int LastScanType;
  187. int ArithMode;
  188. int InterIDCT;
  189. int MVBack;
  190. int32_t MVBackTab[6];
  191. int MVFwd;
  192. int32_t MVFwdTab[6];
  193. atisurf* Dst;
  195. int AllCount;
  196. int BufCount;
  197. int ShowLast;
  198. int ShowCurr;
  199. int ShowNext;
  200. int IDCTWidth;
  201. int IDCTHeight;
  202. pin IDCTOutput;
  203. bool_t Rounding;
  204. bool_t IDCT;
  205. bool_t IDCTInit;
  207. int SaveScanType;
  208. int SavePos;
  209. int SaveData[64]; //data:16*3+close:1
  211. int BufferEnd;
  212. atisurf Buffer[ALL_COUNT];
  213. atisurf Scale[SCALE_COUNT];
  214. rect OverlayRect;
  215. video Overlay;
  216. blitfx SoftFX;
  217. point Offset;
  218. bool_t LowBitdepth;
  219. int Memory;
  220. uint8_t* Device;
  221. volatile int* Regs;
  222. int ShowScale;
  223. int Mirror;
  225. int BufFrameNo[MAXIDCTBUF];
  226. int Backup[BACKUP_LEN];
  228. } ati4200;
  230. extern char* QueryScreen(video* Video,int* Offset,int* Mode);
  232. static bool_t Idle(ati4200* p)
  233. {
  234. if (p->Regs[RING_RPTR] != p->Regs[RING_WPTR])
  235. return 0;
  237. if (p->Regs[RBBM_STATUS] & 0x80000000)
  238. return 0;
  240. return 1;
  241. }
  243. static NOINLINE bool_t Wait(ati4200* p)
  244. {
  245. int n;
  246. for (n=0;n<100000;++n)
  247. {
  248. if (Idle(p))
  249. return 1;
  250. HALDelay(50);
  251. }
  252. return 0;
  253. }
  255. static INLINE void RingPush(ati4200* p, int Value)
  256. {
  257. p->Ring[p->RingPos] = Value;
  258. p->RingPos = (p->RingPos+1) & p->RingMask;
  259. }
  261. static NOINLINE void RingReg(ati4200* p, int Reg, int Value)
  262. {
  263. RingPush(p,Reg);
  264. RingPush(p,Value);
  265. }
  267. static INLINE void RingNOP2(ati4200* p)
  268. {
  269. p->Ring[p->RingPos] = RING_NOP2;
  270. p->RingPos = (p->RingPos+2) & p->RingMask;
  271. }
  273. static INLINE void RingNOP3(ati4200* p)
  274. {
  275. p->Ring[p->RingPos] = RING_NOP3;
  276. p->RingPos = (p->RingPos+3) & p->RingMask;
  277. }
  279. static NOINLINE void RingPrepair(ati4200* p, int Len)
  280. {
  281. if (((p->RingRdPos - p->RingPos - 1) & p->RingMask) < Len)
  282. {
  283. p->RingRdPos = p->Regs[RING_RPTR];
  285. while (((p->RingRdPos - p->RingPos - 1) & p->RingMask) < Len)
  286. {
  287. HALDelay(50);
  288. p->RingRdPos = p->Regs[RING_RPTR];
  289. }
  290. }
  291. }
  293. static INLINE void RingFlush(ati4200* p)
  294. {
  295. p->Regs[RING_WPTR] = p->RingPos;
  297. #ifdef ATIEMU
  298. if (p->Regs[RING_RPTR] != p->RingPos)
  299. {
  300. if (p->Ring[p->Regs[RING_RPTR]] == RING_NOP3 ||
  301. p->Ring[p->Regs[RING_RPTR]] == RING_NOP2)
  302. p->Regs[RING_RPTR] = p->RingPos;
  303. else
  304. {
  305. //DebugMessage("ATI Command");
  306. while (p->Regs[RING_RPTR] != p->RingPos)
  307. {
  308. //DebugMessage("ATI %08x",p->Ring[p->Regs[RING_RPTR]]);
  309. p->Regs[RING_RPTR] = (p->Regs[RING_RPTR] + 1) & p->RingMask;
  310. }
  311. }
  312. }
  313. #endif
  314. }
  316. static NOINLINE void RingFill(ati4200* p,int TargetPos)
  317. {
  318. int n = (TargetPos - p->RingPos) & p->RingMask;
  319. if (n)
  320. {
  321. if (n==1)
  322. n += p->RingMask+1; // bad luck
  324. while (n>1024*3+4)
  325. {
  326. int i;
  327. RingPrepair(p,1024*3);
  328. for (i=0;i<1024;++i)
  329. RingNOP3(p);
  330. RingFlush(p);
  331. n -= 1024*3;
  332. }
  334. RingPrepair(p,n);
  335. for (;n>4;n-=3) 
  336. RingNOP3(p);
  337. switch (n)
  338. {
  339. case 4: RingNOP2(p); //no break
  340. case 2: RingNOP2(p); break;
  341. case 3: RingNOP3(p); break;
  342. }
  343. RingFlush(p);
  344. }
  346. assert(p->RingPos == TargetPos);
  347. }
  349. static void RingBegin(ati4200* p,bool_t Small)
  350. {
  351. int v;
  352. p->RingRdPos = p->Regs[RING_RPTR];
  353. p->RingPos = p->Regs[RING_WPTR] & p->RingMask;
  354. v = p->RingPos == p->RingPos0 ? p->Ring[p->RingPos] : -1;
  355. p->RingPos0 = p->RingPos;
  357. if (v != RING_NOP3 && v != RING_NOP2)
  358. {
  359. // have to wait before doing the register backup
  360. int n;
  361. Wait(p); 
  362. for (n=0;n<BACKUP_LEN;++n) 
  363. p->Backup[n] = p->Regs[BackupRegs[n]];
  364. }
  366. if (Small)
  367. {
  368. int SmallPos = (p->RingPos - 256) & p->RingMask;
  370. if (v != RING_NOP3)
  371. RingFill(p,SmallPos);
  372. else
  373. {
  374. // assuming ring is already filled
  375. p->RingPos = SmallPos; 
  376. RingFlush(p);
  377. }
  378. }
  379. }
  381. static void RingEnd(ati4200* p)
  382. {
  383. int n;
  385. // restore backup registers
  386. RingPrepair(p,2*BACKUP_LEN+2*2);
  387. RingReg(p,SC_TOP_LEFT,0);
  388. RingReg(p,SC_BOTTOM_RIGHT,0x1FFF1FFF);
  389. RingReg(p,SRC_SC_BOTTOM_RIGHT,0x1FFF1FFF);
  391. for (n=0;n<BACKUP_LEN;++n) 
  392. RingReg(p,BackupRegs[n],p->Backup[n]);
  393. RingFlush(p);
  395. // restore ring write position
  396. RingFill(p,p->RingPos0); 
  398. // let some free space for the OS driver
  399. RingPrepair(p,p->RingMask >> 1); 
  401. // signal for next iteration that no backup required
  402. if (p->Ring[p->RingPos0] != RING_NOP3)
  403. p->Ring[p->RingPos0] = RING_NOP2; 
  404. }
  406. static void AllocBuffer(ati4200* p,atisurf* s,int w,int h,int* Offset)
  407. {
  408. int ofs = *Offset;
  409. int size;
  410. w = ALIGN16(w);
  411. h = ALIGN16(h);
  412. size = w*h;
  414. s->YOffset = ofs;
  415. ofs += size;
  416. s->YPitch = w;
  417. s->UOffset = ofs;
  418. ofs += size/4;
  419. s->UPitch = w/2;
  420. s->VOffset = ofs;
  421. ofs += size/4;
  422. s->VPitch = w/2;
  424. s->Planes[0] = p->Device + s->YOffset;
  425. s->Planes[1] = p->Device + s->UOffset;
  426. s->Planes[2] = p->Device + s->VOffset;
  428. memset(s->Planes[0],0,size);
  429. memset(s->Planes[1],128,size/4);
  430. memset(s->Planes[2],128,size/4);
  432. *Offset = ofs;
  433. }
  435. static void BeginUpdate(ati4200* p)
  436. {
  437. p->Regs[DISP_BUF] = 0x78;
  438. }
  440. static void EndUpdate(ati4200* p)
  441. {
  442. p->Regs[DISP_BUF] = 0x7B;
  443. }
  445. static void SetLowBitdepth(ati4200* p,bool_t Value)
  446. {
  447. /* if (p->LowBitdepth != Value)
  448. {
  449. int Ctrl;
  451. p->LowBitdepth = Value;
  453. //if (Value)
  454. // ClearPrimary(p);
  456. while ((p->Regs[GEN_STATUS] & 0x400)==0); // wait until not in vblank 
  457. while ((p->Regs[GEN_STATUS] & 0x400)!=0); // wait until in vblank
  459. Ctrl = p->Regs[GRAPHIC_CTRL];
  460. Ctrl &= ~7;
  461. Ctrl |= Value ? 2:6;
  462. p->Regs[GRAPHIC_CTRL] = Ctrl;
  463. }
  464. */
  465. }
  467. static void UpdateLowBitdepth(ati4200* p)
  468. {
  469. SetLowBitdepth(p,p->p.Show && p->p.FullScreenViewport);
  470. }
  472. static int Hide(ati4200* p)
  473. {
  474. SetLowBitdepth(p,0);
  475. BeginUpdate(p);
  476. p->Regs[VIDEO_CTRL] &= ~0x1C;
  477. EndUpdate(p);
  478. #ifndef ATIEMU
  479. while (p->Regs[DISP_BUF] & 2);
  480. #endif
  481. p->Regs[PWRMGT_CNTL] |= 1;
  482. return ERR_NONE;
  483. }
  485. static int Show(ati4200* p)
  486. {
  487. UpdateLowBitdepth(p);
  488. BeginUpdate(p);
  489. p->Regs[VIDEO_CTRL] |= 0x14;
  490. p->Regs[PWRMGT_CNTL] &= ~1;
  491. EndUpdate(p);
  492. return ERR_NONE;
  493. }
  495. static uint8_t* GetBits()
  496. {
  497. BitmapType* Bitmap;
  498. WinHandle Win = WinGetDisplayWindow();
  499. if (!Win)
  500. return NULL;
  502. Bitmap = WinGetBitmap(Win);
  503. if (!Bitmap)
  504. return NULL;
  506. return BmpGetBits(Bitmap);
  507. }
  509. static int IDCTUpdateFunc(ati4200* p);
  511. static void GetMode(ati4200* p)
  512. {
  513. QueryDesktop(&p->p.Output.Format.Video);
  515. p->p.Output.Format.Video.Direction = GetOrientation() ^ (DIR_MIRRORUPDOWN | DIR_MIRRORLEFTRIGHT);
  517. if (p->p.Output.Format.Video.Direction & DIR_SWAPXY)
  518. {
  519. int Ofs = GetBits() - (p->Device+INT_BASE);
  520. int h;
  521. h = p->Regs[ACTIVE_V_DISP];
  522. h = ((h >> 16) & 0x3FF) - (h & 0x3FF);
  524. SwapInt(&p->p.Output.Format.Video.Width,&p->p.Output.Format.Video.Height);
  526. if (Ofs>=0 && Ofs<h*2)
  527. h -= Ofs>>1;
  529. p->Offset.y = h - p->p.Output.Format.Video.Height;
  530. }
  531. else
  532. p->Offset.y = 0;
  533. }
  535. static int Init(ati4200* p)
  536. {
  537. p->p.SetFX = BLITFX_AVOIDTEARING;
  538. p->p.Overlay = 1;
  540. p->IDCT = 0;
  541. p->ShowScale = -1;
  542. p->ShowCurr = 0;
  543. p->ShowNext = -1;
  544. p->ShowLast = -1;
  545. p->AllCount = 0;
  546. p->BufCount = 0;
  547. p->BufferEnd = 0;
  548. p->LowBitdepth = 0;
  550. if (p->IDCTInit)
  551. {
  552. if (!PlanarYUV420(&p->p.Input.Format.Video.Pixel))
  553. return ERR_NOT_SUPPORTED;
  555. RingBegin(p,1);
  556. RingPrepair(p,2);
  557. RingReg(p,0x30E,0);
  558. RingFlush(p);
  559. RingEnd(p);
  561. p->IDCT = 1;
  562. p->Rounding = 0;
  563. IDCTUpdateFunc(p);
  564. }
  566. GetMode(p);
  567. return ERR_NONE;
  568. }
  570. static void Done(ati4200* p)
  571. {
  572. Wait(p);
  573. Hide(p);
  575. p->IDCT = 0;
  576. p->BufferEnd = 0;
  577. p->AllCount = 0;
  578. }
  580. static int Reset(ati4200* p)
  581. {
  582. GetMode(p);
  583. return ERR_NONE;
  584. }
  586. static int UpdateShow(ati4200* p)
  587. {
  588. if (p->p.Show)
  589. Show(p);
  590. else
  591. Hide(p);
  592. return ERR_NONE;
  593. }
  595. static int MirrorOffset(ati4200* p,atisurf* s,int Plane)
  596. {
  597. int Ofs = 0;
  598. int Width = p->p.DstAlignedRect.Width;
  599. int Height = p->p.DstAlignedRect.Height;
  600. int Pitch = s->YPitch;
  601. int x = 0;
  602. int y = 0;
  604. if (p->ShowScale<0)
  605. {
  606. x = p->OverlayRect.x & ~7;
  607. y = p->OverlayRect.y;
  608. }
  610. if (Plane)
  611. {
  612. Pitch >>= 1;
  613. Width >>= 1;
  614. Height >>= 1;
  615. x >>= 1;
  616. y >>= 1;
  617. }
  619. Ofs += x;
  620. Ofs += y * Pitch;
  622. if (p->Mirror & DIR_MIRRORLEFTRIGHT)
  623. Ofs += Width-1;
  625. if (p->Mirror & DIR_MIRRORUPDOWN)
  626. Ofs += (Height-1)*Pitch;
  628. return Ofs;
  629. }
  631. static void SwapPtr(ati4200* p,int a,int b,int SwapShow)
  632. {
  633. atisurf t;
  635. memcpy(&t,p->Buffer+a,sizeof(atisurf));
  636. memcpy(p->Buffer+a,p->Buffer+b,sizeof(atisurf));
  637. memcpy(p->Buffer+b,&t,sizeof(atisurf));
  639. if (SwapShow)
  640. {
  641. SwapInt(&p->BufFrameNo[a],&p->BufFrameNo[b]);
  643. if (p->ShowNext == a)
  644. p->ShowNext = b;
  645. else
  646. if (p->ShowNext == b)
  647. p->ShowNext = a;
  649. if (p->ShowLast == a)
  650. p->ShowLast = b;
  651. else
  652. if (p->ShowLast == b)
  653. p->ShowLast = a;
  655. if (p->ShowCurr == a)
  656. p->ShowCurr = b;
  657. else
  658. if (p->ShowCurr == b)
  659. p->ShowCurr = a;
  660. }
  661. }
  663. static void Stretch(ati4200* p,bool_t Flip);
  665. static int Update(ati4200* p)
  666. {
  667. video OldOverlay;
  668. blitfx OvlFX = p->p.FX;
  669. rect BufferRect;
  670. int Total;
  671. int Ctrl,n,x0,y0,x1,y1;
  672. int Offset = p->Memory;
  673. atisurf* s; 
  675. Wait(p);
  676. Hide(p);
  678. memcpy(&OldOverlay,&p->Overlay,sizeof(OldOverlay));
  679. OvlFX.Direction = 0;
  680. p->Mirror = 0;
  682. p->SoftFX = p->p.FX;
  683. p->SoftFX.ScaleX = SCALE_ONE; // scale handled by hardware
  684. p->SoftFX.ScaleY = SCALE_ONE;
  685. p->SoftFX.Flags |= BLITFX_ENLARGEIFNEEDED;
  687. if (p->IDCT)
  688. {
  689. // use overlay mirroring, because hardware idct can only swapxy
  690. p->SoftFX.Direction &= DIR_SWAPXY;
  691. p->Mirror = p->p.FX.Direction & ~DIR_SWAPXY;
  692. p->AllCount = ALL_COUNT;
  693. }
  694. else
  695. p->AllCount = BUFFER_COUNT;
  697. //align to 100%
  698. if (OvlFX.ScaleX > SCALE_ONE-(SCALE_ONE/16) && OvlFX.ScaleX < SCALE_ONE+(SCALE_ONE/16) &&
  699. OvlFX.ScaleY > SCALE_ONE-(SCALE_ONE/16) && OvlFX.ScaleY < SCALE_ONE+(SCALE_ONE/16))
  700. {
  701. OvlFX.ScaleX = SCALE_ONE;
  702. OvlFX.ScaleY = SCALE_ONE;
  703. }
  705. if (p->SoftFX.Direction & DIR_SWAPXY)
  706. SwapInt(&OvlFX.ScaleX,&OvlFX.ScaleY);
  708. memset(&p->Overlay,0,sizeof(p->Overlay));
  709. p->Overlay.Pixel.Flags = PF_YUV420;
  710. p->Overlay.Width = ALIGN16(p->IDCT?p->IDCTWidth:p->p.Input.Format.Video.Width);
  711. p->Overlay.Height = ALIGN16(p->IDCT?p->IDCTHeight:p->p.Input.Format.Video.Height);
  712. p->Overlay.Direction = (p->p.FX.Direction ^ p->p.Input.Format.Video.Direction) & DIR_SWAPXY;
  713. if ((p->IDCT?p->Overlay.Direction:p->p.FX.Direction) & DIR_SWAPXY)
  714. SwapInt(&p->Overlay.Width,&p->Overlay.Height);
  715. p->Overlay.Pitch = p->Overlay.Width;
  717. VirtToPhy(NULL,&p->OverlayRect,&p->p.Input.Format.Video);
  718. if (p->p.FX.Direction & DIR_SWAPXY)
  719. SwapInt(&p->OverlayRect.Width,&p->OverlayRect.Height);
  721. if (p->IDCT)
  722. IDCTUpdateFunc(p);
  724. VirtToPhy(&p->p.Viewport,&p->p.DstAlignedRect,&p->p.Output.Format.Video);
  726. if (OvlFX.ScaleX != SCALE_ONE || OvlFX.ScaleY != SCALE_ONE)
  727. {
  728. // avoid bilinear scale overrun (shrink source)
  729. if (p->OverlayRect.Width>2) 
  730. {
  731. OvlFX.ScaleX = Scale(OvlFX.ScaleX,p->OverlayRect.Width,p->OverlayRect.Width-2);
  732. p->OverlayRect.Width -= 2;
  733. }
  734. if (p->OverlayRect.Height>2) 
  735. {
  736. OvlFX.ScaleY = Scale(OvlFX.ScaleY,p->OverlayRect.Height,p->OverlayRect.Height-2);
  737. p->OverlayRect.Height -= 2;
  738. }
  739. }
  741. AnyAlign(&p->p.DstAlignedRect, &p->OverlayRect, &OvlFX, 2, 1, SCALE_ONE>>1, SCALE_ONE*16);
  743. VirtToPhy(NULL,&p->p.SrcAlignedRect,&p->p.Input.Format.Video);
  745. BufferRect.x = p->OverlayRect.x & ~15;
  746. BufferRect.y = p->OverlayRect.y & ~15;
  747. BufferRect.Width = ALIGN16(p->OverlayRect.Width + (p->OverlayRect.x & 15));
  748. BufferRect.Height = ALIGN16(p->OverlayRect.Height + (p->OverlayRect.y & 15));
  750. BlitRelease(p->p.Soft);
  751. p->p.Soft = BlitCreate(&p->Overlay,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  752. BlitAlign(p->p.Soft,&BufferRect,&p->p.SrcAlignedRect);
  754. if (!p->IDCT)
  755. {
  756. // adjust Overlay size if not all part of the input is needed
  757. p->BufferEnd = 0;
  758. p->Overlay.Width = ALIGN16(BufferRect.Width);
  759. p->Overlay.Height = ALIGN16(BufferRect.Height);
  760. p->Overlay.Pitch = p->Overlay.Width;
  762. // adjust OverlayRect
  763. BufferRect.x = p->p.SrcAlignedRect.x;
  764. BufferRect.y = p->p.SrcAlignedRect.y;
  765. if (p->SoftFX.Direction & DIR_SWAPXY)
  766. SwapInt(&BufferRect.x,&BufferRect.y);
  767. p->OverlayRect.x -= BufferRect.x;
  768. p->OverlayRect.y -= BufferRect.y;
  769. ClipRectPhy(&p->OverlayRect,&p->Overlay);
  771. BufferRect.x = 0;
  772. BufferRect.y = 0;
  774. BlitRelease(p->p.Soft);
  775. p->p.Soft = BlitCreate(&p->Overlay,&p->p.Input.Format.Video,&p->SoftFX,&p->p.Caps);
  776. BlitAlign(p->p.Soft,&BufferRect,&p->p.SrcAlignedRect);
  777. }
  778. else
  779. {
  780. int DCAdd;
  782. p->p.Caps = VC_BRIGHTNESS;
  784. // swapxy changed?
  785. if (p->BufferEnd && ((OldOverlay.Direction ^ p->Overlay.Direction) & DIR_SWAPXY))
  786. {
  787. for (n=0;n<p->AllCount;++n)
  788. {
  789. p->Buffer[n].YPitch = p->Overlay.Pitch;
  790. p->Buffer[n].UPitch = p->Overlay.Pitch >> 1;
  791. p->Buffer[n].VPitch = p->Overlay.Pitch >> 1;
  792. }
  794. if (p->AllCount > p->BufCount)
  795. for (n=0;n<p->BufCount;++n)
  796. {
  797. SurfaceRotate(&OldOverlay,&p->Overlay,p->Buffer[n].Planes,
  798.               p->Buffer[p->BufCount].Planes,DIR_SWAPXY);
  799. SwapPtr(p,n,p->BufCount,0);
  800. }
  801. }
  803. // brightness changed?
  804. DCAdd = p->p.FX.Brightness * DCFACTOR;
  805. if (p->DCAdd != DCAdd)
  806. {
  807. int Delta = (DCAdd - p->DCAdd) / DCFACTOR;
  808. p->DCAdd = DCAdd;
  810. if (p->BufferEnd)
  811. for (n=0;n<p->BufCount;++n)
  812. {
  813. uint8_t* v = p->Buffer[n].Planes[0];
  814. uint8_t* ve = v + p->Overlay.Width * p->Overlay.Height;
  815. for (;v!=ve;v+=4)
  816. {
  817. int a = v[0] + Delta;
  818. int b = v[1] + Delta;
  819. int c = v[2] + Delta;
  820. int d = v[3] + Delta;
  821. if (a>255) a=255; else if (a<0) a=0;
  822. if (b>255) b=255; else if (b<0) b=0;
  823. if (c>255) c=255; else if (c<0) c=0;
  824. if (d>255) d=255; else if (d<0) d=0;
  825. *(uint32_t*)v = a | (b<<8) | (c<<16) | (d<<24);
  826. }
  827. }
  828. }
  829. }
  831. if (!p->BufferEnd)
  832. {
  833. for (n=0;n<p->AllCount;++n)
  834. {
  835. AllocBuffer(p,&p->Buffer[n],p->Overlay.Width,p->Overlay.Height,&Offset);
  836. p->BufFrameNo[n] = -1;
  837. }
  838. p->BufferEnd = Offset;
  839. }
  840. else
  841. Offset = p->BufferEnd;
  843. if (OvlFX.ScaleX != SCALE_ONE || OvlFX.ScaleY != SCALE_ONE)
  844. {
  845. for (n=0;n<SCALE_COUNT;++n)
  846. AllocBuffer(p,&p->Scale[n],p->p.DstAlignedRect.Width,p->p.DstAlignedRect.Height,&Offset);
  847. p->ShowScale = 0;
  848. Stretch(p,0);
  849. s = p->Scale + p->ShowScale;
  850. }
  851. else
  852. {
  853. // no scaling -> adjust dst rectangle with soft yuv blitting alignement
  854. memset(p->Scale,0,sizeof(p->Scale));
  855. p->ShowScale = -1;
  857. p->p.DstAlignedRect.x += (p->p.DstAlignedRect.Width - p->OverlayRect.Width) >> 1;
  858. p->p.DstAlignedRect.y += (p->p.DstAlignedRect.Height - p->OverlayRect.Height) >> 1;
  859. p->p.DstAlignedRect.Width = p->OverlayRect.Width;
  860. p->p.DstAlignedRect.Height = p->OverlayRect.Height;
  861. s = p->Buffer + p->ShowCurr;
  862. }
  864. PhyToVirt(&p->p.DstAlignedRect,&p->p.GUIAlignedRect,&p->p.Output.Format.Video);
  866. BeginUpdate(p);
  867. p->Regs[DISP_DEBUG] &= ~0x1F0;
  869. Total = (p->p.DstAlignedRect.Width + 3) >> 2;
  870. Ctrl = 
  871. (1 << 0)| // yuv420 video mode
  872. ((Total & 511) << 9) |
  873. (1 << 22)| // yuv
  874. (1 << 23); // yuv option
  876. if (p->Mirror & DIR_MIRRORLEFTRIGHT)
  877. Ctrl |= 1 << 24;
  879. if (p->Mirror & DIR_MIRRORUPDOWN)
  880. Ctrl |= 1 << 25;
  882. p->Regs[VIDEO_CTRL] = Ctrl;
  884. x0 = p->Regs[ACTIVE_H_DISP] & 0x3FF;
  885. y0 = p->Regs[ACTIVE_V_DISP] & 0x3FF;
  887. x0 += p->Offset.x;
  888. y0 += p->Offset.y;
  890. x0 += p->p.DstAlignedRect.x;
  891. y0 += p->p.DstAlignedRect.y;
  893. x1 = x0 + p->p.DstAlignedRect.Width;
  894. y1 = y0 + p->p.DstAlignedRect.Height;
  896. p->Regs[VIDEO_H_POS] = x0 | (x1 << 16);
  897. p->Regs[VIDEO_V_POS] = y0 | (y1 << 16);
  898. p->Regs[VIDEO_Y_OFFSET] = s->YOffset+MirrorOffset(p,s,0);
  899. p->Regs[VIDEO_Y_PITCH] = s->YPitch;
  900. p->Regs[VIDEO_U_OFFSET] = s->UOffset+MirrorOffset(p,s,1);
  901. p->Regs[VIDEO_U_PITCH] = s->UPitch;
  902. p->Regs[VIDEO_V_OFFSET] = s->VOffset+MirrorOffset(p,s,2);
  903. p->Regs[VIDEO_V_PITCH] = s->VPitch;
  904. p->Regs[DISP_DEBUG2] |= 0x40000000;
  906. EndUpdate(p);
  908. return UpdateShow(p);
  909. }
  911. static void StretchPlane(ati4200* p, int SrcOffset, int SrcPitch, rect* SrcRect, int DstOffset, int DstPitch, rect* DstRect)
  912. {
  913. int DWidth,DHeight;
  914. int RScaleX = min(0x1FF,max(0x10,(SrcRect->Width << 8) / DstRect->Width));
  915. int RScaleY = min(0x1FF,max(0x10,(SrcRect->Height << 8) / DstRect->Height));
  917. DWidth = ((SrcRect->Width << 8)+RScaleX-1) / RScaleX;
  918. DHeight = ((SrcRect->Height << 8)+RScaleY-1) / RScaleY;
  920. RingReg(p,DP_GUI_MASTER_CNTL, 0xD598B2DF);
  921. RingReg(p,DP_CNTL , 0x0000003F);
  922. RingReg(p,DP_MIX , 0x01CC1200);
  923. RingReg(p,DP_DATATYPE , 0x40037D02);
  924. RingReg(p,E2_ARITHMETIC_CNTL, 0x02020008);
  926. RingReg(p,SC_TOP_LEFT,(DstRect->x & 0xFFFF) | (DstRect->y << 16));
  927. RingReg(p,SC_BOTTOM_RIGHT,((DstRect->x + DstRect->Width) & 0xFFFF) | ((DstRect->y + DstRect->Height) << 16));
  928. RingReg(p,DST_OFFSET,DstOffset);
  929. RingReg(p,DST_PITCH,DstPitch);
  930. RingReg(p,SRC_OFFSET,SrcOffset);
  931. RingReg(p,SRC_PITCH,SrcPitch);
  933. RingReg(p,SRC2_OFFSET,SrcOffset);
  934. RingReg(p,SRC2_PITCH,SrcPitch);
  936. RingReg(p,SRC_WIDTH,DWidth+1);
  937. RingReg(p,SRC_HEIGHT,DHeight);
  938. RingReg(p,SRC_INC,(RScaleX & 0xFFFF) | (RScaleY << 16));
  940. RingReg(p,SRC2_WIDTH,DWidth+1);
  941. RingReg(p,SRC2_HEIGHT,DHeight);
  942. RingReg(p,SRC2_INC,(RScaleX & 0xFFFF) | (RScaleY << 16));
  944. RingReg(p,SRC_X_Y,((SrcRect->y*4) & 0xFFFF) + ((SrcRect->x*4) << 16));
  945. RingReg(p,SRC2_X_Y,((SrcRect->y*4 + 4) & 0xFFFF) + ((SrcRect->x*4) << 16));
  946. RingReg(p,DST_X_Y,(DstRect->y & 0xFFFF) | (DstRect->x << 16));
  947. RingReg(p,DST_WIDTH_HEIGHT,(DHeight & 0xFFFF) | (DWidth << 16));
  948. }
  950. static void Stretch(ati4200* p,bool_t Flip)
  951. {
  952. rect SrcRect2;
  953. rect DstRect2;
  954. rect* SrcRect = &p->OverlayRect;
  955. rect DstRect;
  956. atisurf* Dst;
  957. atisurf* Src = p->Buffer+p->ShowCurr;
  959. if (++p->ShowScale >= SCALE_COUNT)
  960. p->ShowScale = 0;
  961. Dst = p->Scale + p->ShowScale;
  963. DstRect.x = 0;
  964. DstRect.y = 0;
  965. DstRect.Width = p->p.DstAlignedRect.Width;
  966. DstRect.Height = p->p.DstAlignedRect.Height;
  968. SrcRect2.x = SrcRect->x >> 1;
  969. SrcRect2.y = SrcRect->y >> 1;
  970. SrcRect2.Width = SrcRect->Width >> 1;
  971. SrcRect2.Height = SrcRect->Height >> 1;
  973. DstRect2.x = DstRect.x >> 1;
  974. DstRect2.y = DstRect.y >> 1;
  975. DstRect2.Width = DstRect.Width >> 1;
  976. DstRect2.Height = DstRect.Height >> 1;
  978. if (DstRect2.Width && DstRect2.Height)
  979. {
  980. bool_t PossibleBug = SrcRect2.Width*7 > DstRect2.Width*10;
  982. RingBegin(p,1);
  984. RingPrepair(p,128*2); // just an approx.
  986. StretchPlane(p,Src->UOffset,Src->UPitch,&SrcRect2,Dst->UOffset,Dst->UPitch,&DstRect2);
  987. if (PossibleBug)
  988. {
  989. RingFlush(p);
  990. Wait(p);
  991. }
  993. StretchPlane(p,Src->VOffset,Src->VPitch,&SrcRect2,Dst->VOffset,Dst->VPitch,&DstRect2);
  994. if (PossibleBug)
  995. {
  996. RingFlush(p);
  997. Wait(p);
  998. }
  1000. StretchPlane(p,Src->YOffset,Src->YPitch,SrcRect,Dst->YOffset,Dst->YPitch,&DstRect);
  1001. if ((p->Mirror & DIR_MIRRORUPDOWN) || !Flip)
  1002. {
  1003. RingFlush(p);
  1004. Wait(p);
  1005. }
  1007. if (Flip)
  1008. {
  1009. RingReg(p,DISP_BUF,0x78);
  1010. RingReg(p,VIDEO_Y_OFFSET,Dst->YOffset+MirrorOffset(p,Dst,0));
  1011. RingReg(p,VIDEO_Y_PITCH,Dst->YPitch);
  1012. RingReg(p,VIDEO_U_OFFSET,Dst->UOffset+MirrorOffset(p,Dst,1));
  1013. RingReg(p,VIDEO_U_PITCH,Dst->UPitch);
  1014. RingReg(p,VIDEO_V_OFFSET,Dst->VOffset+MirrorOffset(p,Dst,2));
  1015. RingReg(p,VIDEO_V_PITCH,Dst->VPitch);
  1016. RingReg(p,DISP_BUF,0x7B);
  1017. RingFlush(p);
  1018. }
  1020. RingEnd(p);
  1021. }
  1022. }
  1024. static void SetOverlay(ati4200* p)
  1025. {
  1026. atisurf* s = p->Buffer + p->ShowCurr;
  1027. BeginUpdate(p);
  1028. p->Regs[VIDEO_Y_OFFSET] = s->YOffset+MirrorOffset(p,s,0);
  1029. p->Regs[VIDEO_Y_PITCH] = s->YPitch;
  1030. p->Regs[VIDEO_U_OFFSET] = s->UOffset+MirrorOffset(p,s,1);
  1031. p->Regs[VIDEO_U_PITCH] = s->UPitch;
  1032. p->Regs[VIDEO_V_OFFSET] = s->VOffset+MirrorOffset(p,s,2);
  1033. p->Regs[VIDEO_V_PITCH] = s->VPitch;
  1034. EndUpdate(p);
  1035. }
  1037. static int Blit(ati4200* p, const constplanes Data, const constplanes DataLast )
  1038. {
  1039. if (++p->ShowCurr>=BUFFER_COUNT) 
  1040. p->ShowCurr=0; 
  1042. BlitImage(p->p.Soft,p->Buffer[p->ShowCurr].Planes,Data,DataLast,-1,-1);
  1044. if (p->ShowScale<0)
  1045. SetOverlay(p);
  1046. else
  1047. Stretch(p,1);
  1048. return ERR_NONE;
  1049. }
  1051. //---------------------------------------------------------------------------------------------
  1053. static const uint8_t ScanTable[3][64] = {
  1054. {
  1055.  0,  1,  8, 16,  9,  2,  3, 10, 
  1056. 17, 24, 32, 25, 18, 11,  4,  5,
  1057. 12, 19, 26, 33, 40, 48, 41, 34, 
  1058. 27, 20, 13,  6,  7, 14, 21, 28, 
  1059. 35, 42, 49, 56, 57, 50, 43, 36, 
  1060. 29, 22, 15, 23, 30, 37, 44, 51, 
  1061. 58, 59, 52, 45, 38, 31, 39, 46, 
  1062. 53, 60, 61, 54, 47, 55, 62, 63
  1063. },
  1064. {
  1065.    0,  1,  2,  3,  8,  9, 16, 17, 
  1066. 10, 11,  4,  5,  6,  7, 15, 14,
  1067. 13, 12, 19, 18, 24, 25, 32, 33, 
  1068. 26, 27, 20, 21, 22, 23, 28, 29,
  1069. 30, 31, 34, 35, 40, 41, 48, 49, 
  1070. 42, 43, 36, 37, 38, 39, 44, 45,
  1071. 46, 47, 50, 51, 56, 57, 58, 59, 
  1072. 52, 53, 54, 55, 60, 61, 62, 63
  1073. },
  1074. {
  1075.  0,  8, 16, 24,  1,  9,  2, 10, 
  1076. 17, 25, 32, 40, 48, 56, 57, 49,
  1077. 41, 33, 26, 18,  3, 11,  4, 12, 
  1078. 19, 27, 34, 42, 50, 58, 35, 43,
  1079. 51, 59, 20, 28,  5, 13,  6, 14, 
  1080. 21, 29, 36, 44, 52, 60, 37, 45,
  1081. 53, 61, 22, 30,  7, 15, 23, 31, 
  1082. 38, 46, 54, 62, 39, 47, 55, 63
  1083. }};
  1085. static const uint8_t ZigZagSwap[64] = {
  1086.  0,  8,  1,  2,  9, 16, 24, 17, 
  1087. 10,  3,  4, 11, 18, 25, 32, 40,
  1088. 33, 26, 19, 12,  5,  6, 13, 20, 
  1089. 27, 34, 41, 48, 56, 49, 42, 35, 
  1090. 28, 21, 14,  7, 15, 22, 29, 36, 
  1091. 43, 50, 57, 58, 51, 44, 37, 30, 
  1092. 23, 31, 38, 45, 52, 59, 60, 53, 
  1093. 46, 39, 47, 54, 61, 62, 55, 63
  1094. };
  1096. static const uint8_t ZigZagSwapLength[64] = {
  1097. 1,   3,  3,  6,  6,  6, 10, 10,
  1098. 10, 10, 15, 15, 15, 15, 15, 21, 
  1099. 21, 21, 21, 21, 21, 28, 28, 28,
  1100. 28, 28, 28, 28, 36, 36, 36, 36, 
  1101. 36, 36, 36, 36, 43, 43, 43, 43, 
  1102. 43, 43, 43, 49, 49, 49, 49, 49,
  1103. 49, 54, 54, 54, 54, 54, 58, 58, 
  1104. 58, 58, 61, 61, 61, 63, 63, 64
  1105. };
  1107. #define AHI(p) ((ati4200*)((char*)(p)-(int)&(((ati4200*)0)->IdctVMT)))
  1109. // input: Block, Length
  1110. #define AHIDCBLOCK(Offset)
  1111. {
  1112. if (Length < 1)
  1113. {
  1114. Block[0] = (idct_block_t)(Offset);
  1115. Length = 1;
  1116. }
  1117. else
  1118. Block[0] = (idct_block_t)(Block[0] + (Offset));
  1119. }
  1121. // ADJUST: don't care about MVFwd (only in b-frames which are not accumulated)
  1122. #define AHIMVADJBLOCK(SubNo)
  1123. if (AHI(p)->MVBack && (AHI(p)->MVBackTab[SubNo-1] & 0x00020002)==0x00020002)
  1124. AHIDCBLOCK(2);
  1126. #define AHIPUSH(v)
  1127. {
  1128. Dst[DstPos] = v;
  1129. DstPos = (DstPos+1) & DstMask;
  1130. }
  1132. // Block, Length, Scan, ScanEnd
  1133. #define AHIPACK(ScanType,Inter,SkipLabel,Backup)
  1134. ScanEnd = Scan + Length;
  1136. Last = Scan;
  1137. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  1138. if (Scan == ScanEnd)
  1139. {
  1140. if (!Backup && (!Inter || AHI(p)->InterIDCT))
  1141. AHIPUSH(0);
  1142. }
  1143. else
  1144. {
  1145. int v;
  1146. if (!Backup)
  1147. {
  1148. if (Inter && !AHI(p)->InterIDCT)
  1149. {
  1150. AHI(p)->InterIDCT = 1;
  1151. for (v=SubNo;v>1;--v)
  1152. AHIPUSH(0);
  1153. }
  1155. if (AHI(p)->LastScanType != ScanType)
  1156. {
  1157. AHI(p)->LastScanType = ScanType;
  1158. AHIPUSH(7);
  1159. v = ScanType?(ScanType==2 ? 0x10: 0x800):0;
  1160. AHIPUSH(v);
  1161. }
  1162. else
  1163. AHIPUSH(2);
  1164. }
  1166. LenPtr = Dst+DstPos;
  1167. DstPos = (DstPos+1) & DstMask;
  1169. for (Length=0;;)
  1170. {
  1171. Data.v[0] = -1;
  1173. v = *Scan;
  1174. Data.d.skip0 = (char)(Scan++ - Last);
  1175. Data.d.data0 = Block[v];
  1177. Last = Scan;
  1178. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  1179. if (Scan == ScanEnd) break;
  1180. v = *Scan;
  1181. Data.d.skip1 = (char)(Scan++ - Last);
  1182. Data.d.data1 = Block[v];
  1184. Last = Scan;
  1185. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  1186. if (Scan == ScanEnd) break;
  1187. v = *Scan;
  1188. Data.d.skip2 = (char)(Scan++ - Last);
  1189. Data.d.data2 = Block[v];
  1191. Last = Scan;
  1192. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  1193. if (Scan == ScanEnd) break;
  1194. v = *Scan;
  1195. Data.d.skip3 = (char)(Scan++ - Last);
  1196. Data.d.data3 = Block[v];
  1198. AHIPUSH(Data.v[0]);
  1199. AHIPUSH(Data.v[1]);
  1200. AHIPUSH(Data.v[2]);
  1201. ++Length;
  1203. Last = Scan;
  1204. while (Scan != ScanEnd && !Block[*Scan]) ++Scan;
  1205. if (Scan == ScanEnd)
  1206. {
  1207. AHIPUSH(0);
  1208. goto SkipLabel;
  1209. }
  1210. }
  1212. AHIPUSH(Data.v[0]);
  1213. AHIPUSH(Data.v[1]);
  1214. AHIPUSH(Data.v[2]);
  1215. ++Length;
  1217. SkipLabel:
  1218. *LenPtr = Length;
  1219. }
  1221. #define AHIPACKNORMAL(ScanType,Inter)
  1222. {
  1223. const unsigned char *Scan = ScanTable[ScanType];
  1224. const unsigned char *ScanEnd;
  1225. const unsigned char *Last;
  1226. int* Dst = (int*)AHI(p)->Ring;
  1227. int DstPos = AHI(p)->RingPos;
  1228. int DstMask = AHI(p)->RingMask;
  1229. int* LenPtr;
  1230. idct_ati Data;
  1231. AHIPACK(ScanType,Inter,SkipLabel,0)
  1232. AHI(p)->RingPos = DstPos;
  1233. }
  1235. #define AHIPACKSWAP(ScanType,Inter,SkipLabel,_Dst,_DstPos,_DstMask,Backup) 
  1236. {
  1237. const unsigned char *Scan;
  1238. const unsigned char *ScanEnd;
  1239. const unsigned char *Last;
  1240. int* LenPtr;
  1241. int* Dst = (int*)_Dst;
  1242. int DstPos = _DstPos;
  1243. int DstMask = _DstMask;
  1244. idct_ati Data;
  1245. if (ScanType == IDCTSCAN_ZIGZAG)
  1246. {
  1247. Scan = ZigZagSwap;
  1248. Length = ZigZagSwapLength[Length-1];
  1249. }
  1250. else
  1251. {
  1252. Scan = ScanTable[ScanType];
  1253. ScanType = 3 - ScanType;
  1254. }
  1255. AHIPACK(ScanType,Inter,SkipLabel,Backup)
  1256. _DstPos = DstPos;
  1257. }
  1259. #define AHIPACKSWAPZIGZAG(Inter,SkipLabel,_Dst,_DstPos,_DstMask,Backup)
  1260. {
  1261. const unsigned char *Scan;
  1262. const unsigned char *ScanEnd;
  1263. const unsigned char *Last;
  1264. int* LenPtr;
  1265. int* Dst = (int*)_Dst;
  1266. int DstPos = _DstPos;
  1267. int DstMask = _DstMask;
  1268. idct_ati Data;
  1269. Scan = ZigZagSwap;
  1270. Length = ZigZagSwapLength[Length-1];
  1271. AHIPACK(IDCTSCAN_ZIGZAG,Inter,SkipLabel,Backup)
  1272. _DstPos = DstPos;
  1273. }
  1275. #define AHIQPEL(MVPtr)
  1276. MV = *(MVPtr++);
  1277. MV <<= 1;
  1278. MV &= ~0x00010000;
  1280. #define AHIQPELSWAP(MVPtr)
  1281. MV = *(MVPtr++);
  1282. MV = (MV << 17) |
  1283.  ((uint32_t)MV >> 15);
  1284. MV &= ~0x00010001;
  1286. static void IDCTMComp(void* p,const int* MVBack,const int* MVFwd)
  1287. {
  1288. int32_t* Tab;
  1289. int MV;
  1291. AHI(p)->MVBack = 0;
  1292. AHI(p)->MVFwd = 0;
  1294. if (MVBack)
  1295. {
  1296. AHI(p)->MVBack = 1;
  1297. Tab = AHI(p)->MVBackTab;
  1298. AHIQPELSWAP(MVBack); Tab[0] = MV;
  1299. AHIQPELSWAP(MVBack); Tab[1] = MV;
  1300. AHIQPELSWAP(MVBack); Tab[2] = MV;
  1301. AHIQPELSWAP(MVBack); Tab[3] = MV;
  1302. AHIQPELSWAP(MVBack); Tab[4] = MV;
  1303. AHIQPELSWAP(MVBack); Tab[5] = MV;
  1304. }
  1306. if (MVFwd)
  1307. {
  1308. AHI(p)->MVFwd = 1;
  1309. Tab = AHI(p)->MVFwdTab;
  1310. AHIQPELSWAP(MVFwd); Tab[0] = MV;
  1311. AHIQPELSWAP(MVFwd); Tab[1] = MV;
  1312. AHIQPELSWAP(MVFwd); Tab[2] = MV;
  1313. AHIQPELSWAP(MVFwd); Tab[3] = MV;
  1314. AHIQPELSWAP(MVFwd); Tab[4] = MV;
  1315. AHIQPELSWAP(MVFwd); Tab[5] = MV;
  1316. }
  1317. }
  1319. static void IDCTMCompSwap(void* p,const int* MVBack,const int* MVFwd)
  1320. {
  1321. int32_t* Tab;
  1322. int MV;
  1324. AHI(p)->MVBack = 0;
  1325. AHI(p)->MVFwd = 0;
  1327. if (MVBack)
  1328. {
  1329. AHI(p)->MVBack = 1;
  1330. Tab = AHI(p)->MVBackTab;
  1331. AHIQPEL(MVBack); Tab[0] = MV;
  1332. AHIQPEL(MVBack); Tab[2] = MV;
  1333. AHIQPEL(MVBack); Tab[1] = MV;
  1334. AHIQPEL(MVBack); Tab[3] = MV;
  1335. AHIQPEL(MVBack); Tab[4] = MV;
  1336. AHIQPEL(MVBack); Tab[5] = MV;
  1337. }
  1339. if (MVFwd)
  1340. {
  1341. AHI(p)->MVFwd = 1;
  1342. Tab = AHI(p)->MVFwdTab;
  1343. AHIQPEL(MVFwd); Tab[0] = MV;
  1344. AHIQPEL(MVFwd); Tab[2] = MV;
  1345. AHIQPEL(MVFwd); Tab[1] = MV;
  1346. AHIQPEL(MVFwd); Tab[3] = MV;
  1347. AHIQPEL(MVFwd); Tab[4] = MV;
  1348. AHIQPEL(MVFwd); Tab[5] = MV;
  1349. }
  1350. }
  1352. static void IDCTProcess(void* p,int x,int y)
  1353. {
  1354. AHI(p)->SubNo = 0;
  1355. AHI(p)->MacroCoord = (y << 4) | (x << 20);
  1356. }
  1358. static void IDCTProcessSwap(void* p,int x,int y)
  1359. {
  1360. AHI(p)->SubNo = 0;
  1361. AHI(p)->MacroCoord = (x << 4) | (y << 20);
  1362. }
  1364. static NOINLINE void IDCTIntraStart(ati4200* p)
  1365. {
  1366. RingPrepair(p,512);
  1368. if (p->LastMode != 0x0F)
  1369. {
  1370. p->LastMode = 0x0F;
  1371. RingPush(p,0x4A1);
  1372. }
  1373. else
  1374. RingPush(p,0xC0001000);
  1375. RingPush(p,0);
  1377. p->MacroPos = p->RingPos;
  1378. p->RingPos = (p->RingPos+1) & p->RingMask;
  1379. }
  1381. static NOINLINE void IDCTIntraEnd(ati4200* p)
  1382. {
  1383. atisurf* Dst = p->Dst;
  1384. int Pos;
  1386. RingPush(p,5);
  1387. RingPush(p,0xF|p->ArithMode); 
  1389. RingPush(p,0x2D000003 | Dst->YOffset);
  1391. Pos = p->MacroCoord;
  1392. RingPush(p,Pos);
  1393. RingPush(p,Pos*4);
  1394. Pos += 8 << 16;
  1395. RingPush(p,Pos);
  1396. RingPush(p,Pos*4);
  1397. Pos += 8 - (8 << 16);
  1398. RingPush(p,Pos);
  1399. RingPush(p,Pos*4);
  1400. Pos += 8 << 16;
  1401. RingPush(p,Pos);
  1402. RingPush(p,Pos*4);
  1403. Pos -= 8 + (8 << 16);
  1404. Pos >>= 1;
  1405. RingPush(p,Pos);
  1406. RingPush(p,Pos*4);
  1407. RingPush(p,0x2C000003 | Dst->UOffset);
  1408. RingPush(p,Pos);
  1409. RingPush(p,Pos*4);
  1410. RingPush(p,0x2C000003 | Dst->VOffset);
  1412. p->Ring[p->MacroPos] = 0xC0003200 | (((p->RingPos - (p->MacroPos+2)) & p->RingMask) << 16);
  1414. RingFlush(p);
  1415. }
  1417. static INLINE void IDCTInterStart(ati4200* p)
  1418. {
  1419. RingPrepair(p,512);
  1421. p->MacroPos = p->RingPos;
  1422. p->RingPos = (p->RingPos+3) & p->RingMask;
  1423. p->InterIDCT = 0;
  1424. }
  1426. static INLINE void PushMV(ati4200* p,int Pos,int n)
  1427. {
  1428. if (p->MVBack)
  1429. RingPush(p,(p->MVBackTab[n] + Pos) & ~0x00010000);
  1431. if (p->MVFwd)
  1432. RingPush(p,(p->MVFwdTab[n] + Pos) & ~0x00010000);
  1433. }
  1435. static NOINLINE void IDCTInterEnd(ati4200* p)
  1436. {
  1437. atisurf* Dst = p->Dst;
  1438. int Mode,Pos;
  1440. assert(p->MVBack || p->MVFwd);
  1442. if (p->MVBack && p->MVFwd)
  1443. {
  1444. Mode = 0x0E;
  1445. RingPush(p,6);
  1446. }
  1447. else
  1448. {
  1449. Mode = 0x0D;
  1450. RingPush(p,5);
  1451. }
  1453. if (!p->InterIDCT)
  1454. Mode -= 2;
  1456. RingPush(p,Mode|p->ArithMode);
  1458. RingPush(p,0x2D000000 | Dst->YOffset | (p->MVBack?0:3));
  1460. Pos = p->MacroCoord;
  1461. RingPush(p,Pos);
  1462. PushMV(p,Pos*4,0);
  1464. Pos += 8 << 16;
  1465. RingPush(p,Pos);
  1466. PushMV(p,Pos*4,1);
  1468. Pos += 8 - (8 << 16);
  1469. RingPush(p,Pos);
  1470. PushMV(p,Pos*4,2);
  1472. Pos += 8 << 16;
  1473. RingPush(p,Pos);
  1474. PushMV(p,Pos*4,3);
  1476. Pos -= 8 + (8 << 16);
  1477. Pos >>= 1;
  1478. RingPush(p,Pos);
  1479. PushMV(p,Pos*4,4);
  1481. RingPush(p,0x20000000 | (4<<26) | Dst->UOffset | (p->MVBack?1:4));
  1483. RingPush(p,Pos);
  1484. PushMV(p,Pos*4,5);
  1486. RingPush(p,0x20000000 | (5<<26) | Dst->VOffset | (p->MVBack?2:5));
  1488. Pos = p->MacroPos;
  1489. if (p->LastMode != Mode)
  1490. {
  1491. p->LastMode = Mode;
  1492. p->Ring[Pos] = 0x4A1;
  1493. }
  1494. else
  1495. p->Ring[Pos] = 0xC0001000;
  1496. Pos = (Pos+1) & p->RingMask;
  1497. p->Ring[Pos] = 0;
  1498. Pos = (Pos+1) & p->RingMask;
  1499. p->Ring[Pos] = 0xC0003200 | (((p->RingPos - (Pos+2)) & p->RingMask) << 16);
  1501. RingFlush(p);
  1502. }
  1504. void IDCTIntra(void* p,idct_block_t *Block,int Length,int ScanType)
  1505. {
  1506. int SubNo = ++AHI(p)->SubNo;
  1507. if (SubNo <= 4)
  1508. AHIDCBLOCK(AHI(p)->DCAdd)
  1510. if (SubNo == 1)
  1511. IDCTIntraStart(AHI(p));
  1513. if (Length>0 && Length<=64)
  1514. AHIPACKNORMAL(ScanType,0)
  1515. else
  1516. RingPush(AHI(p),0);
  1518. if (SubNo == 6)
  1519. IDCTIntraEnd(AHI(p));
  1520. }
  1522. void IDCTInter(void* p,idct_block_t *Block,int Length)
  1523. {
  1524. int SubNo = ++AHI(p)->SubNo;
  1526. AHIMVADJBLOCK(SubNo)
  1528. if (SubNo == 1)
  1529. IDCTInterStart(AHI(p));
  1531. if (Length>0 && Length<=64)
  1532. AHIPACKNORMAL(IDCTSCAN_ZIGZAG,1)
  1533. else
  1534. if (AHI(p)->InterIDCT)
  1535. RingPush(AHI(p),0);
  1537. if (SubNo == 6)
  1538. IDCTInterEnd(AHI(p));
  1539. }
  1541. void IDCTIntraSwap(void* p,idct_block_t *Block,int Length,int ScanType)
  1542. {
  1543. int SubNo = ++AHI(p)->SubNo;
  1544. if (SubNo <= 4)
  1545. AHIDCBLOCK(AHI(p)->DCAdd)
  1547. if (SubNo == 1)
  1548. IDCTIntraStart(AHI(p));
  1550. if (SubNo == 2)
  1551. {
  1552. AHI(p)->SavePos = 0;
  1553. if (Length>0 && Length<=64)
  1554. {
  1555. AHIPACKSWAP(ScanType,0,SkipLabel1,AHI(p)->SaveData,AHI(p)->SavePos,-1,1)
  1556. AHI(p)->SaveScanType = ScanType;
  1557. }
  1558. }
  1559. else
  1560. {
  1561. if (Length>0 && Length<=64)
  1562. AHIPACKSWAP(ScanType,0,SkipLabel2,AHI(p)->Ring,AHI(p)->RingPos,AHI(p)->RingMask,0)
  1563. else
  1564. RingPush(AHI(p),0);
  1566. if (SubNo == 3)
  1567. {
  1568. int j,i = AHI(p)->RingPos;
  1569. if (AHI(p)->SavePos)
  1570. {
  1571. j = AHI(p)->SaveScanType;
  1572. if (AHI(p)->LastScanType != j)
  1573. {
  1574. AHI(p)->LastScanType = j;
  1575. AHI(p)->Ring[i] = 7;
  1576. i = (i+1) & AHI(p)->RingMask;
  1577. if (j==2) j=0x10;
  1578. else if (j==1) j=0x800;
  1579. AHI(p)->Ring[i] = j;
  1580. i = (i+1) & AHI(p)->RingMask;
  1581. }
  1582. else
  1583. {
  1584. AHI(p)->Ring[i] = 2;
  1585. i = (i+1) & AHI(p)->RingMask;
  1586. }
  1588. for (j=0;j<AHI(p)->SavePos;++j)
  1589. {
  1590. AHI(p)->Ring[i] = AHI(p)->SaveData[j];
  1591. i = (i+1) & AHI(p)->RingMask;
  1592. }
  1593. }
  1594. else
  1595. {
  1596. AHI(p)->Ring[i] = 0;
  1597. i = (i+1) & AHI(p)->RingMask;
  1598. }
  1599. AHI(p)->RingPos = i;
  1600. }
  1601. else
  1602. if (SubNo == 6)
  1603. IDCTIntraEnd(AHI(p));
  1604. }
  1605. }
  1607. void IDCTInterSwap(void* p,idct_block_t *Block,int Length)
  1608. {
  1609. int SubNo = ++AHI(p)->SubNo;
  1611. AHIMVADJBLOCK(SubNo)
  1613. if (SubNo == 1)
  1614. IDCTInterStart(AHI(p));
  1616. if (SubNo == 2)
  1617. {
  1618. AHI(p)->SavePos = 0;
  1619. if (Length>0 && Length<=64)
  1620. AHIPACKSWAPZIGZAG(1,SkipLabel1,AHI(p)->SaveData,AHI(p)->SavePos,-1,1)
  1621. }
  1622. else
  1623. if (SubNo == 3)
  1624. {
  1625. if (Length>0 && Length<=64)
  1626. {
  1627. --SubNo;
  1628. AHIPACKSWAPZIGZAG(1,SkipLabel2,AHI(p)->Ring,AHI(p)->RingPos,AHI(p)->RingMask,0)
  1629. }
  1630. else
  1631. if (AHI(p)->InterIDCT)
  1632. RingPush(AHI(p),0);
  1634. if (AHI(p)->SavePos>0 || AHI(p)->InterIDCT)
  1635. {
  1636. int j,i = AHI(p)->RingPos;
  1638. if (!AHI(p)->InterIDCT)
  1639. {
  1640. AHI(p)->InterIDCT = 1;
  1641. AHI(p)->Ring[i] = 0; 
  1642. i = (i+1) & AHI(p)->RingMask;
  1643. AHI(p)->Ring[i] = 0; 
  1644. i = (i+1) & AHI(p)->RingMask;
  1645. }
  1647. if (AHI(p)->SavePos>0)
  1648. {
  1649. if (AHI(p)->LastScanType != IDCTSCAN_ZIGZAG)
  1650. {
  1651. AHI(p)->LastScanType = IDCTSCAN_ZIGZAG;
  1652. AHI(p)->Ring[i] = 7;
  1653. i = (i+1) & AHI(p)->RingMask;
  1654. AHI(p)->Ring[i] = 0;
  1655. i = (i+1) & AHI(p)->RingMask;
  1656. }
  1657. else
  1658. {
  1659. AHI(p)->Ring[i] = 2;
  1660. i = (i+1) & AHI(p)->RingMask;
  1661. }
  1663. for (j=0;j<AHI(p)->SavePos;++j)
  1664. {
  1665. AHI(p)->Ring[i] = AHI(p)->SaveData[j];
  1666. i = (i+1) & AHI(p)->RingMask;
  1667. }
  1668. }
  1669. else
  1670. {
  1671. AHI(p)->Ring[i] = 0;
  1672. i = (i+1) & AHI(p)->RingMask;
  1673. }
  1674. AHI(p)->RingPos = i;
  1675. }
  1676. }
  1677. else
  1678. {
  1679. if (Length>0 && Length<=64)
  1680. AHIPACKSWAPZIGZAG(1,SkipLabel3,AHI(p)->Ring,AHI(p)->RingPos,AHI(p)->RingMask,0)
  1681. else
  1682. if (AHI(p)->InterIDCT)
  1683. RingPush(AHI(p),0);
  1685. if (SubNo == 6)
  1686. IDCTInterEnd(AHI(p));
  1687. }
  1688. }
  1690. static void IDCTCopy16x16(void* p,int x,int y,int Forward)
  1691. {
  1692. int32_t* Tab;
  1693. AHI(p)->MacroCoord = (y << 4) | (x << 20);
  1695. if (Forward)
  1696. {
  1697. AHI(p)->MVBack = 0;
  1698. AHI(p)->MVFwd = 1;
  1699. Tab = AHI(p)->MVFwdTab;
  1700. }
  1701. else
  1702. {
  1703. AHI(p)->MVBack = 1;
  1704. AHI(p)->MVFwd = 0;
  1705. Tab = AHI(p)->MVBackTab;
  1706. }
  1708. Tab[0] = 0;
  1709. Tab[1] = 0;
  1710. Tab[2] = 0;
  1711. Tab[3] = 0;
  1712. Tab[4] = 0;
  1713. Tab[5] = 0;
  1715. IDCTInterStart(AHI(p));
  1716. IDCTInterEnd(AHI(p));
  1717. }
  1719. static void IDCTCopy16x16Swap(void* p,int x,int y,int Forward)
  1720. {
  1721. int32_t* Tab;
  1722. AHI(p)->MacroCoord = (x << 4) | (y << 20);
  1723. AHI(p)->InterIDCT = 0;
  1725. if (Forward)
  1726. {
  1727. AHI(p)->MVBack = 0;
  1728. AHI(p)->MVFwd = 1;
  1729. Tab = AHI(p)->MVFwdTab;
  1730. }
  1731. else
  1732. {
  1733. AHI(p)->MVBack = 1;
  1734. AHI(p)->MVFwd = 0;
  1735. Tab = AHI(p)->MVBackTab;
  1736. }
  1738. Tab[0] = 0;
  1739. Tab[1] = 0;
  1740. Tab[2] = 0;
  1741. Tab[3] = 0;
  1742. Tab[4] = 0;
  1743. Tab[5] = 0;
  1745. IDCTInterStart(AHI(p));
  1746. IDCTInterEnd(AHI(p));
  1747. }
  1749. static int IDCTUpdateFunc(ati4200* p)
  1750. {
  1751. if (p->Overlay.Direction)
  1752. {
  1753. p->IdctVMT.Copy16x16 = IDCTCopy16x16Swap;
  1754. p->IdctVMT.Process = IDCTProcessSwap;
  1755. p->IdctVMT.MComp8x8 = IDCTMCompSwap;
  1756. p->IdctVMT.MComp16x16 = IDCTMCompSwap;
  1757. p->IdctVMT.Intra8x8 = (idctintra)IDCTIntraSwap;
  1758. p->IdctVMT.Inter8x8 = (idctinter)IDCTInterSwap;
  1759. }
  1760. else 
  1761. {
  1762. p->IdctVMT.Copy16x16 = IDCTCopy16x16;
  1763. p->IdctVMT.Process = IDCTProcess;
  1764. p->IdctVMT.MComp8x8 = IDCTMComp;
  1765. p->IdctVMT.MComp16x16 = IDCTMComp;
  1766. p->IdctVMT.Intra8x8 = (idctintra)IDCTIntra;
  1767. p->IdctVMT.Inter8x8 = (idctinter)IDCTInter;
  1768. }
  1769. return ERR_NONE;
  1770. }
  1772. static int IDCTOutputFormat(ati4200* p, const void* Data, int Size)
  1773. {
  1774. packetformat Format;
  1775. int Result;
  1776. p->IDCTInit = 1;
  1778. if (Size == sizeof(video))
  1779. {
  1780. memset(&Format,0,sizeof(Format));
  1781. Format.Type = PACKET_VIDEO;
  1782. Format.Format.Video = *(const video*)Data;
  1783. Data = &Format;
  1784. Size = sizeof(packetformat);
  1786. //IDCTWidth or IDCTHeight could have changes so invalidate current input format
  1787. memset(&p->p.Input.Format.Video,0,sizeof(video));
  1788. }
  1790. Result = p->p.Node.Set((node*)p,OUT_INPUT|PIN_FORMAT,Data,Size);
  1792. if (Size && Result != ERR_NONE)
  1793. p->p.Node.Set((node*)p,OUT_INPUT|PIN_FORMAT,NULL,0);
  1795. p->IDCTInit = 0;
  1796. return Result;
  1797. }
  1799. static int IDCTSend(void* p,tick_t RefTime,const flowstate* State);
  1801. static int IDCTSet(void* p, int No, const void* Data, int Size)
  1802. {
  1803. flowstate State;
  1804. int Result = ERR_INVALID_PARAM;
  1805. switch (No)
  1806. {
  1807. case IDCT_MODE: if (*(int*)Data==0) Result = ERR_NONE; break;
  1808. case IDCT_BUFFERWIDTH: SETVALUE(AHI(p)->IDCTWidth,int,ERR_NONE); break;
  1809. case IDCT_BUFFERHEIGHT: SETVALUE(AHI(p)->IDCTHeight,int,ERR_NONE); break;
  1810. case IDCT_FORMAT:
  1811. assert(Size == sizeof(video) || !Data);
  1812. Result = IDCTOutputFormat(AHI(p),Data,Size);
  1813. break;
  1815. case IDCT_BACKUP:
  1816. if (Size == sizeof(idctbackup))
  1817. Result = IDCTRestore(p,(idctbackup*)Data);
  1818. break;
  1820. case IDCT_ROUNDING: SETVALUE(AHI(p)->Rounding,bool_t,ERR_NONE); break;
  1822. case IDCT_SHOW: 
  1823. SETVALUE(AHI(p)->ShowNext,int,ERR_NONE); 
  1824. if (AHI(p)->ShowNext >= AHI(p)->BufCount) AHI(p)->ShowNext = -1;
  1825. break;
  1827. case IDCT_BUFFERCOUNT:
  1828. assert(Size == sizeof(int));
  1829. if (*(const int*)Data > ALL_COUNT)
  1830. Result = ERR_OUT_OF_MEMORY;
  1831. else
  1832. {
  1833. AHI(p)->BufCount = *(const int*)Data;
  1834. Result = ERR_NONE;
  1835. }
  1836. break;
  1838. case FLOW_FLUSH:
  1839. AHI(p)->ShowNext = -1;
  1840. Result = ERR_NONE;
  1841. break;
  1843. case FLOW_RESEND:
  1844. State.CurrTime = TIME_RESEND;
  1845. State.DropLevel = 0;
  1846. Result = IDCTSend(p,-1,&State);
  1847. break;
  1848. }
  1849. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+AHI(p)->AllCount)
  1850. SETVALUE(AHI(p)->BufFrameNo[No-IDCT_FRAMENO],int,ERR_NONE);
  1851. return Result;
  1852. }
  1854. static int IDCTEnumAHI(void* p, int* No, datadef* Param)
  1855. {
  1856. int Result = IDCTEnum(p,No,Param);
  1857. if (Result == ERR_NONE && Param->No == IDCT_OUTPUT)
  1858. Param->Flags |= DF_RDONLY;
  1859. return Result;
  1860. }
  1862. static int IDCTGet(void* p, int No, void* Data, int Size)
  1863. {
  1864. int Result = ERR_INVALID_PARAM;
  1865. switch (No)
  1866. {
  1867. case FLOW_BUFFERED: GETVALUE(1,bool_t); break;
  1868. case NODE_PARTOF: GETVALUE(AHI(p),ati4200*); break;
  1869. case IDCT_OUTPUT|PIN_FORMAT: GETVALUECOND(AHI(p)->p.Input,packetformat,AHI(p)->IDCT); break;
  1870. case IDCT_OUTPUT|PIN_PROCESS: GETVALUE(NULL,packetprocess); break;
  1871. case IDCT_OUTPUT: GETVALUE(AHI(p)->IDCTOutput,pin); break;
  1872. case IDCT_FORMAT: 
  1873. assert(Size==sizeof(video));
  1874. if (AHI(p)->IDCT)
  1875. {
  1876. video* i = (video*)Data;
  1877. *i = AHI(p)->p.Input.Format.Video;
  1878. if ((AHI(p)->Overlay.Direction ^ i->Direction) & DIR_SWAPXY)
  1879. {
  1880. i->Direction ^= DIR_SWAPXY;
  1881. SwapInt(&i->Width,&i->Height);
  1882. }
  1883. Result = ERR_NONE;
  1884. }
  1885. break;
  1886. case IDCT_MODE: GETVALUE(0,int); break;
  1887. case IDCT_ROUNDING: GETVALUE(AHI(p)->Rounding,bool_t); break;
  1888. case IDCT_BUFFERCOUNT: GETVALUE(AHI(p)->BufCount,int); break;
  1889. case IDCT_BUFFERWIDTH: GETVALUE(AHI(p)->IDCTWidth,int); break;
  1890. case IDCT_BUFFERHEIGHT: GETVALUE(AHI(p)->IDCTHeight,int); break;
  1891. case IDCT_SHOW: GETVALUE(AHI(p)->ShowNext,int); break;
  1892. case IDCT_BACKUP: 
  1893. assert(Size == sizeof(idctbackup));
  1894. Result = IDCTBackup(p,(idctbackup*)Data);
  1895. break;
  1896. }
  1897. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+AHI(p)->AllCount)
  1898. GETVALUE(AHI(p)->BufFrameNo[No-IDCT_FRAMENO],int);
  1899. return Result;
  1900. }
  1902. static int IDCTLock(void* p,int No,planes Planes,int* Brightness,video* Format)
  1903. {
  1904. if (Brightness)
  1905. *Brightness = AHI(p)->p.FX.Brightness;
  1906. if (Format)
  1907. *Format = AHI(p)->Overlay;
  1909. if (No<0 || No>=AHI(p)->BufCount || No>=AHI(p)->AllCount)
  1910. {
  1911. Planes[0] = NULL;
  1912. Planes[1] = NULL;
  1913. Planes[2] = NULL;
  1914. return ERR_INVALID_PARAM;
  1915. }
  1917. Wait(AHI(p));
  1918. memcpy(Planes,AHI(p)->Buffer[No].Planes,sizeof(planes));
  1919. return ERR_NONE;
  1920. }
  1922. static void IDCTUnlock(void* p,int No)
  1923. {
  1924. }
  1926. static int IDCTFrameStart(void* p,int FrameNo,int *OldFrameNo,int DstNo,int BackNo,int FwdNo,int ShowNo,bool_t Drop)
  1927. {
  1928. if (!AHI(p)->IDCT)
  1929. return ERR_DEVICE_ERROR;
  1931. // we will try to avoid to overwrite currently displayed buffers:
  1932. //   ShowCurr currently displayed
  1933. //   ShowLast may be still on screen (because flip occurs only during vblank)
  1935. if (AHI(p)->ShowScale<0 && (AHI(p)->ShowLast == DstNo || AHI(p)->ShowCurr == DstNo))
  1936. {
  1937. // try to find a free buffer
  1938. int SwapNo;
  1939. for (SwapNo=0;SwapNo<AHI(p)->AllCount;++SwapNo)
  1940. if (SwapNo != AHI(p)->ShowLast && SwapNo != AHI(p)->ShowCurr && 
  1941. SwapNo != BackNo && SwapNo != FwdNo && SwapNo != ShowNo)
  1942. break; 
  1944. if (SwapNo < AHI(p)->AllCount)
  1945. SwapPtr(AHI(p),SwapNo,DstNo,1);
  1946. }
  1948. AHI(p)->ShowNext = ShowNo;
  1950. if (OldFrameNo)
  1951. *OldFrameNo = AHI(p)->BufFrameNo[DstNo];
  1952. AHI(p)->BufFrameNo[DstNo] = FrameNo;
  1954. AHI(p)->Dst = AHI(p)->Buffer+DstNo;
  1956. RingBegin(AHI(p),0);
  1958. RingPrepair(AHI(p),32);
  1960. RingReg(AHI(p),DP_MIX,0x01CC1200);
  1961. RingReg(AHI(p),DP_GUI_MASTER_CNTL,0xD598B2DF);
  1962. RingReg(AHI(p),DP_DATATYPE,0x40037D02);
  1963. RingReg(AHI(p),DST_PITCH,AHI(p)->Dst->UPitch);
  1964. RingReg(AHI(p),SC_TOP_LEFT,0);
  1965. RingReg(AHI(p),SC_BOTTOM_RIGHT,(AHI(p)->Overlay.Width & 0xFFFF) | (AHI(p)->Overlay.Height << 16));
  1966. RingReg(AHI(p),SRC_SC_BOTTOM_RIGHT,(((AHI(p)->Overlay.Width>>1)-1) & 0xFFFF) | (((AHI(p)->Overlay.Height>>1)-1) << 16));
  1968. if (BackNo >= 0)
  1969. {
  1970. atisurf* s = AHI(p)->Buffer+BackNo;
  1971. RingReg(AHI(p),REF1_PITCH_OFFSET,(s->YPitch << 19) | (s->YOffset >> 4));
  1972. RingReg(AHI(p),REF2_PITCH_OFFSET,(s->UPitch << 19) | (s->UOffset >> 4));
  1973. RingReg(AHI(p),REF3_PITCH_OFFSET,(s->VPitch << 19) | (s->VOffset >> 4));
  1974. }
  1976. if (FwdNo >= 0)
  1977. {
  1978. atisurf* s = AHI(p)->Buffer+FwdNo;
  1979. RingReg(AHI(p),REF4_PITCH_OFFSET,(s->YPitch << 19) | (s->YOffset >> 4));
  1980. RingReg(AHI(p),REF5_PITCH_OFFSET,(s->UPitch << 19) | (s->UOffset >> 4));
  1981. RingReg(AHI(p),REF6_PITCH_OFFSET,(s->VPitch << 19) | (s->VOffset >> 4));
  1982. }
  1984. AHI(p)->LastScanType = -1;
  1985. AHI(p)->LastMode = -1;
  1986. AHI(p)->ArithMode = (AHI(p)->Rounding?0x80000000:0)|0x200;
  1988. RingFlush(AHI(p));
  1990. return ERR_NONE;
  1991. }
  1993. static void IDCTFrameEnd(void* p)
  1994. {
  1995. if (AHI(p)->IDCT)
  1996. {
  1997. Wait(AHI(p)); // register restoring would mess up running IDCT
  1998. RingEnd(AHI(p));
  1999. }
  2000. }
  2002. static void IDCTDrop(void* p)
  2003. {
  2004. int No;
  2005. for (No=0;No<AHI(p)->AllCount;++No)
  2006. AHI(p)->BufFrameNo[No] = -1;
  2007. }
  2009. static int IDCTNull(void* p,const flowstate* State,bool_t Empty)
  2010. {
  2011. if (Empty)
  2012. ++AHI(p)->p.Total;
  2013. if (!State || State->DropLevel)
  2014. ++AHI(p)->p.Dropped;
  2015. return ERR_NONE;
  2016. }
  2018. static int IDCTSend(void* p,tick_t RefTime,const flowstate* State)
  2019. {
  2020. if (AHI(p)->ShowNext < 0)
  2021. return ERR_NEED_MORE_DATA;
  2023. if (State->CurrTime >= 0)
  2024. {
  2025. if (!AHI(p)->p.Play && State->CurrTime == AHI(p)->p.LastTime)
  2026. return ERR_BUFFER_FULL;
  2028. if (RefTime - (State->CurrTime + SHOWAHEAD) >= 0)
  2029. return ERR_BUFFER_FULL;
  2031. AHI(p)->p.LastTime = State->CurrTime;
  2032. }
  2033. else
  2034. AHI(p)->p.LastTime = RefTime;
  2036. if (State->CurrTime != TIME_RESEND)
  2037. ++AHI(p)->p.Total;
  2039. AHI(p)->ShowLast = AHI(p)->ShowCurr;
  2040. AHI(p)->ShowCurr = AHI(p)->ShowNext;
  2042. if (AHI(p)->ShowScale>=0)
  2043. {
  2044. if (State->DropLevel)
  2045. ++AHI(p)->p.Dropped;
  2046. else
  2047. Stretch(AHI(p),1);
  2048. }
  2049. else
  2050. SetOverlay(AHI(p));
  2052. return ERR_NONE;
  2053. }
  2055. static const nodedef ATI4200_IDCT =
  2056. {
  2057. CF_ABSTRACT,
  2058. ATI4200_IDCT_ID,
  2059. IDCT_CLASS,
  2060. PRI_DEFAULT-10, // don't use acceleration by default...
  2061. };
  2063. //---------------------------------------------------------------------------------------------
  2065. #if defined(_M_IX86)
  2066. extern void* __stdcall VirtualAlloc(void*,int,int,int);
  2067. #define MEM_COMMIT        0x1000     
  2068. #define PAGE_READWRITE    0x04     
  2069. #endif
  2071. static int Create(ati4200* p)
  2072. {
  2073. if (QueryPlatform(PLATFORM_MODEL)!=MODEL_ZODIAC)
  2074. return ERR_NOT_SUPPORTED;
  2076. p->p.Init = (ovlfunc)Init;
  2077. p->p.Done = (ovldone)Done;
  2078. p->p.Reset = (ovlfunc)Reset;
  2079. p->p.Blit = (ovlblit)Blit;
  2080. p->p.Update = (ovlfunc)Update;
  2081. p->p.UpdateShow = (ovlfunc)UpdateShow;
  2082. p->p.DoPowerOff = 1;
  2084. #if defined(_M_IX86)
  2085. #if !defined(ATIEMU)
  2086. return ERR_NOT_SUPPORTED;
  2087. #else
  2088. p->Device = VirtualAlloc(NULL,EXT_BASE+8*1024*1024,MEM_COMMIT,PAGE_READWRITE);
  2089. if (!p->Device)
  2090. return ERR_NOT_SUPPORTED;
  2091. memset(p->Device,0,EXT_BASE+8*1024*1024);
  2092. p->Regs = (int*)(p->Device + REG_BASE);
  2093. p->Regs[RING_CNTL] = 0x0800000D;
  2094. p->Regs[RING_BASE] = 0x00150000;
  2095. p->Regs[ACTIVE_V_DISP] = 480 << 16;
  2097. #endif
  2098. #else
  2099. p->Device = (uint8_t*)0x90000000;
  2100. p->Regs = (int*)(p->Device + REG_BASE);
  2101. #endif
  2103. p->Memory = EXT_BASE + 512*1024;
  2105. p->RingMask = (2 << (p->Regs[RING_CNTL] & 0x3F))-1;
  2106. p->Ring = (int*)(p->Device + p->Regs[RING_BASE]);
  2108. p->IdctVMT.Class = ATI4200_IDCT_ID;
  2109. p->IdctVMT.Enum = IDCTEnumAHI;
  2110. p->IdctVMT.Get = IDCTGet;
  2111. p->IdctVMT.Set = IDCTSet;
  2112. p->IdctVMT.Send = IDCTSend;
  2113. p->IdctVMT.Null = IDCTNull;
  2114. p->IdctVMT.Drop = IDCTDrop;
  2115. p->IdctVMT.Lock = IDCTLock;
  2116. p->IdctVMT.Unlock = IDCTUnlock;
  2117. p->IdctVMT.FrameStart = IDCTFrameStart;
  2118. p->IdctVMT.FrameEnd = IDCTFrameEnd;
  2120. p->IDCTOutput.Node = (node*)p;
  2121. p->IDCTOutput.No = OUT_INPUT;
  2123. p->p.AccelIDCT = &p->IdctVMT;
  2124. NodeRegisterClass(&ATI4200_IDCT);
  2126. GetMode(p);
  2128. return ERR_NONE;
  2129. }
  2131. static const nodedef ATI4200 = 
  2132. {
  2133. sizeof(ati4200)|CF_GLOBAL,
  2134. ATI4200_ID,
  2135. OVERLAY_CLASS,
  2136. PRI_DEFAULT+50,
  2137. (nodecreate)Create,
  2138. };
  2140. void ATI4200_Init() 
  2141. {
  2142. NodeRegisterClass(&ATI4200);
  2143. }
  2145. void ATI4200_Done() 
  2146. {
  2147. NodeUnRegisterClass(ATI4200_ID);
  2148. }
  2150. #else
  2151. void ATI4200_Init() {}
  2152. void ATI4200_Done() {}
  2153. #endif