Category

Development Platform
Home > SourceCode/Document > Embeded-SCM Develop > Windows CE > View Code
overlay_xscale.c
Package: tcpmp.rar　[view]
Upload User: wstnjxml
Upload Date: 2014-04-03
Package Size: 7248k
Code Size: 24k
Category:

Windows CE

Development Platform:

C/C++

overlay_xscale.c：Code Content
  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: overlay_xscale.c 615 2006-01-26 16:57:51Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  26. #define X50V // included in official version
  28. #if defined(ARM)
  30. #define WIN32_LEAN_AND_MEAN
  31. #ifndef STRICT
  32. #define STRICT
  33. #endif
  34. #include <windows.h>
  36. #define MAXDESC 1024
  37. #define MAXORIGBLOCK 8
  38. #define MAXCOUNT 3
  39. #define MAXDESCBLOCK 4
  41. typedef struct xscaledesc
  42. {
  43. uint32_t Next;
  44. uint32_t Base;
  45. uint32_t Id;
  46. uint32_t Cmd;
  48. } xscaledesc;
  50. typedef struct xscaledriver
  51. {
  52. node Node;
  53. int Width;
  54. int Height;
  55. int BufferSize;
  56. int MaxBlock;
  57. bool_t AllocAtStart;
  58. bool_t SetupFlip;
  59. bool_t SetupStretch;
  60. bool_t InAlloc;
  61. bool_t AtStart;
  62. struct xscale* Used;
  64. int DescPhyCount[MAXCOUNT];
  65. phymemblock DescPhy[MAXCOUNT][MAXDESCBLOCK];
  66. xscaledesc* Desc[MAXCOUNT];
  67. xscaledesc* DescLast[MAXCOUNT];
  69. int* Map;
  70. int BufferPhyCount[MAXCOUNT];
  71. phymemblock* BufferPhy; // [MAXCOUNT][MaxBlock]
  72. void* Buffer[MAXCOUNT];
  73. int Count;
  75. #ifdef X50V
  76. uint32_t* GPIO;
  77. uint32_t* Marathon;
  78. bool_t X50v;
  79. #endif
  81. uint32_t* Regs;
  82. uint32_t OrigDescPhy[MAXORIGBLOCK];
  83. phymemblock OrigBufferPhy[MAXORIGBLOCK];
  84. int OrigDescCount;
  85. void* OrigBuffer;
  86. int OrigBufferSize;
  87. xscaledesc* OrigDescEnd;
  88. bool_t OrigDescEndSet;
  89. bool_t NotOrig;
  91. } xscaledriver;
  93. typedef struct xscale
  94. {
  95. overlay Overlay;
  96. xscaledriver* Driver;
  97. bool_t Flip;
  98. int Next;
  100. } xscale;
  102. #define MAGIC 0xBABE0000
  104. #define GPIO_BASE 0x40E00000
  105. #define GPIO_SIZE 0x1000
  106. #define LCD_BASE 0x44000000
  107. #define LCD_SIZE 0x1000
  109. #define LCCR0 (0x000/4)
  110. #define LCCR1 (0x004/4)
  111. #define LCCR2 (0x008/4)
  112. #define LCCR3 (0x00C/4)
  113. #define LCCR4 (0x010/4)
  114. #define LCCR5 (0x014/4)
  115. #define LCSR0 (0x038/4)
  116. #define LCSR1 (0x034/4)
  117. #define FBR0 (0x020/4)
  118. #define FDADR0 (0x200/4)
  119. #define FSADR0 (0x204/4)
  120. #define FIDR0 (0x208/4)
  122. #define GAFR1_U (0x060/4)
  123. #define GAFR2_L (0x064/4)
  125. #define LCD_CONFIG (0x03fe0060/4)
  127. static void FreeOrig(xscaledriver* p)
  128. {
  129. int n;
  131. // be sure that the old orig is not referenced by the buffers
  132. for (n=0;n<p->Count;++n)
  133. p->DescLast[n]->Next = p->DescPhy[n]->Addr;
  135. // restore and release end descriptor
  136. if (p->OrigDescEnd)
  137. {
  138. if (p->OrigDescEndSet)
  139. {
  140. p->OrigDescEnd->Next = p->OrigDescPhy[0];
  141. p->OrigDescEndSet = 0;
  142. }
  143. PhyMemEnd(p->OrigDescEnd);
  144. p->OrigDescEnd = NULL;
  145. }
  147. // release framebuffer
  148. if (p->OrigBuffer)
  149. {
  150. PhyMemEnd(p->OrigBuffer);
  151. p->OrigBuffer = NULL;
  152. }
  154. p->OrigDescCount = 0;
  155. p->OrigBufferSize = 0;
  156. p->NotOrig = 0;
  157. }
  159. static void GetOrig(xscaledriver* p)
  160. {
  161. uint32_t DescPhy[MAXORIGBLOCK]; // original descriptor head
  162. xscaledesc Desc[MAXORIGBLOCK];
  163. uint32_t Phy;
  165. #ifdef X50V
  166. if (p->X50v)
  167. {
  168. // create a fake desc chain with SRAM usage (like Loox720)
  169. /*
  170. int Left = 640*480*2 - 256*1024;
  171. phymemblock Block2;
  172. phymemblock Block;
  173. int One = 1;
  174. xscaledesc* d = (xscaledesc*) PhyMemAlloc(sizeof(xscaledesc)*2,&Block,&One);
  175. if (!d)
  176. return;
  178. One = 1;
  179. if (!PhyMemAlloc(Left,&Block2,&One))
  180. return;
  182. d[0].Base = Block2.Addr;
  183. d[0].Cmd = Block2.Length;
  184. d[0].Id = 0;
  185. d[0].Next = Block.Addr + sizeof(xscaledesc);
  187. d[1].Base = 0x5C000000;
  188. d[1].Cmd = 256*1024 | (1<<21);
  189. d[1].Id = 0;
  190. d[1].Next = Block.Addr;
  192. Phy = Block.Addr;
  193. */
  195. Phy = 0;
  196. }
  197. else
  198. #endif
  199. {
  200. Phy = p->Regs[FDADR0] & ~15;
  201. p->Width = (p->Regs[LCCR1] & 1023)+1;
  202. p->Height = (p->Regs[LCCR2] & 1023)+1;
  203. }
  205. if (Phy)
  206. {
  207. int n,m;
  209. FreeOrig(p);
  211. for (n=0;n<MAXORIGBLOCK;)
  212. {
  213. xscaledesc* d = (xscaledesc*) PhyMemBegin(Phy,sizeof(xscaledesc),0);
  214. if (!d)
  215. break;
  217. DescPhy[n] = Phy;
  218. Desc[n] = *d;
  219. DEBUG_MSG4(-1,T("XScale %08x (%08x %08x %08x)"),Phy,Desc[n].Base,Desc[n].Cmd,Desc[n].Next);
  221. ++n;
  223. Phy = d->Next & ~15;
  224. PhyMemEnd(d);
  226. for (m=0;m<n;++m)
  227. if (DescPhy[m] == Phy)
  228. {
  229. int i,j;
  231. if (n-m>1) // need to find end
  232. {
  233. for (i=m;i<n;++i)
  234. if (Desc[i].Cmd & (1<<21))
  235. {
  236. ++i;
  237. if (i==n) i=m;
  238. break;
  239. }
  241. if (i==n)
  242. return; // failed
  243. }
  244. else
  245. i=m; // there is only one desc
  247. j=i;
  248. do
  249. {
  250. p->OrigDescPhy[p->OrigDescCount] = DescPhy[j];
  251. p->OrigBufferPhy[p->OrigDescCount].Addr = Desc[j].Base;
  252. p->OrigBufferPhy[p->OrigDescCount].Length = Desc[j].Cmd & 0x1FFFFF;
  253. p->OrigBufferSize += p->OrigBufferPhy[p->OrigDescCount].Length;
  254. p->OrigDescCount++;
  255. if (++j==n) j=m;
  256. }
  257. while (i!=j);
  259. // map end descriptor so we don't have to use disable/enable for flipping (with multiple desc displays)
  260. p->OrigDescEnd = (xscaledesc*) PhyMemBegin(p->OrigDescPhy[p->OrigDescCount-1],sizeof(xscaledesc),0);
  261. if (p->OrigDescEnd && p->OrigDescEnd->Next != p->OrigDescPhy[0])
  262. {
  263. PhyMemEnd(p->OrigDescEnd);
  264. p->OrigDescEnd = NULL;
  265. }
  267. // reuse original framebuffer
  268. if (p->OrigBufferSize >= p->Width*2*p->Height)
  269. p->OrigBuffer = PhyMemBeginEx(p->OrigBufferPhy,p->OrigDescCount,1);
  271. return;
  272. }
  273. }
  274. }
  275. }
  277. static bool_t FreeBuffer(xscaledriver* p)
  278. {
  279. int n;
  281. if (!p->BufferPhy || p->InAlloc || p->Used)
  282. return 0;
  284. for (n=0;n<p->Count;++n)
  285. {
  286. PhyMemFree(p->Desc[n],p->DescPhy[n],p->DescPhyCount[n]);
  287. if (n>0 || !p->OrigDescCount)
  288. PhyMemFree(p->Buffer[n],p->BufferPhy+p->MaxBlock*n,p->BufferPhyCount[n]);
  289. }
  291. p->Count = 0;
  292. p->MaxBlock = 0;
  294. free(p->Map);
  295. p->Map = NULL;
  297. free(p->BufferPhy);
  298. p->BufferPhy = NULL;
  300. DEBUG_MSG(-1,T("XSCALE Freed"));
  301. return 1;
  302. }
  304. static bool_t AllocBuffer(xscaledriver* p)
  305. {
  306. if (!p->BufferPhy && p->OrigBuffer)
  307. {
  308. int n;
  310. p->BufferSize = (p->Width*2 * p->Height) & ~3;
  311. p->MaxBlock = (p->BufferSize / 4096)+1;
  313. p->BufferPhy = (phymemblock*) malloc(sizeof(phymemblock)*p->MaxBlock*MAXCOUNT);
  314. if (!p->BufferPhy)
  315. return 0;
  317. p->Map = (int*) malloc(sizeof(int)*p->Height);
  318. if (!p->Map)
  319. {
  320. free(p->BufferPhy);
  321. p->BufferPhy = NULL;
  322. return 0;
  323. }
  325. p->InAlloc = 1;
  326. for (n=0;n<(p->SetupFlip?MAXCOUNT:1);++n)
  327. {
  328. // allocate desc table
  330. p->DescPhyCount[n] = MAXDESCBLOCK;
  331. p->Desc[n] = p->DescLast[n] = PhyMemAlloc(MAXDESC*sizeof(xscaledesc),p->DescPhy[n],&p->DescPhyCount[n]);
  332. if (!p->Desc[n])
  333. break;
  335. if (n==0 && p->OrigBufferSize >= p->BufferSize)
  336. {
  337. // use original surface
  338. p->Buffer[n] = p->OrigBuffer;
  339. p->BufferPhyCount[n] = p->OrigDescCount;
  340. memcpy(p->BufferPhy+p->MaxBlock*n,p->OrigBufferPhy,sizeof(phymemblock)*p->OrigDescCount);
  341. }
  342. else
  343. {
  344. // allocate new surface
  345. p->BufferPhyCount[n] = p->MaxBlock;
  346. p->Buffer[n] = PhyMemAlloc(p->BufferSize,p->BufferPhy+p->MaxBlock*n,&p->BufferPhyCount[n]);
  347. }
  349. if (!p->Buffer[n])
  350. {
  351. PhyMemFree(p->Desc[n],p->DescPhy[n],p->DescPhyCount[n]);
  352. break;
  353. }
  354. }
  356. if (n==2)
  357. {
  358. // can't flip chain with 2 surfaces (minimum is 3)
  359. PhyMemFree(p->Desc[1],p->DescPhy[1],p->DescPhyCount[1]);
  360. PhyMemFree(p->Buffer[1],p->BufferPhy+p->MaxBlock*1,p->BufferPhyCount[1]);
  361. --n;
  362. }
  364. p->Count = n;
  365. p->InAlloc = 0;
  367. DEBUG_MSG5(-1,T("XSCALE %d %d %d %d %d"),p->Count,p->BufferPhyCount[0],p->BufferPhyCount[1],p->BufferPhyCount[2],AvailMemory());
  368. }
  369. return 1;
  370. }
  372. static void GetMode(xscale* p)
  373. {
  374. p->Overlay.Output.Format.Video.Width = p->Driver->Width;
  375. p->Overlay.Output.Format.Video.Height = p->Driver->Height;
  376. p->Overlay.Output.Format.Video.Direction = 0;
  377. p->Overlay.Output.Format.Video.Aspect = ASPECT_ONE;
  378. p->Overlay.Output.Format.Video.Pitch = p->Overlay.Output.Format.Video.Width*2;
  379. DefaultRGB(&p->Overlay.Output.Format.Video.Pixel,16,5,6,5,0,0,0);
  380. AdjustOrientation(&p->Overlay.Output.Format.Video,1);
  382. if (p->Overlay.Output.Format.Video.Direction & DIR_SWAPXY)
  383. {
  384. int Model = QueryPlatform(PLATFORM_MODEL);
  385. if (Model == MODEL_IPAQ_H3800 || Model == MODEL_IPAQ_H3900 ||
  386. (Model == MODEL_NOVOGO && QueryPlatform(PLATFORM_VER)<500 && p->Driver->Width==240 && p->Driver->Height==320))
  387. p->Overlay.Output.Format.Video.Direction ^= DIR_MIRRORLEFTRIGHT|DIR_MIRRORUPDOWN;
  388. }
  390. if (!((uint32_t)p->Driver->OrigBuffer & 15))
  391. p->Overlay.Output.Format.Video.Pixel.Flags |= PF_16ALIGNED;
  392. }
  394. static int Init(xscale* p)
  395. {
  396. if (!p->Driver->OrigBuffer)
  397. {
  398. GetOrig(p->Driver);
  399. if (!p->Driver->OrigBuffer)
  400. return ERR_NOT_SUPPORTED;
  401. }
  403. GetMode(p);
  404. p->Next = 0;
  405. p->Flip = 0;
  407. p->Overlay.SetFX = BLITFX_AVOIDTEARING;
  409. if (p->Driver->Used)
  410. return ERR_DEVICE_ERROR;
  411. p->Driver->Used = p;
  413. if (!AllocBuffer(p->Driver))
  414. return ERR_OUT_OF_MEMORY;
  416. if (p->Driver->Count >= 3)
  417. p->Overlay.ClearFX = BLITFX_ONLYDIFF;
  419. return ERR_NONE;
  420. }
  422. static void QuickDisable(xscaledriver* p)
  423. {
  424. int n = p->Regs[LCCR0];
  425. n &= ~(1<<10); //DIS
  426. n &= ~1;    //ENB
  427. p->Regs[LCCR0] = n;
  428. Sleep(1);
  429. }
  431. static void Disable(xscaledriver* p)
  432. {
  433. int i;
  434. int n = p->Regs[LCCR0];
  435. if (n & 1)
  436. {
  437. n |= 1<<10; //DIS
  438. p->Regs[LCCR0] = n;
  440. for (i=0;i<30;++i)
  441. {
  442. if (!(p->Regs[LCCR0] & 1)) 
  443. break;
  444. Sleep(1);
  445. }
  447. if (i==30)
  448. QuickDisable(p);
  449. }
  450. }
  452. static void Enable(xscaledriver* p)
  453. {
  454. int n = p->Regs[LCCR0];
  456. n &= ~(1<<10); //DIS
  457. n |= 1; //EN;
  459. p->Regs[LCCR0] = n;
  460. Sleep(1);
  461. }
  463. static int GetCurrent2(xscaledriver* p)
  464. {
  465. int n;
  466. int Id = p->Regs[FIDR0] & ~15;
  467. uint32_t Phy = p->Regs[FDADR0] & ~15;
  469. if ((Id & 0xFFFF0000) == MAGIC)
  470. return (Id >> 4) & 0xFF;
  472. for (n=0;n<p->OrigDescCount;++n)
  473. if (Phy == p->OrigDescPhy[n] || Phy == p->OrigDescPhy[n]+sizeof(xscaledesc))
  474. return -1;
  476. return -2; // unknown
  477. }
  479. static int GetCurrent(xscaledriver* p)
  480. {
  481. int Current;
  483. if (!(p->Regs[LCCR0] & 1))
  484. return -2; // turned off lcd
  486. Current = GetCurrent2(p);
  487. if (Current >= -1)
  488. return Current;
  490. Sleep(50); // original desc chain has changed. maybe it's just temporary
  492. Current = GetCurrent2(p);
  493. if (Current >= -1)
  494. return Current;
  496. GetOrig(p); // reread original desc chain 
  498. return GetCurrent2(p);
  499. }
  501. #ifdef X50V
  503. static void X50vDisable(xscaledriver* p)
  504. {
  505. if (p->Marathon[LCD_CONFIG] & (1<<16))
  506. {
  507. uint32_t v;
  509. while ((v = p->Marathon[LCD_CONFIG]) & (1<<16))
  510. p->Marathon[LCD_CONFIG] = v & ~0x1000A;
  512. Disable(p);
  514. v = p->GPIO[GAFR1_U];
  515. if (v & 0xFFF00000)
  516. p->GPIO[GAFR1_U] = v & 0xFFFFF;
  518. v = p->GPIO[GAFR2_L];
  519. if (v & 0xFFFFFFF)
  520. p->GPIO[GAFR2_L] = v & 0xF0000000;
  521. }
  522. }
  524. static bool_t X50vEnable(xscaledriver* p,uint32_t Desc)
  525. {
  526. bool_t Changed = 0;
  527. if (!(p->Marathon[LCD_CONFIG] & (1<<16)))
  528. {
  529. uint32_t v;
  531. Changed = 1;
  532. Disable(p);
  534. p->Regs[LCCR0] = 0x1B008F8;
  535. p->Regs[LCCR1] = 0x1056FDDF; 
  536. p->Regs[LCCR2] = 0x104067F;  
  537. p->Regs[LCCR3] = 0x4f00001;  
  538. p->Regs[LCCR4] = 0;
  539. p->Regs[LCCR5] = 0x3F3F3F3F;
  541. p->Regs[FDADR0] = 0;
  542. p->Regs[LCSR0] = 0;
  544. v = p->GPIO[GAFR1_U];
  545. if ((v & 0xFFF00000) != 0xAAA00000)
  546. p->GPIO[GAFR1_U] = (v & 0xFFFFF) | 0xAAA00000;
  548. v = p->GPIO[GAFR2_L];
  549. if ((v & 0xFFFFFFF) != 0xAAAAAAA)
  550. p->GPIO[GAFR2_L] = (v & 0xF0000000) | 0xAAAAAAA;
  552. p->Regs[FDADR0] = Desc;
  553. Enable(p);
  554. QuickDisable(p);
  555. p->Regs[FDADR0] = Desc;
  556. Enable(p);
  558. while (!((v = p->Marathon[LCD_CONFIG]) & (1<<16)))
  559. {
  560. p->Marathon[LCD_CONFIG] = v | 0x1000A;
  561. Sleep(1);
  562. }
  563. }
  564. return Changed;
  565. }
  567. #endif
  569. static void SetOrig(xscaledriver* p)
  570. {
  571. int n;
  573. #ifdef X50V
  574. if (p->X50v)
  575. X50vDisable(p);
  576. else
  577. #endif
  578. {
  579. if (p->NotOrig)
  580. {
  581. if (p->OrigDescEnd && p->OrigDescEndSet)
  582. {
  583. p->OrigDescEnd->Next = p->OrigDescPhy[0];
  584. p->OrigDescEndSet = 0;
  585. }
  587. for (n=0;n<p->Count;++n)
  588. p->DescLast[n]->Next = p->OrigDescPhy[0];
  590. // wait for primary to be restored
  591. for (n=0;n<100;++n)
  592. {
  593. if (GetCurrent(p)<0)
  594. break;
  595. Sleep(1);
  596. }
  598. p->NotOrig = 0;
  599. }
  600. }
  601. }
  603. static void Done(xscale* p)
  604. {
  605. SetOrig(p->Driver);
  606. if (p->Driver->Used == p)
  607. p->Driver->Used = NULL;
  608. }
  610. static int Reset(xscale* p)
  611. {
  612. Done(p);
  613. Init(p);
  614. return ERR_NONE;
  615. }
  617. static xscaledesc* BuildDesc(xscaledesc* Desc,phymemblock* DescPhy,int DescPhyCount,phymemblock* BufferPhy,int BufferPhyCount,
  618.  int* Map,int Pitch,int Height,int Id)
  619. {
  620. uint32_t First = DescPhy->Addr;
  621. uint32_t Last = 0;
  622. uint32_t DescAddr = 0;
  623. int n,m;
  625. for (n=0;n<Height;++n)
  626. {
  627. uint32_t Pos = Pitch * Map[n];
  628. int Length = Pitch;
  630. for (m=0;Length>0 && m<BufferPhyCount;++m)
  631. {
  632. if (Pos < BufferPhy[m].Length)
  633. {
  634. uint32_t Addr = BufferPhy[m].Addr + Pos;
  635. int Size = BufferPhy[m].Length - Pos;
  636. if (Size > Length)
  637. Size = Length;
  639. if (Size & 3) return NULL; // this shouldn't happen
  641. // add desc 
  642. if (Addr != Last)
  643. {
  644. DescAddr += sizeof(xscaledesc);
  645. if (DescAddr > DescPhy->Length)
  646. {
  647. // next desc block
  648. if (--DescPhyCount==0) return NULL; // not enough desc...
  649. ++DescPhy;
  650. DescAddr = 0;
  651. }
  653. Desc->Next = DescPhy->Addr + DescAddr;
  654. Desc->Base = Addr;
  655. Desc->Id = Id;
  656. Desc->Cmd = Size;
  657. ++Desc;
  658. }
  659. else
  660. Desc[-1].Cmd += Size;
  661. Last = Addr + Size;
  663. Length -= Size;
  664. Pos += Size;
  665. }
  667. Pos -= BufferPhy[m].Length;
  668. }
  669. }
  671. --Desc;
  672. Desc->Next = First;
  673. Desc->Cmd |= (1<<21);
  674. return Desc;
  675. }
  677. static bool_t Build(xscaledriver* p)
  678. {
  679. int n;
  680. for (n=0;n<p->Count;++n)
  681. {
  682. p->DescLast[n] = BuildDesc(p->Desc[n],p->DescPhy[n],p->DescPhyCount[n],p->BufferPhy+p->MaxBlock*n,
  683. p->BufferPhyCount[n],p->Map,p->Width*2,p->Height,MAGIC | (n<<4));
  685. if (!p->DescLast[n])
  686. break;
  687. }
  689. if (n==p->Count)
  690. {
  691. for (n=p->OrigDescCount?1:0;n<p->Count;++n)
  692. memset(p->Buffer[n],0,p->BufferSize);
  693. return 1;
  694. }
  696. return 0;
  697. }
  699. static int UpdateAlign(xscale* p)
  700. {
  701. rect FullScreen;
  702. int* ScaleY;
  703. blitfx FX = p->Overlay.FX;
  704. bool_t FullView;
  706. if (FX.Direction & DIR_SWAPXY)
  707. ScaleY = &FX.ScaleX;
  708. else
  709. ScaleY = &FX.ScaleY;
  711. PhyToVirt(NULL,&FullScreen,&p->Overlay.Output.Format.Video);
  712. FullView = p->Driver->Count && EqRect(&FullScreen,&p->Overlay.Viewport);
  714. if (FullView && p->Driver->Count>=3)
  715. p->Overlay.FX.Flags &= ~BLITFX_AVOIDTEARING; //flipping used
  717. p->Flip = 0;
  718. p->Next = 0;
  719. SetOrig(p->Driver);
  721. OverlayUpdateAlign(&p->Overlay);
  723. if (FullView && p->Driver->Count)
  724. {
  725. int n;
  726. for (n=0;n<p->Overlay.Output.Format.Video.Height;++n)
  727. p->Driver->Map[n]=n;
  729. if (p->Driver->SetupStretch && 
  730. ((p->Overlay.Node.Class == XSCALE_LOW_ID && *ScaleY > SCALE_ONE/2) || *ScaleY > SCALE_ONE) && 
  731. !(p->Overlay.Output.Format.Video.Width & 1) && p->Overlay.Output.Format.Video.Height>0)
  732. {
  733. int Num,Den;
  734. int Adj;
  735. int LowSrc,HighSrc,CenterSrc;
  736. rect DstAlignedRect;
  737. rect SrcAlignedRect;
  739. *ScaleY = p->Overlay.Node.Class == XSCALE_LOW_ID ? SCALE_ONE/2 : SCALE_ONE;
  741. VirtToPhy(&p->Overlay.Viewport,&DstAlignedRect,&p->Overlay.Output.Format.Video);
  742. VirtToPhy(NULL,&SrcAlignedRect,&p->Overlay.Input.Format.Video);
  744. BlitRelease(p->Overlay.Soft);
  745. p->Overlay.Soft = BlitCreate(&p->Overlay.Output.Format.Video,&p->Overlay.Input.Format.Video,&FX,&p->Overlay.Caps);
  747. BlitAlign(p->Overlay.Soft, &DstAlignedRect, &SrcAlignedRect );
  749. LowSrc = -(DstAlignedRect.Height/2);
  750. HighSrc = LowSrc + DstAlignedRect.Height;
  751. CenterSrc = DstAlignedRect.y - LowSrc;
  753. Num = DstAlignedRect.Height;
  754. Den = p->Overlay.DstAlignedRect.Height;
  755. if (FX.Direction & DIR_SWAPXY)
  756. {
  757. Num *= p->Overlay.SrcAlignedRect.Width;
  758. Den *= SrcAlignedRect.Width;
  759. }
  760. else
  761. {
  762. Num *= p->Overlay.SrcAlignedRect.Height;
  763. Den *= SrcAlignedRect.Height;
  764. }
  765. Adj = Scale(p->Overlay.DstAlignedRect.Height,Num,2*Den);
  767. for (n=0;n<p->Overlay.DstAlignedRect.Height;++n)
  768. {
  769. int i = Scale(n,Num,Den) - Adj;
  770. if (i >= HighSrc) i=HighSrc-1;
  771. if (i < LowSrc) i=LowSrc;
  772. p->Driver->Map[p->Overlay.DstAlignedRect.y+n] = CenterSrc + i;
  773. }
  774. }
  776. if (Build(p->Driver))
  777. {
  778. p->Overlay.FX.Flags |= BLITFX_AVOIDTEARING; //restore
  779. p->Flip = 1;
  780. }
  781. }
  783. return ERR_NONE;
  784. }
  786. static void Restore(xscaledriver* p,int Next)
  787. {
  788. int n;
  789. char *s,*d;
  790. char *Src = (char*)p->Buffer[Next];
  791. char *Dst = (char*)p->OrigBuffer;
  792. int Middle = p->Height/2;
  793. int Pitch = p->Width*2;
  795. for (n=0;n<Middle;++n)
  796. {
  797. s = Src + p->Map[n] * Pitch;
  798. d = Dst + n*Pitch;
  799. if (s != d)
  800. memcpy(d,s,Pitch);
  801. }
  803. for (n=p->Height-1;n>=Middle;--n)
  804. {
  805. s = Src + p->Map[n] * Pitch;
  806. d = Dst + n*Pitch;
  807. if (s != d)
  808. memcpy(d,s,Pitch);
  809. }
  810. }
  812. static int UpdateShow(xscale* p)
  813. {
  814. if (!p->Overlay.Show)
  815. {
  816. SetOrig(p->Driver);
  818. if (p->Flip)
  819. {
  820. // restore after SetOrig because it's vsynced and restore starts for upper part anyway
  821. Restore(p->Driver,p->Next); 
  822. }
  823. p->Next = 0;
  824. }
  825. return ERR_NONE;
  826. }
  828. static int Lock(xscale* p, planes Planes, bool_t OnlyAligned )
  829. {
  830. if (p->Flip)
  831. {
  832. int Next = p->Next+1;
  833. if (Next == p->Driver->Count) 
  834. Next = 0;
  836. // use new buffer only if it's not the current
  837. if (GetCurrent(p->Driver) != Next) 
  838. p->Next = Next;
  840. Planes[0] = p->Driver->Buffer[p->Next];
  841. }
  842. else
  843. Planes[0] = p->Driver->OrigBuffer;
  845. return ERR_NONE;
  846. }
  848. static int Unlock(xscale* p )
  849. {
  850. if (p->Flip)
  851. {
  852. int Current = GetCurrent(p->Driver);
  853. uint32_t DescPhy = p->Driver->DescPhy[p->Next]->Addr;
  855. // close chain
  856. p->Driver->DescLast[p->Next]->Next = DescPhy;
  858. #ifdef X50V
  859. if (p->Driver->X50v && X50vEnable(p->Driver,DescPhy))
  860. Current = p->Next;
  861. #endif
  863. DEBUG_MSG4(-1,T("%08x %08x %08x %d"),p->Driver->Regs[LCCR0],p->Driver->Regs[LCCR3],p->Driver->Regs[FDADR0],Current);
  865. if (Current<-1)
  866. return ERR_DEVICE_ERROR;
  868. if (Current<0)
  869. {
  870. if (p->Driver->OrigDescEnd)
  871. {
  872. p->Driver->OrigDescEnd->Next = DescPhy;
  873. p->Driver->OrigDescEndSet = 1;
  874. }
  875. else
  876. if (p->Driver->OrigDescCount>1) 
  877. {
  878. // multi desc original
  879. bool_t Old = (p->Driver->Regs[LCCR0] & 1);
  880. Disable(p->Driver);
  881. p->Driver->Regs[FBR0] = 0;
  882. p->Driver->Regs[FDADR0] = DescPhy;
  883. if (Old) Enable(p->Driver);
  884. }
  885. else // simply branch
  886. p->Driver->Regs[FBR0] = DescPhy | 1; 
  887. }
  888. else
  889. {
  890. // modify last frames tail to new frame
  891. Current = p->Next-1;
  892. if (Current<0)
  893. Current = p->Driver->Count-1;
  894. p->Driver->DescLast[Current]->Next = DescPhy;
  895. }
  896. p->Driver->NotOrig = 1;
  897. }
  899. return ERR_NONE;
  900. }
  902. static int UpdateStretch(xscaledriver* Driver)
  903. {
  904. if (Driver->Used)
  905. UpdateAlign(Driver->Used);
  906. return ERR_NONE;
  907. }
  909. static int UpdateFlip(xscaledriver* Driver)
  910. {
  911. if (Driver->Used)
  912. {
  913. xscale* p = Driver->Used;
  914. Done(p);
  915. FreeBuffer(Driver);
  916. Init(p);
  917. UpdateAlign(p);
  918. p->Overlay.Dirty = 1;
  919. p->Overlay.LastTime = -1;
  920. }
  921. return ERR_NONE;
  922. }
  924. static const datatable Params[] = 
  925. {
  926. { XSCALEDRIVER_STRETCH, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  927. { XSCALEDRIVER_FLIP, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  928. { XSCALEDRIVER_ALLOC_AT_START, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  930. DATATABLE_END(XSCALEDRIVER_ID)
  931. };
  933. static int Enum(xscaledriver* p, int* No, datadef* Param)
  934. {
  935. return NodeEnumTable(No,Param,Params);
  936. }
  938. static int Get(xscaledriver* p,int No,void* Data,int Size)
  939. {
  940. int Result = ERR_INVALID_PARAM;
  941. switch (No) 
  942. {
  943. case XSCALEDRIVER_STRETCH: GETVALUE(p->SetupStretch,bool_t); break;
  944. case XSCALEDRIVER_FLIP: GETVALUE(p->SetupFlip,bool_t); break;
  945. case XSCALEDRIVER_ALLOC_AT_START: GETVALUE(p->AllocAtStart,bool_t); break;
  946. }
  947. return Result;
  948. }
  950. static bool_t Selected()
  951. {
  952. int Id;
  953. return NodeRegLoadValue(PLAYER_ID,PLAYER_VOUTPUTID,&Id,sizeof(Id),TYPE_INT) && (Id == XSCALE_ID || Id == XSCALE_LOW_ID);
  954. }
  956. static int Set(xscaledriver* p,int No,const void* Data,int Size)
  957. {
  958. int Result = ERR_INVALID_PARAM;
  959. switch (No)
  960. {
  961. case XSCALEDRIVER_STRETCH: SETVALUECMP(p->SetupStretch,bool_t,UpdateStretch(p),EqBool); break;
  962. case XSCALEDRIVER_FLIP: SETVALUECMP(p->SetupFlip,bool_t,UpdateFlip(p),EqBool); break;
  963. case XSCALEDRIVER_ALLOC_AT_START: SETVALUE(p->AllocAtStart,bool_t,ERR_NONE); break;
  964. case NODE_SETTINGSCHANGED:
  965. if (p->AllocAtStart && p->AtStart && Selected())
  966. {
  967. if (!p->OrigBuffer)
  968. GetOrig(p);
  969. AllocBuffer(p);
  970. }
  971. p->AtStart = 0;
  972. break;
  973. case NODE_HIBERNATE:
  974. if (!p->Used && FreeBuffer(p))
  975. Result = ERR_NONE;
  976. break;
  977. }
  978. return Result;
  979. }
  981. static int Create(xscale* p)
  982. {
  983. p->Driver = (xscaledriver*)NodeEnumObject(NULL,XSCALEDRIVER_ID);
  984. if (!p->Driver)
  985. return ERR_NOT_SUPPORTED;
  987. if (p->Overlay.Node.Class == XSCALE_LOW_ID && (p->Driver->Width*p->Driver->Height <= 320*240 || 
  988. (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_WMMX)!=0))
  989. return ERR_NOT_SUPPORTED;
  991. GetMode(p);
  992. p->Overlay.Init = Init;
  993. p->Overlay.Done= Done;
  994. p->Overlay.Reset = Reset;
  995. p->Overlay.Update = UpdateAlign;
  996. p->Overlay.UpdateShow = UpdateShow;
  997. p->Overlay.Lock = Lock;
  998. p->Overlay.Unlock = Unlock;
  999. return ERR_NONE;
  1000. }
  1002. static int CreateDriver(xscaledriver* p)
  1003. {
  1004. bool_t Detected;
  1005. int Caps = QueryPlatform(PLATFORM_CAPS);
  1006. if (!(Caps & CAPS_ARM_XSCALE))
  1007. return ERR_NOT_SUPPORTED;
  1009. p->Node.Enum = Enum;
  1010. p->Node.Get = Get;
  1011. p->Node.Set = Set;
  1013. p->AtStart = 1;
  1014. p->OrigBuffer = NULL;
  1015. p->OrigDescCount = 0;
  1016. p->Regs = (uint32_t*)PhyMemBegin(LCD_BASE,LCD_SIZE,0);
  1017. if (!p->Regs)
  1018. return ERR_NOT_SUPPORTED;
  1020. #ifdef X50V
  1021. p->X50v = QueryPlatform(PLATFORM_MODEL)==MODEL_AXIM_X50 && CheckModule(T("pvrvadd.dll"));
  1022. if (p->X50v)
  1023. {
  1024. p->Width = 480;
  1025. p->Height = 640;
  1026. p->Marathon = (uint32_t*) 0xBC000000;
  1027. p->GPIO = (uint32_t*) PhyMemBegin(GPIO_BASE,GPIO_SIZE,0);
  1028. if (p->GPIO)
  1029. {
  1030. RawFrameBufferInfo Info;
  1031. HDC DC= GetDC(NULL);
  1032. memset(&Info,0,sizeof(Info));
  1033. ExtEscape(DC, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char*)&Info);
  1034. ReleaseDC(NULL,DC);
  1036. p->OrigBuffer = Info.pFramePointer;
  1037. }
  1038. }
  1039. else
  1040. #endif
  1041. if (!(p->Regs[LCCR0] & 1) || ((p->Regs[LCCR3] >> 24) & 7)!=4) // LCD enabled, RGB 16bit
  1042. return ERR_NOT_SUPPORTED;
  1044. if (!NodeRegLoadValue(XSCALEDRIVER_ID, XSCALEDRIVER_DETECTED, &Detected, sizeof(Detected), TYPE_BOOL) || !Detected)
  1045. {
  1046. GetOrig(p);
  1047. if (!p->OrigBuffer)
  1048. {
  1049. PhyMemEnd(p->Regs);
  1050. p->Regs = NULL;
  1051. return ERR_NOT_SUPPORTED;
  1052. }
  1053. Detected = 1;
  1054. NodeRegSaveValue(XSCALEDRIVER_ID, XSCALEDRIVER_DETECTED, &Detected, sizeof(Detected), TYPE_BOOL);
  1055. }
  1057. p->AllocAtStart = 1;
  1058. p->SetupFlip = 1;
  1059. p->SetupStretch = (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_WMMX)==0;
  1060. return ERR_NONE;
  1061. }
  1063. static void DeleteDriver(xscaledriver* p)
  1064. {
  1065. if (p->Regs)
  1066. SetOrig(p);
  1068. FreeBuffer(p);
  1069. FreeOrig(p);
  1071. #ifdef X50V
  1072. if (p->GPIO)
  1073. {
  1074. PhyMemEnd(p->GPIO);
  1075. p->GPIO = NULL;
  1076. }
  1077. #endif
  1079. if (p->Regs)
  1080. {
  1081. PhyMemEnd(p->Regs);
  1082. p->Regs = NULL;
  1083. }
  1084. }
  1086. static const nodedef XScaleDriver = 
  1087. {
  1088. sizeof(xscaledriver)|CF_GLOBAL|CF_SETTINGS,
  1089. XSCALEDRIVER_ID,
  1090. NODE_CLASS,
  1091. PRI_DEFAULT,
  1092. (nodecreate)CreateDriver,
  1093. (nodedelete)DeleteDriver,
  1094. };
  1096. static const nodedef XScale = 
  1097. {
  1098. sizeof(xscale)|CF_GLOBAL,
  1099. XSCALE_ID,
  1100. OVERLAY_CLASS,
  1101. PRI_DEFAULT+97,
  1102. (nodecreate)Create,
  1103. };
  1105. static const nodedef XScaleLow = 
  1106. {
  1107. sizeof(xscale)|CF_GLOBAL,
  1108. XSCALE_LOW_ID,
  1109. XSCALE_ID,
  1110. PRI_DEFAULT+96,
  1111. };
  1113. void OverlayXScale_Init() 
  1114. { 
  1115. NodeRegisterClass(&XScaleDriver);
  1116. NodeRegisterClass(&XScale);
  1117. NodeRegisterClass(&XScaleLow);
  1118. }
  1120. void OverlayXScale_Done()
  1121. {
  1122. NodeUnRegisterClass(XSCALE_LOW_ID);
  1123. NodeUnRegisterClass(XSCALE_ID);
  1124. NodeUnRegisterClass(XSCALEDRIVER_ID);
  1125. }
  1127. #else
  1128. void OverlayXScale_Init() {}
  1129. void OverlayXScale_Done() {}
  1130. #endif