backup
/
gps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gps/GPSResources/tcpmp/common/overlay/overlay_xscale.c

1131 lines
24 KiB
C
Raw Normal View History

Init Projects
2019-05-01 12:32:35 +00:00
/*****************************************************************************
*
* This program is free software ; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: overlay_xscale.c 615 2006-01-26 16:57:51Z picard $
*
* The Core Pocket Media Player
* Copyright (c) 2004-2005 Gabor Kovacs
*
****************************************************************************/
#include "../common.h"
#define X50V // included in official version
#if defined(ARM)
#define WIN32_LEAN_AND_MEAN
#ifndef STRICT
#define STRICT
#endif
#include <windows.h>
#define MAXDESC 1024
#define MAXORIGBLOCK 8
#define MAXCOUNT 3
#define MAXDESCBLOCK 4
typedef struct xscaledesc
{
uint32_t Next;
uint32_t Base;
uint32_t Id;
uint32_t Cmd;
} xscaledesc;
typedef struct xscaledriver
{
node Node;
int Width;
int Height;
int BufferSize;
int MaxBlock;
bool_t AllocAtStart;
bool_t SetupFlip;
bool_t SetupStretch;
bool_t InAlloc;
bool_t AtStart;
struct xscale* Used;
int DescPhyCount[MAXCOUNT];
phymemblock DescPhy[MAXCOUNT][MAXDESCBLOCK];
xscaledesc* Desc[MAXCOUNT];
xscaledesc* DescLast[MAXCOUNT];
int* Map;
int BufferPhyCount[MAXCOUNT];
phymemblock* BufferPhy; // [MAXCOUNT][MaxBlock]
void* Buffer[MAXCOUNT];
int Count;
#ifdef X50V
uint32_t* GPIO;
uint32_t* Marathon;
bool_t X50v;
#endif
uint32_t* Regs;
uint32_t OrigDescPhy[MAXORIGBLOCK];
phymemblock OrigBufferPhy[MAXORIGBLOCK];
int OrigDescCount;
void* OrigBuffer;
int OrigBufferSize;
xscaledesc* OrigDescEnd;
bool_t OrigDescEndSet;
bool_t NotOrig;
} xscaledriver;
typedef struct xscale
{
overlay Overlay;
xscaledriver* Driver;
bool_t Flip;
int Next;
} xscale;
#define MAGIC 0xBABE0000
#define GPIO_BASE 0x40E00000
#define GPIO_SIZE 0x1000
#define LCD_BASE 0x44000000
#define LCD_SIZE 0x1000
#define LCCR0 (0x000/4)
#define LCCR1 (0x004/4)
#define LCCR2 (0x008/4)
#define LCCR3 (0x00C/4)
#define LCCR4 (0x010/4)
#define LCCR5 (0x014/4)
#define LCSR0 (0x038/4)
#define LCSR1 (0x034/4)
#define FBR0 (0x020/4)
#define FDADR0 (0x200/4)
#define FSADR0 (0x204/4)
#define FIDR0 (0x208/4)
#define GAFR1_U (0x060/4)
#define GAFR2_L (0x064/4)
#define LCD_CONFIG (0x03fe0060/4)
static void FreeOrig(xscaledriver* p)
{
int n;
// be sure that the old orig is not referenced by the buffers
for (n=0;n<p->Count;++n)
p->DescLast[n]->Next = p->DescPhy[n]->Addr;
// restore and release end descriptor
if (p->OrigDescEnd)
{
if (p->OrigDescEndSet)
{
p->OrigDescEnd->Next = p->OrigDescPhy[0];
p->OrigDescEndSet = 0;
}
PhyMemEnd(p->OrigDescEnd);
p->OrigDescEnd = NULL;
}
// release framebuffer
if (p->OrigBuffer)
{
PhyMemEnd(p->OrigBuffer);
p->OrigBuffer = NULL;
}
p->OrigDescCount = 0;
p->OrigBufferSize = 0;
p->NotOrig = 0;
}
static void GetOrig(xscaledriver* p)
{
uint32_t DescPhy[MAXORIGBLOCK]; // original descriptor head
xscaledesc Desc[MAXORIGBLOCK];
uint32_t Phy;
#ifdef X50V
if (p->X50v)
{
// create a fake desc chain with SRAM usage (like Loox720)
/*
int Left = 640*480*2 - 256*1024;
phymemblock Block2;
phymemblock Block;
int One = 1;
xscaledesc* d = (xscaledesc*) PhyMemAlloc(sizeof(xscaledesc)*2,&Block,&One);
if (!d)
return;
One = 1;
if (!PhyMemAlloc(Left,&Block2,&One))
return;
d[0].Base = Block2.Addr;
d[0].Cmd = Block2.Length;
d[0].Id = 0;
d[0].Next = Block.Addr + sizeof(xscaledesc);
d[1].Base = 0x5C000000;
d[1].Cmd = 256*1024 | (1<<21);
d[1].Id = 0;
d[1].Next = Block.Addr;
Phy = Block.Addr;
*/
Phy = 0;
}
else
#endif
{
Phy = p->Regs[FDADR0] & ~15;
p->Width = (p->Regs[LCCR1] & 1023)+1;
p->Height = (p->Regs[LCCR2] & 1023)+1;
}
if (Phy)
{
int n,m;
FreeOrig(p);
for (n=0;n<MAXORIGBLOCK;)
{
xscaledesc* d = (xscaledesc*) PhyMemBegin(Phy,sizeof(xscaledesc),0);
if (!d)
break;
DescPhy[n] = Phy;
Desc[n] = *d;
DEBUG_MSG4(-1,T("XScale %08x (%08x %08x %08x)"),Phy,Desc[n].Base,Desc[n].Cmd,Desc[n].Next);
++n;
Phy = d->Next & ~15;
PhyMemEnd(d);
for (m=0;m<n;++m)
if (DescPhy[m] == Phy)
{
int i,j;
if (n-m>1) // need to find end
{
for (i=m;i<n;++i)
if (Desc[i].Cmd & (1<<21))
{
++i;
if (i==n) i=m;
break;
}
if (i==n)
return; // failed
}
else
i=m; // there is only one desc
j=i;
do
{
p->OrigDescPhy[p->OrigDescCount] = DescPhy[j];
p->OrigBufferPhy[p->OrigDescCount].Addr = Desc[j].Base;
p->OrigBufferPhy[p->OrigDescCount].Length = Desc[j].Cmd & 0x1FFFFF;
p->OrigBufferSize += p->OrigBufferPhy[p->OrigDescCount].Length;
p->OrigDescCount++;
if (++j==n) j=m;
}
while (i!=j);
// map end descriptor so we don't have to use disable/enable for flipping (with multiple desc displays)
p->OrigDescEnd = (xscaledesc*) PhyMemBegin(p->OrigDescPhy[p->OrigDescCount-1],sizeof(xscaledesc),0);
if (p->OrigDescEnd && p->OrigDescEnd->Next != p->OrigDescPhy[0])
{
PhyMemEnd(p->OrigDescEnd);
p->OrigDescEnd = NULL;
}
// reuse original framebuffer
if (p->OrigBufferSize >= p->Width*2*p->Height)
p->OrigBuffer = PhyMemBeginEx(p->OrigBufferPhy,p->OrigDescCount,1);
return;
}
}
}
}
static bool_t FreeBuffer(xscaledriver* p)
{
int n;
if (!p->BufferPhy || p->InAlloc || p->Used)
return 0;
for (n=0;n<p->Count;++n)
{
PhyMemFree(p->Desc[n],p->DescPhy[n],p->DescPhyCount[n]);
if (n>0 || !p->OrigDescCount)
PhyMemFree(p->Buffer[n],p->BufferPhy+p->MaxBlock*n,p->BufferPhyCount[n]);
}
p->Count = 0;
p->MaxBlock = 0;
free(p->Map);
p->Map = NULL;
free(p->BufferPhy);
p->BufferPhy = NULL;
DEBUG_MSG(-1,T("XSCALE Freed"));
return 1;
}
static bool_t AllocBuffer(xscaledriver* p)
{
if (!p->BufferPhy && p->OrigBuffer)
{
int n;
p->BufferSize = (p->Width*2 * p->Height) & ~3;
p->MaxBlock = (p->BufferSize / 4096)+1;
p->BufferPhy = (phymemblock*) malloc(sizeof(phymemblock)*p->MaxBlock*MAXCOUNT);
if (!p->BufferPhy)
return 0;
p->Map = (int*) malloc(sizeof(int)*p->Height);
if (!p->Map)
{
free(p->BufferPhy);
p->BufferPhy = NULL;
return 0;
}
p->InAlloc = 1;
for (n=0;n<(p->SetupFlip?MAXCOUNT:1);++n)
{
// allocate desc table
p->DescPhyCount[n] = MAXDESCBLOCK;
p->Desc[n] = p->DescLast[n] = PhyMemAlloc(MAXDESC*sizeof(xscaledesc),p->DescPhy[n],&p->DescPhyCount[n]);
if (!p->Desc[n])
break;
if (n==0 && p->OrigBufferSize >= p->BufferSize)
{
// use original surface
p->Buffer[n] = p->OrigBuffer;
p->BufferPhyCount[n] = p->OrigDescCount;
memcpy(p->BufferPhy+p->MaxBlock*n,p->OrigBufferPhy,sizeof(phymemblock)*p->OrigDescCount);
}
else
{
// allocate new surface
p->BufferPhyCount[n] = p->MaxBlock;
p->Buffer[n] = PhyMemAlloc(p->BufferSize,p->BufferPhy+p->MaxBlock*n,&p->BufferPhyCount[n]);
}
if (!p->Buffer[n])
{
PhyMemFree(p->Desc[n],p->DescPhy[n],p->DescPhyCount[n]);
break;
}
}
if (n==2)
{
// can't flip chain with 2 surfaces (minimum is 3)
PhyMemFree(p->Desc[1],p->DescPhy[1],p->DescPhyCount[1]);
PhyMemFree(p->Buffer[1],p->BufferPhy+p->MaxBlock*1,p->BufferPhyCount[1]);
--n;
}
p->Count = n;
p->InAlloc = 0;
DEBUG_MSG5(-1,T("XSCALE %d %d %d %d %d"),p->Count,p->BufferPhyCount[0],p->BufferPhyCount[1],p->BufferPhyCount[2],AvailMemory());
}
return 1;
}
static void GetMode(xscale* p)
{
p->Overlay.Output.Format.Video.Width = p->Driver->Width;
p->Overlay.Output.Format.Video.Height = p->Driver->Height;
p->Overlay.Output.Format.Video.Direction = 0;
p->Overlay.Output.Format.Video.Aspect = ASPECT_ONE;
p->Overlay.Output.Format.Video.Pitch = p->Overlay.Output.Format.Video.Width*2;
DefaultRGB(&p->Overlay.Output.Format.Video.Pixel,16,5,6,5,0,0,0);
AdjustOrientation(&p->Overlay.Output.Format.Video,1);
if (p->Overlay.Output.Format.Video.Direction & DIR_SWAPXY)
{
int Model = QueryPlatform(PLATFORM_MODEL);
if (Model == MODEL_IPAQ_H3800 || Model == MODEL_IPAQ_H3900 ||
(Model == MODEL_NOVOGO && QueryPlatform(PLATFORM_VER)<500 && p->Driver->Width==240 && p->Driver->Height==320))
p->Overlay.Output.Format.Video.Direction ^= DIR_MIRRORLEFTRIGHT|DIR_MIRRORUPDOWN;
}
if (!((uint32_t)p->Driver->OrigBuffer & 15))
p->Overlay.Output.Format.Video.Pixel.Flags |= PF_16ALIGNED;
}
static int Init(xscale* p)
{
if (!p->Driver->OrigBuffer)
{
GetOrig(p->Driver);
if (!p->Driver->OrigBuffer)
return ERR_NOT_SUPPORTED;
}
GetMode(p);
p->Next = 0;
p->Flip = 0;
p->Overlay.SetFX = BLITFX_AVOIDTEARING;
if (p->Driver->Used)
return ERR_DEVICE_ERROR;
p->Driver->Used = p;
if (!AllocBuffer(p->Driver))
return ERR_OUT_OF_MEMORY;
if (p->Driver->Count >= 3)
p->Overlay.ClearFX = BLITFX_ONLYDIFF;
return ERR_NONE;
}
static void QuickDisable(xscaledriver* p)
{
int n = p->Regs[LCCR0];
n &= ~(1<<10); //DIS
n &= ~1; //ENB
p->Regs[LCCR0] = n;
Sleep(1);
}
static void Disable(xscaledriver* p)
{
int i;
int n = p->Regs[LCCR0];
if (n & 1)
{
n |= 1<<10; //DIS
p->Regs[LCCR0] = n;
for (i=0;i<30;++i)
{
if (!(p->Regs[LCCR0] & 1))
break;
Sleep(1);
}
if (i==30)
QuickDisable(p);
}
}
static void Enable(xscaledriver* p)
{
int n = p->Regs[LCCR0];
n &= ~(1<<10); //DIS
n |= 1; //EN;
p->Regs[LCCR0] = n;
Sleep(1);
}
static int GetCurrent2(xscaledriver* p)
{
int n;
int Id = p->Regs[FIDR0] & ~15;
uint32_t Phy = p->Regs[FDADR0] & ~15;
if ((Id & 0xFFFF0000) == MAGIC)
return (Id >> 4) & 0xFF;
for (n=0;n<p->OrigDescCount;++n)
if (Phy == p->OrigDescPhy[n] || Phy == p->OrigDescPhy[n]+sizeof(xscaledesc))
return -1;
return -2; // unknown
}
static int GetCurrent(xscaledriver* p)
{
int Current;
if (!(p->Regs[LCCR0] & 1))
return -2; // turned off lcd
Current = GetCurrent2(p);
if (Current >= -1)
return Current;
Sleep(50); // original desc chain has changed. maybe it's just temporary
Current = GetCurrent2(p);
if (Current >= -1)
return Current;
GetOrig(p); // reread original desc chain
return GetCurrent2(p);
}
#ifdef X50V
static void X50vDisable(xscaledriver* p)
{
if (p->Marathon[LCD_CONFIG] & (1<<16))
{
uint32_t v;
while ((v = p->Marathon[LCD_CONFIG]) & (1<<16))
p->Marathon[LCD_CONFIG] = v & ~0x1000A;
Disable(p);
v = p->GPIO[GAFR1_U];
if (v & 0xFFF00000)
p->GPIO[GAFR1_U] = v & 0xFFFFF;
v = p->GPIO[GAFR2_L];
if (v & 0xFFFFFFF)
p->GPIO[GAFR2_L] = v & 0xF0000000;
}
}
static bool_t X50vEnable(xscaledriver* p,uint32_t Desc)
{
bool_t Changed = 0;
if (!(p->Marathon[LCD_CONFIG] & (1<<16)))
{
uint32_t v;
Changed = 1;
Disable(p);
p->Regs[LCCR0] = 0x1B008F8;
p->Regs[LCCR1] = 0x1056FDDF;
p->Regs[LCCR2] = 0x104067F;
p->Regs[LCCR3] = 0x4f00001;
p->Regs[LCCR4] = 0;
p->Regs[LCCR5] = 0x3F3F3F3F;
p->Regs[FDADR0] = 0;
p->Regs[LCSR0] = 0;
v = p->GPIO[GAFR1_U];
if ((v & 0xFFF00000) != 0xAAA00000)
p->GPIO[GAFR1_U] = (v & 0xFFFFF) | 0xAAA00000;
v = p->GPIO[GAFR2_L];
if ((v & 0xFFFFFFF) != 0xAAAAAAA)
p->GPIO[GAFR2_L] = (v & 0xF0000000) | 0xAAAAAAA;
p->Regs[FDADR0] = Desc;
Enable(p);
QuickDisable(p);
p->Regs[FDADR0] = Desc;
Enable(p);
while (!((v = p->Marathon[LCD_CONFIG]) & (1<<16)))
{
p->Marathon[LCD_CONFIG] = v | 0x1000A;
Sleep(1);
}
}
return Changed;
}
#endif
static void SetOrig(xscaledriver* p)
{
int n;
#ifdef X50V
if (p->X50v)
X50vDisable(p);
else
#endif
{
if (p->NotOrig)
{
if (p->OrigDescEnd && p->OrigDescEndSet)
{
p->OrigDescEnd->Next = p->OrigDescPhy[0];
p->OrigDescEndSet = 0;
}
for (n=0;n<p->Count;++n)
p->DescLast[n]->Next = p->OrigDescPhy[0];
// wait for primary to be restored
for (n=0;n<100;++n)
{
if (GetCurrent(p)<0)
break;
Sleep(1);
}
p->NotOrig = 0;
}
}
}
static void Done(xscale* p)
{
SetOrig(p->Driver);
if (p->Driver->Used == p)
p->Driver->Used = NULL;
}
static int Reset(xscale* p)
{
Done(p);
Init(p);
return ERR_NONE;
}
static xscaledesc* BuildDesc(xscaledesc* Desc,phymemblock* DescPhy,int DescPhyCount,phymemblock* BufferPhy,int BufferPhyCount,
int* Map,int Pitch,int Height,int Id)
{
uint32_t First = DescPhy->Addr;
uint32_t Last = 0;
uint32_t DescAddr = 0;
int n,m;
for (n=0;n<Height;++n)
{
uint32_t Pos = Pitch * Map[n];
int Length = Pitch;
for (m=0;Length>0 && m<BufferPhyCount;++m)
{
if (Pos < BufferPhy[m].Length)
{
uint32_t Addr = BufferPhy[m].Addr + Pos;
int Size = BufferPhy[m].Length - Pos;
if (Size > Length)
Size = Length;
if (Size & 3) return NULL; // this shouldn't happen
// add desc
if (Addr != Last)
{
DescAddr += sizeof(xscaledesc);
if (DescAddr > DescPhy->Length)
{
// next desc block
if (--DescPhyCount==0) return NULL; // not enough desc...
++DescPhy;
DescAddr = 0;
}
Desc->Next = DescPhy->Addr + DescAddr;
Desc->Base = Addr;
Desc->Id = Id;
Desc->Cmd = Size;
++Desc;
}
else
Desc[-1].Cmd += Size;
Last = Addr + Size;
Length -= Size;
Pos += Size;
}
Pos -= BufferPhy[m].Length;
}
}
--Desc;
Desc->Next = First;
Desc->Cmd |= (1<<21);
return Desc;
}
static bool_t Build(xscaledriver* p)
{
int n;
for (n=0;n<p->Count;++n)
{
p->DescLast[n] = BuildDesc(p->Desc[n],p->DescPhy[n],p->DescPhyCount[n],p->BufferPhy+p->MaxBlock*n,
p->BufferPhyCount[n],p->Map,p->Width*2,p->Height,MAGIC | (n<<4));
if (!p->DescLast[n])
break;
}
if (n==p->Count)
{
for (n=p->OrigDescCount?1:0;n<p->Count;++n)
memset(p->Buffer[n],0,p->BufferSize);
return 1;
}
return 0;
}
static int UpdateAlign(xscale* p)
{
rect FullScreen;
int* ScaleY;
blitfx FX = p->Overlay.FX;
bool_t FullView;
if (FX.Direction & DIR_SWAPXY)
ScaleY = &FX.ScaleX;
else
ScaleY = &FX.ScaleY;
PhyToVirt(NULL,&FullScreen,&p->Overlay.Output.Format.Video);
FullView = p->Driver->Count && EqRect(&FullScreen,&p->Overlay.Viewport);
if (FullView && p->Driver->Count>=3)
p->Overlay.FX.Flags &= ~BLITFX_AVOIDTEARING; //flipping used
p->Flip = 0;
p->Next = 0;
SetOrig(p->Driver);
OverlayUpdateAlign(&p->Overlay);
if (FullView && p->Driver->Count)
{
int n;
for (n=0;n<p->Overlay.Output.Format.Video.Height;++n)
p->Driver->Map[n]=n;
if (p->Driver->SetupStretch &&
((p->Overlay.Node.Class == XSCALE_LOW_ID && *ScaleY > SCALE_ONE/2) || *ScaleY > SCALE_ONE) &&
!(p->Overlay.Output.Format.Video.Width & 1) && p->Overlay.Output.Format.Video.Height>0)
{
int Num,Den;
int Adj;
int LowSrc,HighSrc,CenterSrc;
rect DstAlignedRect;
rect SrcAlignedRect;
*ScaleY = p->Overlay.Node.Class == XSCALE_LOW_ID ? SCALE_ONE/2 : SCALE_ONE;
VirtToPhy(&p->Overlay.Viewport,&DstAlignedRect,&p->Overlay.Output.Format.Video);
VirtToPhy(NULL,&SrcAlignedRect,&p->Overlay.Input.Format.Video);
BlitRelease(p->Overlay.Soft);
p->Overlay.Soft = BlitCreate(&p->Overlay.Output.Format.Video,&p->Overlay.Input.Format.Video,&FX,&p->Overlay.Caps);
BlitAlign(p->Overlay.Soft, &DstAlignedRect, &SrcAlignedRect );
LowSrc = -(DstAlignedRect.Height/2);
HighSrc = LowSrc + DstAlignedRect.Height;
CenterSrc = DstAlignedRect.y - LowSrc;
Num = DstAlignedRect.Height;
Den = p->Overlay.DstAlignedRect.Height;
if (FX.Direction & DIR_SWAPXY)
{
Num *= p->Overlay.SrcAlignedRect.Width;
Den *= SrcAlignedRect.Width;
}
else
{
Num *= p->Overlay.SrcAlignedRect.Height;
Den *= SrcAlignedRect.Height;
}
Adj = Scale(p->Overlay.DstAlignedRect.Height,Num,2*Den);
for (n=0;n<p->Overlay.DstAlignedRect.Height;++n)
{
int i = Scale(n,Num,Den) - Adj;
if (i >= HighSrc) i=HighSrc-1;
if (i < LowSrc) i=LowSrc;
p->Driver->Map[p->Overlay.DstAlignedRect.y+n] = CenterSrc + i;
}
}
if (Build(p->Driver))
{
p->Overlay.FX.Flags |= BLITFX_AVOIDTEARING; //restore
p->Flip = 1;
}
}
return ERR_NONE;
}
static void Restore(xscaledriver* p,int Next)
{
int n;
char *s,*d;
char *Src = (char*)p->Buffer[Next];
char *Dst = (char*)p->OrigBuffer;
int Middle = p->Height/2;
int Pitch = p->Width*2;
for (n=0;n<Middle;++n)
{
s = Src + p->Map[n] * Pitch;
d = Dst + n*Pitch;
if (s != d)
memcpy(d,s,Pitch);
}
for (n=p->Height-1;n>=Middle;--n)
{
s = Src + p->Map[n] * Pitch;
d = Dst + n*Pitch;
if (s != d)
memcpy(d,s,Pitch);
}
}
static int UpdateShow(xscale* p)
{
if (!p->Overlay.Show)
{
SetOrig(p->Driver);
if (p->Flip)
{
// restore after SetOrig because it's vsynced and restore starts for upper part anyway
Restore(p->Driver,p->Next);
}
p->Next = 0;
}
return ERR_NONE;
}
static int Lock(xscale* p, planes Planes, bool_t OnlyAligned )
{
if (p->Flip)
{
int Next = p->Next+1;
if (Next == p->Driver->Count)
Next = 0;
// use new buffer only if it's not the current
if (GetCurrent(p->Driver) != Next)
p->Next = Next;
Planes[0] = p->Driver->Buffer[p->Next];
}
else
Planes[0] = p->Driver->OrigBuffer;
return ERR_NONE;
}
static int Unlock(xscale* p )
{
if (p->Flip)
{
int Current = GetCurrent(p->Driver);
uint32_t DescPhy = p->Driver->DescPhy[p->Next]->Addr;
// close chain
p->Driver->DescLast[p->Next]->Next = DescPhy;
#ifdef X50V
if (p->Driver->X50v && X50vEnable(p->Driver,DescPhy))
Current = p->Next;
#endif
DEBUG_MSG4(-1,T("%08x %08x %08x %d"),p->Driver->Regs[LCCR0],p->Driver->Regs[LCCR3],p->Driver->Regs[FDADR0],Current);
if (Current<-1)
return ERR_DEVICE_ERROR;
if (Current<0)
{
if (p->Driver->OrigDescEnd)
{
p->Driver->OrigDescEnd->Next = DescPhy;
p->Driver->OrigDescEndSet = 1;
}
else
if (p->Driver->OrigDescCount>1)
{
// multi desc original
bool_t Old = (p->Driver->Regs[LCCR0] & 1);
Disable(p->Driver);
p->Driver->Regs[FBR0] = 0;
p->Driver->Regs[FDADR0] = DescPhy;
if (Old) Enable(p->Driver);
}
else // simply branch
p->Driver->Regs[FBR0] = DescPhy | 1;
}
else
{
// modify last frames tail to new frame
Current = p->Next-1;
if (Current<0)
Current = p->Driver->Count-1;
p->Driver->DescLast[Current]->Next = DescPhy;
}
p->Driver->NotOrig = 1;
}
return ERR_NONE;
}
static int UpdateStretch(xscaledriver* Driver)
{
if (Driver->Used)
UpdateAlign(Driver->Used);
return ERR_NONE;
}
static int UpdateFlip(xscaledriver* Driver)
{
if (Driver->Used)
{
xscale* p = Driver->Used;
Done(p);
FreeBuffer(Driver);
Init(p);
UpdateAlign(p);
p->Overlay.Dirty = 1;
p->Overlay.LastTime = -1;
}
return ERR_NONE;
}
static const datatable Params[] =
{
{ XSCALEDRIVER_STRETCH, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
{ XSCALEDRIVER_FLIP, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
{ XSCALEDRIVER_ALLOC_AT_START, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
DATATABLE_END(XSCALEDRIVER_ID)
};
static int Enum(xscaledriver* p, int* No, datadef* Param)
{
return NodeEnumTable(No,Param,Params);
}
static int Get(xscaledriver* p,int No,void* Data,int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case XSCALEDRIVER_STRETCH: GETVALUE(p->SetupStretch,bool_t); break;
case XSCALEDRIVER_FLIP: GETVALUE(p->SetupFlip,bool_t); break;
case XSCALEDRIVER_ALLOC_AT_START: GETVALUE(p->AllocAtStart,bool_t); break;
}
return Result;
}
static bool_t Selected()
{
int Id;
return NodeRegLoadValue(PLAYER_ID,PLAYER_VOUTPUTID,&Id,sizeof(Id),TYPE_INT) && (Id == XSCALE_ID || Id == XSCALE_LOW_ID);
}
static int Set(xscaledriver* p,int No,const void* Data,int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case XSCALEDRIVER_STRETCH: SETVALUECMP(p->SetupStretch,bool_t,UpdateStretch(p),EqBool); break;
case XSCALEDRIVER_FLIP: SETVALUECMP(p->SetupFlip,bool_t,UpdateFlip(p),EqBool); break;
case XSCALEDRIVER_ALLOC_AT_START: SETVALUE(p->AllocAtStart,bool_t,ERR_NONE); break;
case NODE_SETTINGSCHANGED:
if (p->AllocAtStart && p->AtStart && Selected())
{
if (!p->OrigBuffer)
GetOrig(p);
AllocBuffer(p);
}
p->AtStart = 0;
break;
case NODE_HIBERNATE:
if (!p->Used && FreeBuffer(p))
Result = ERR_NONE;
break;
}
return Result;
}
static int Create(xscale* p)
{
p->Driver = (xscaledriver*)NodeEnumObject(NULL,XSCALEDRIVER_ID);
if (!p->Driver)
return ERR_NOT_SUPPORTED;
if (p->Overlay.Node.Class == XSCALE_LOW_ID && (p->Driver->Width*p->Driver->Height <= 320*240 ||
(QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_WMMX)!=0))
return ERR_NOT_SUPPORTED;
GetMode(p);
p->Overlay.Init = Init;
p->Overlay.Done= Done;
p->Overlay.Reset = Reset;
p->Overlay.Update = UpdateAlign;
p->Overlay.UpdateShow = UpdateShow;
p->Overlay.Lock = Lock;
p->Overlay.Unlock = Unlock;
return ERR_NONE;
}
static int CreateDriver(xscaledriver* p)
{
bool_t Detected;
int Caps = QueryPlatform(PLATFORM_CAPS);
if (!(Caps & CAPS_ARM_XSCALE))
return ERR_NOT_SUPPORTED;
p->Node.Enum = Enum;
p->Node.Get = Get;
p->Node.Set = Set;
p->AtStart = 1;
p->OrigBuffer = NULL;
p->OrigDescCount = 0;
p->Regs = (uint32_t*)PhyMemBegin(LCD_BASE,LCD_SIZE,0);
if (!p->Regs)
return ERR_NOT_SUPPORTED;
#ifdef X50V
p->X50v = QueryPlatform(PLATFORM_MODEL)==MODEL_AXIM_X50 && CheckModule(T("pvrvadd.dll"));
if (p->X50v)
{
p->Width = 480;
p->Height = 640;
p->Marathon = (uint32_t*) 0xBC000000;
p->GPIO = (uint32_t*) PhyMemBegin(GPIO_BASE,GPIO_SIZE,0);
if (p->GPIO)
{
RawFrameBufferInfo Info;
HDC DC= GetDC(NULL);
memset(&Info,0,sizeof(Info));
ExtEscape(DC, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char*)&Info);
ReleaseDC(NULL,DC);
p->OrigBuffer = Info.pFramePointer;
}
}
else
#endif
if (!(p->Regs[LCCR0] & 1) || ((p->Regs[LCCR3] >> 24) & 7)!=4) // LCD enabled, RGB 16bit
return ERR_NOT_SUPPORTED;
if (!NodeRegLoadValue(XSCALEDRIVER_ID, XSCALEDRIVER_DETECTED, &Detected, sizeof(Detected), TYPE_BOOL) || !Detected)
{
GetOrig(p);
if (!p->OrigBuffer)
{
PhyMemEnd(p->Regs);
p->Regs = NULL;
return ERR_NOT_SUPPORTED;
}
Detected = 1;
NodeRegSaveValue(XSCALEDRIVER_ID, XSCALEDRIVER_DETECTED, &Detected, sizeof(Detected), TYPE_BOOL);
}
p->AllocAtStart = 1;
p->SetupFlip = 1;
p->SetupStretch = (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_WMMX)==0;
return ERR_NONE;
}
static void DeleteDriver(xscaledriver* p)
{
if (p->Regs)
SetOrig(p);
FreeBuffer(p);
FreeOrig(p);
#ifdef X50V
if (p->GPIO)
{
PhyMemEnd(p->GPIO);
p->GPIO = NULL;
}
#endif
if (p->Regs)
{
PhyMemEnd(p->Regs);
p->Regs = NULL;
}
}
static const nodedef XScaleDriver =
{
sizeof(xscaledriver)|CF_GLOBAL|CF_SETTINGS,
XSCALEDRIVER_ID,
NODE_CLASS,
PRI_DEFAULT,
(nodecreate)CreateDriver,
(nodedelete)DeleteDriver,
};
static const nodedef XScale =
{
sizeof(xscale)|CF_GLOBAL,
XSCALE_ID,
OVERLAY_CLASS,
PRI_DEFAULT+97,
(nodecreate)Create,
};
static const nodedef XScaleLow =
{
sizeof(xscale)|CF_GLOBAL,
XSCALE_LOW_ID,
XSCALE_ID,
PRI_DEFAULT+96,
};
void OverlayXScale_Init()
{
NodeRegisterClass(&XScaleDriver);
NodeRegisterClass(&XScale);
NodeRegisterClass(&XScaleLow);
}
void OverlayXScale_Done()
{
NodeUnRegisterClass(XSCALE_LOW_ID);
NodeUnRegisterClass(XSCALE_ID);
NodeUnRegisterClass(XSCALEDRIVER_ID);
}
#else
void OverlayXScale_Init() {}
void OverlayXScale_Done() {}
#endif