714 lines
15 KiB
C
Executable File
714 lines
15 KiB
C
Executable File
/*****************************************************************************
|
|
*
|
|
* 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: helper_video.c 548 2006-01-08 22:41:57Z picard $
|
|
*
|
|
* The Core Pocket Media Player
|
|
* Copyright (c) 2004-2005 Gabor Kovacs
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "common.h"
|
|
|
|
bool_t EqSubtitle(const subtitle* a, const subtitle* b)
|
|
{
|
|
return a->FourCC == b->FourCC;
|
|
}
|
|
|
|
bool_t EqAudio(const audio* a, const audio* b)
|
|
{
|
|
return a->Bits == b->Bits &&
|
|
a->Channels == b->Channels &&
|
|
a->SampleRate == b->SampleRate &&
|
|
a->FracBits == b->FracBits &&
|
|
a->Flags == b->Flags &&
|
|
a->Format == b->Format;
|
|
}
|
|
|
|
bool_t EqFrac(const fraction* a, const fraction* b)
|
|
{
|
|
if (a->Den == b->Den && a->Num == b->Num)
|
|
return 1;
|
|
if (!a->Den) return b->Den==0;
|
|
if (!b->Den) return 0;
|
|
return (int64_t)b->Den * a->Num == (int64_t)a->Den * b->Num;
|
|
}
|
|
|
|
int BitMaskSize(uint32_t Mask)
|
|
{
|
|
int i;
|
|
for (i=0;Mask;++i)
|
|
Mask &= Mask - 1;
|
|
return i;
|
|
}
|
|
|
|
int BitMaskPos(uint32_t Mask)
|
|
{
|
|
int i;
|
|
for (i=0;Mask && !(Mask&1);++i)
|
|
Mask >>= 1;
|
|
return i;
|
|
}
|
|
|
|
int ScaleRound(int v,int Num,int Den)
|
|
{
|
|
int64_t i;
|
|
if (!Den)
|
|
return 0;
|
|
i = (int64_t)v * Num;
|
|
if (i<0)
|
|
i-=Den/2;
|
|
else
|
|
i+=Den/2;
|
|
i/=Den;
|
|
return (int)i;
|
|
}
|
|
|
|
void FillColor(uint8_t* Dst,int DstPitch,int x,int y,int Width,int Height,int BPP,int Value)
|
|
{
|
|
if (Width>0 && Height>0)
|
|
{
|
|
uint16_t *p16,*p16e;
|
|
uint32_t *p32,*p32e;
|
|
uint8_t* End;
|
|
|
|
Dst += y*DstPitch + (x*BPP)/8;
|
|
End = Dst + Height * DstPitch;
|
|
do
|
|
{
|
|
switch (BPP)
|
|
{
|
|
case 1:
|
|
Value &= 1;
|
|
memset(Dst,Value * 0xFF,Width >> 3);
|
|
break;
|
|
case 2:
|
|
Value &= 3;
|
|
memset(Dst,Value * 0x55,Width >> 2);
|
|
break;
|
|
case 4:
|
|
Value &= 15;
|
|
memset(Dst,Value * 0x11,Width >> 1);
|
|
break;
|
|
case 8:
|
|
memset(Dst,Value,Width);
|
|
break;
|
|
case 16:
|
|
p16 = (uint16_t*)Dst;
|
|
p16e = p16+Width;
|
|
for (;p16!=p16e;++p16)
|
|
*p16 = (uint16_t)Value;
|
|
break;
|
|
case 32:
|
|
p32 = (uint32_t*)Dst;
|
|
p32e = p32+Width;
|
|
for (;p32!=p32e;++p32)
|
|
*p32 = Value;
|
|
break;
|
|
}
|
|
Dst += DstPitch;
|
|
}
|
|
while (Dst != End);
|
|
}
|
|
}
|
|
|
|
bool_t EqBlitFX(const blitfx* a, const blitfx* b)
|
|
{
|
|
return a->Flags == b->Flags &&
|
|
a->Contrast == b->Contrast &&
|
|
a->Saturation == b->Saturation &&
|
|
a->Brightness == b->Brightness &&
|
|
a->Direction == b->Direction &&
|
|
a->RGBAdjust[0] == b->RGBAdjust[0] &&
|
|
a->RGBAdjust[1] == b->RGBAdjust[1] &&
|
|
a->RGBAdjust[2] == b->RGBAdjust[2] &&
|
|
a->ScaleX == b->ScaleX &&
|
|
a->ScaleY == b->ScaleY;
|
|
}
|
|
|
|
int CombineDir(int Src, int Blit, int Dst)
|
|
{
|
|
//order of transformations
|
|
// SrcMirror
|
|
// SrcSwap
|
|
// BlitSwap
|
|
// BlitMirror
|
|
// DstSwap
|
|
// DstMirror
|
|
|
|
//should be combined to a single
|
|
// Swap
|
|
// Mirror
|
|
|
|
if (Dst & DIR_SWAPXY)
|
|
{
|
|
if (Blit & DIR_MIRRORLEFTRIGHT)
|
|
Dst ^= DIR_MIRRORUPDOWN;
|
|
if (Blit & DIR_MIRRORUPDOWN)
|
|
Dst ^= DIR_MIRRORLEFTRIGHT;
|
|
}
|
|
else
|
|
Dst ^= Blit & (DIR_MIRRORUPDOWN|DIR_MIRRORLEFTRIGHT);
|
|
Dst ^= Blit & DIR_SWAPXY;
|
|
Dst ^= Src & DIR_SWAPXY;
|
|
if (Dst & DIR_SWAPXY)
|
|
{
|
|
if (Src & DIR_MIRRORLEFTRIGHT)
|
|
Dst ^= DIR_MIRRORUPDOWN;
|
|
if (Src & DIR_MIRRORUPDOWN)
|
|
Dst ^= DIR_MIRRORLEFTRIGHT;
|
|
}
|
|
else
|
|
Dst ^= Src & (DIR_MIRRORUPDOWN|DIR_MIRRORLEFTRIGHT);
|
|
|
|
return Dst;
|
|
}
|
|
|
|
int SurfaceRotate(const video* SrcFormat, const video* DstFormat,
|
|
const planes Src, planes Dst, int Dir)
|
|
{
|
|
blitfx FX;
|
|
memset(&FX,0,sizeof(FX));
|
|
FX.ScaleX = SCALE_ONE;
|
|
FX.ScaleY = SCALE_ONE;
|
|
FX.Direction = Dir;
|
|
return SurfaceCopy(SrcFormat,DstFormat,Src,Dst,&FX);
|
|
}
|
|
|
|
|
|
int SurfaceCopy(const video* SrcFormat, const video* DstFormat,
|
|
const planes Src, planes Dst, const blitfx* FX)
|
|
{
|
|
void* Blit;
|
|
rect SrcRect;
|
|
rect DstRect;
|
|
|
|
VirtToPhy(NULL,&SrcRect,SrcFormat);
|
|
VirtToPhy(NULL,&DstRect,DstFormat);
|
|
|
|
Blit = BlitCreate(DstFormat,SrcFormat,FX,NULL);
|
|
if (!Blit)
|
|
return ERR_NOT_SUPPORTED;
|
|
|
|
BlitAlign(Blit,&DstRect,&SrcRect);
|
|
BlitImage(Blit,Dst,*(const constplanes*)Src,NULL,-1,-1);
|
|
BlitRelease(Blit);
|
|
|
|
return ERR_NONE;
|
|
}
|
|
|
|
int SurfaceAlloc(planes Ptr, const video* p)
|
|
{
|
|
int i;
|
|
for (i=0;i<MAXPLANES;++i)
|
|
Ptr[i] = NULL;
|
|
|
|
if (p->Pixel.Flags & (PF_YUV420|PF_YUV422|PF_YUV444|PF_YUV410))
|
|
{
|
|
int x,y,s;
|
|
PlanarYUV(&p->Pixel,&x,&y,&s);
|
|
Ptr[0] = Alloc16(p->Height * p->Pitch);
|
|
Ptr[1] = Alloc16((p->Height>>y) * (p->Pitch>>s));
|
|
Ptr[2] = Alloc16((p->Height>>y) * (p->Pitch>>s));
|
|
if (!Ptr[0] || !Ptr[1] || !Ptr[2])
|
|
{
|
|
SurfaceFree(Ptr);
|
|
return ERR_OUT_OF_MEMORY;
|
|
}
|
|
return ERR_NONE;
|
|
}
|
|
Ptr[0] = Alloc16(GetImageSize(p));
|
|
return Ptr[0] ? ERR_NONE : ERR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
void SurfaceFree(planes p)
|
|
{
|
|
int i;
|
|
for (i=0;i<MAXPLANES;++i)
|
|
{
|
|
Free16(p[i]);
|
|
p[i] = NULL;
|
|
}
|
|
}
|
|
|
|
int DefaultAspect(int Width,int Height)
|
|
{
|
|
return ASPECT_ONE; //todo?
|
|
}
|
|
|
|
void DefaultPitch(video* p)
|
|
{
|
|
p->Pitch = p->Width*GetBPP(&p->Pixel);
|
|
if (p->Pixel.Flags & PF_RGB)
|
|
p->Pitch = ((p->Pitch+31)>>5)*4; // dword align
|
|
else
|
|
p->Pitch = (p->Pitch+7)>>3; // byte align
|
|
}
|
|
|
|
void DefaultRGB(pixel* p, int BitCount,
|
|
int RBits, int GBits, int BBits,
|
|
int RGaps, int GGaps, int BGaps)
|
|
{
|
|
p->Flags = PF_RGB;
|
|
p->BitCount = BitCount;
|
|
p->BitMask[0] = ((1<<RBits)-1) << (RGaps+GBits+GGaps+BBits+BGaps);
|
|
p->BitMask[1] = ((1<<GBits)-1) << (GGaps+BBits+BGaps);
|
|
p->BitMask[2] = ((1<<BBits)-1) << (BGaps);
|
|
}
|
|
|
|
bool_t Compressed(const pixel* Fmt)
|
|
{
|
|
return (Fmt->Flags & PF_FOURCC) && !AnyYUV(Fmt);
|
|
}
|
|
|
|
bool_t PlanarYUV(const pixel* Fmt, int* x, int* y,int *s)
|
|
{
|
|
if (PlanarYUV420(Fmt))
|
|
{
|
|
if (x) *x = 1;
|
|
if (y) *y = 1;
|
|
if (s)
|
|
{
|
|
if (Fmt->Flags & PF_FOURCC &&
|
|
((Fmt->FourCC == FOURCC_IMC2) || (Fmt->FourCC == FOURCC_IMC4)))
|
|
*s = 0; // interleaved uv scanlines
|
|
else
|
|
*s = 1;
|
|
}
|
|
return 1;
|
|
|
|
}
|
|
if (PlanarYUV422(Fmt))
|
|
{
|
|
if (x) *x = 1;
|
|
if (s) *s = 1;
|
|
if (y) *y = 0;
|
|
return 1;
|
|
|
|
}
|
|
if (PlanarYUV444(Fmt))
|
|
{
|
|
if (x) *x = 0;
|
|
if (y) *y = 0;
|
|
if (s) *s = 0;
|
|
return 1;
|
|
}
|
|
if (PlanarYUV410(Fmt))
|
|
{
|
|
if (x) *x = 2;
|
|
if (s) *s = 2;
|
|
if (y) *y = 2;
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (x) *x = 0;
|
|
if (y) *y = 0;
|
|
if (s) *s = 0;
|
|
return 0;
|
|
}
|
|
|
|
typedef struct rgbfourcc
|
|
{
|
|
uint32_t FourCC;
|
|
int BitCount;
|
|
uint32_t BitMask[3];
|
|
|
|
} rgbfourcc;
|
|
|
|
static const rgbfourcc RGBFourCC[] =
|
|
{
|
|
{ FOURCC_RGB32, 32, { 0xFF0000, 0xFF00, 0xFF }},
|
|
{ FOURCC_RGB24, 24, { 0xFF0000, 0xFF00, 0xFF }},
|
|
{ FOURCC_RGB16, 16, { 0xF800, 0x07E0, 0x001F }},
|
|
{ FOURCC_RGB15, 16, { 0x7C00, 0x03E0, 0x001F }},
|
|
{ FOURCC_BGR32, 32, { 0xFF, 0xFF00, 0xFF0000 }},
|
|
{ FOURCC_BGR24, 24, { 0xFF, 0xFF00, 0xFF0000 }},
|
|
{ FOURCC_BGR16, 16, { 0x001F, 0x07E0, 0xF800 }},
|
|
{ FOURCC_BGR15, 16, { 0x001F, 0x03E0, 0x7C00 }},
|
|
{0},
|
|
};
|
|
|
|
uint32_t DefFourCC(const pixel* Fmt)
|
|
{
|
|
uint32_t FourCC=0;
|
|
if (Fmt->Flags & PF_YUV420)
|
|
return FOURCC_I420;
|
|
if (Fmt->Flags & PF_YUV422)
|
|
return FOURCC_YV16;
|
|
if (Fmt->Flags & PF_YUV410)
|
|
return FOURCC_YUV9;
|
|
|
|
if (Fmt->Flags & PF_FOURCC)
|
|
{
|
|
FourCC = Fmt->FourCC;
|
|
if (FourCC == FOURCC_YVU9)
|
|
FourCC = FOURCC_YUV9;
|
|
if (FourCC == FOURCC_IYUV || FourCC == FOURCC_YV12)
|
|
FourCC = FOURCC_I420;
|
|
if (FourCC == FOURCC_YUNV || FourCC == FOURCC_V422 || FourCC == FOURCC_YUYV)
|
|
FourCC = FOURCC_YUY2;
|
|
if (FourCC == FOURCC_Y422 || FourCC == FOURCC_UYNV)
|
|
FourCC = FOURCC_UYVY;
|
|
}
|
|
else
|
|
if (Fmt->Flags & PF_RGB)
|
|
{
|
|
const rgbfourcc *i;
|
|
for (i=RGBFourCC;i->FourCC;++i)
|
|
if (i->BitCount == Fmt->BitCount &&
|
|
i->BitMask[0] == Fmt->BitMask[0] &&
|
|
i->BitMask[1] == Fmt->BitMask[1] &&
|
|
i->BitMask[2] == Fmt->BitMask[2])
|
|
{
|
|
FourCC = i->FourCC;
|
|
break;
|
|
}
|
|
}
|
|
return FourCC;
|
|
}
|
|
|
|
bool_t PlanarYUV420(const pixel* Fmt)
|
|
{
|
|
if (Fmt->Flags & PF_YUV420)
|
|
return 1;
|
|
|
|
return (Fmt->Flags & PF_FOURCC) &&
|
|
((Fmt->FourCC == FOURCC_YV12) ||
|
|
(Fmt->FourCC == FOURCC_IYUV) ||
|
|
(Fmt->FourCC == FOURCC_I420) ||
|
|
(Fmt->FourCC == FOURCC_IMC2) ||
|
|
(Fmt->FourCC == FOURCC_IMC4));
|
|
}
|
|
|
|
bool_t PlanarYUV410(const pixel* Fmt)
|
|
{
|
|
if (Fmt->Flags & PF_YUV410)
|
|
return 1;
|
|
|
|
return (Fmt->Flags & PF_FOURCC) &&
|
|
((Fmt->FourCC == FOURCC_YVU9) ||
|
|
(Fmt->FourCC == FOURCC_YUV9));
|
|
}
|
|
|
|
bool_t PlanarYUV422(const pixel* Fmt)
|
|
{
|
|
if (Fmt->Flags & PF_YUV422)
|
|
return 1;
|
|
|
|
return (Fmt->Flags & PF_FOURCC) && (Fmt->FourCC == FOURCC_YV16);
|
|
}
|
|
|
|
bool_t PlanarYUV444(const pixel* Fmt)
|
|
{
|
|
return (Fmt->Flags & PF_YUV444) != 0;
|
|
}
|
|
|
|
bool_t PackedYUV(const pixel* Fmt)
|
|
{
|
|
return (Fmt->Flags & PF_FOURCC) &&
|
|
|
|
((Fmt->FourCC == FOURCC_YUY2) ||
|
|
(Fmt->FourCC == FOURCC_YUNV) ||
|
|
(Fmt->FourCC == FOURCC_V422) ||
|
|
(Fmt->FourCC == FOURCC_YUYV) ||
|
|
(Fmt->FourCC == FOURCC_VYUY) ||
|
|
(Fmt->FourCC == FOURCC_UYVY) ||
|
|
(Fmt->FourCC == FOURCC_Y422) ||
|
|
(Fmt->FourCC == FOURCC_YVYU) ||
|
|
(Fmt->FourCC == FOURCC_UYNV));
|
|
}
|
|
|
|
bool_t AnyYUV(const pixel* Fmt)
|
|
{
|
|
return PlanarYUV420(Fmt) ||
|
|
PlanarYUV410(Fmt) ||
|
|
PlanarYUV422(Fmt) ||
|
|
PlanarYUV444(Fmt) ||
|
|
PackedYUV(Fmt);
|
|
}
|
|
|
|
uint32_t RGBToFormat(rgbval_t RGB, const pixel* Fmt)
|
|
{
|
|
uint32_t v;
|
|
int R,G,B;
|
|
int Y,U,V;
|
|
int Pos[3];
|
|
|
|
R = (INT32LE(RGB) >> 0) & 255;
|
|
G = (INT32LE(RGB) >> 8) & 255;
|
|
B = (INT32LE(RGB) >> 16) & 255;
|
|
|
|
if (AnyYUV(Fmt))
|
|
{
|
|
Y = ((2105 * R) + (4128 * G) + (802 * B))/0x2000 + 16;
|
|
V = ((3596 * R) - (3015 * G) - (582 * B))/0x2000 + 128;
|
|
U = (-(1212 * R) - (2384 * G) + (3596 * B))/0x2000 + 128;
|
|
|
|
if (Fmt->Flags & PF_INVERTED)
|
|
{
|
|
Y ^= 255;
|
|
U ^= 255;
|
|
V ^= 255;
|
|
}
|
|
v = (Fmt->BitMask[0] / 255) * Y;
|
|
v += (Fmt->BitMask[1] / 255) * U;
|
|
v += (Fmt->BitMask[2] / 255) * V;
|
|
}
|
|
else
|
|
{
|
|
if (Fmt->Flags & PF_INVERTED)
|
|
{
|
|
R ^= 255;
|
|
G ^= 255;
|
|
B ^= 255;
|
|
}
|
|
|
|
Pos[0] = BitMaskPos(Fmt->BitMask[0]) + BitMaskSize(Fmt->BitMask[0]);
|
|
Pos[1] = BitMaskPos(Fmt->BitMask[1]) + BitMaskSize(Fmt->BitMask[1]);
|
|
Pos[2] = BitMaskPos(Fmt->BitMask[2]) + BitMaskSize(Fmt->BitMask[2]);
|
|
|
|
v = ((R << Pos[0]) & (Fmt->BitMask[0] << 8)) |
|
|
((G << Pos[1]) & (Fmt->BitMask[1] << 8)) |
|
|
((B << Pos[2]) & (Fmt->BitMask[2] << 8));
|
|
v >>= 8;
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
void FillInfo(pixel* Fmt)
|
|
{
|
|
Fmt->BitCount = GetBPP(Fmt);
|
|
if (PlanarYUV(Fmt,NULL,NULL,NULL))
|
|
{
|
|
if (Fmt->Flags & (PF_YUV420|PF_YUV422|PF_YUV444|PF_YUV410))
|
|
{
|
|
Fmt->BitMask[0] = 0x000000FF;
|
|
Fmt->BitMask[1] = 0x0000FF00;
|
|
Fmt->BitMask[2] = 0x00FF0000;
|
|
}
|
|
else
|
|
switch (Fmt->FourCC)
|
|
{
|
|
case FOURCC_IMC4:
|
|
case FOURCC_I420:
|
|
case FOURCC_IYUV:
|
|
case FOURCC_YUV9:
|
|
Fmt->BitMask[0] = 0x000000FF;
|
|
Fmt->BitMask[1] = 0x0000FF00;
|
|
Fmt->BitMask[2] = 0x00FF0000;
|
|
break;
|
|
case FOURCC_IMC2:
|
|
case FOURCC_YV16:
|
|
case FOURCC_YV12:
|
|
case FOURCC_YVU9:
|
|
Fmt->BitMask[0] = 0x000000FF;
|
|
Fmt->BitMask[1] = 0x00FF0000;
|
|
Fmt->BitMask[2] = 0x0000FF00;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
if (PackedYUV(Fmt))
|
|
switch (Fmt->FourCC)
|
|
{
|
|
case FOURCC_YUY2:
|
|
case FOURCC_YUNV:
|
|
case FOURCC_V422:
|
|
case FOURCC_YUYV:
|
|
Fmt->BitMask[0] = 0x00FF00FF;
|
|
Fmt->BitMask[1] = 0x0000FF00;
|
|
Fmt->BitMask[2] = 0xFF000000;
|
|
break;
|
|
case FOURCC_YVYU:
|
|
Fmt->BitMask[0] = 0x00FF00FF;
|
|
Fmt->BitMask[1] = 0xFF000000;
|
|
Fmt->BitMask[2] = 0x0000FF00;
|
|
break;
|
|
case FOURCC_UYVY:
|
|
case FOURCC_Y422:
|
|
case FOURCC_UYNV:
|
|
Fmt->BitMask[0] = 0xFF00FF00;
|
|
Fmt->BitMask[1] = 0x000000FF;
|
|
Fmt->BitMask[2] = 0x00FF0000;
|
|
break;
|
|
}
|
|
}
|
|
|
|
int GetImageSize(const video* p)
|
|
{
|
|
int Size = p->Pitch * p->Height;
|
|
if (PlanarYUV420(&p->Pixel))
|
|
Size = (Size*3)/2; //1:0.25:0.25
|
|
else
|
|
if (PlanarYUV422(&p->Pixel))
|
|
Size *= 2; //1:0.5:0.5
|
|
else
|
|
if (PlanarYUV444(&p->Pixel))
|
|
Size *= 3; //1:1:1
|
|
return Size;
|
|
}
|
|
|
|
int GetBPP(const pixel* Fmt)
|
|
{
|
|
if (Fmt->Flags & (PF_RGB | PF_PALETTE))
|
|
return Fmt->BitCount;
|
|
if (PlanarYUV(Fmt,NULL,NULL,NULL))
|
|
return 8;
|
|
if (PackedYUV(Fmt))
|
|
return 16;
|
|
return 0;
|
|
}
|
|
|
|
bool_t EqPoint(const point* a, const point* b)
|
|
{
|
|
return a->x==b->x && a->y==b->y;
|
|
}
|
|
|
|
bool_t EqRect(const rect* a, const rect* b)
|
|
{
|
|
return a->x==b->x && a->y==b->y && a->Width==b->Width && a->Height==b->Height;
|
|
}
|
|
|
|
bool_t EqPixel(const pixel* a, const pixel* b)
|
|
{
|
|
if (a->Flags != b->Flags)
|
|
return 0;
|
|
|
|
if ((a->Flags & PF_PALETTE) &&
|
|
a->BitCount != b->BitCount)
|
|
return 0;
|
|
|
|
if ((a->Flags & PF_RGB) &&
|
|
(a->BitCount != b->BitCount ||
|
|
a->BitMask[0] != b->BitMask[0] ||
|
|
a->BitMask[1] != b->BitMask[1] ||
|
|
a->BitMask[2] != b->BitMask[2]))
|
|
return 0;
|
|
|
|
if ((a->Flags & PF_FOURCC) && a->FourCC != b->FourCC)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool_t EqVideo(const video* a, const video* b)
|
|
{
|
|
// no direction check here!
|
|
return a->Width == b->Width &&
|
|
a->Height == b->Height &&
|
|
a->Pitch == b->Pitch &&
|
|
EqPixel(&a->Pixel,&b->Pixel);
|
|
}
|
|
|
|
void ClipRectPhy(rect* Physical, const video* p)
|
|
{
|
|
if (Physical->x < 0)
|
|
{
|
|
Physical->Width += Physical->x;
|
|
Physical->x = 0;
|
|
}
|
|
if (Physical->y < 0)
|
|
{
|
|
Physical->Height += Physical->y;
|
|
Physical->y = 0;
|
|
}
|
|
if (Physical->x + Physical->Width > p->Width)
|
|
{
|
|
Physical->Width = p->Width - Physical->x;
|
|
if (Physical->Width < 0)
|
|
{
|
|
Physical->Width = 0;
|
|
Physical->x = 0;
|
|
}
|
|
}
|
|
if (Physical->y + Physical->Height > p->Height)
|
|
{
|
|
Physical->Height = p->Height - Physical->y;
|
|
if (Physical->Height < 0)
|
|
{
|
|
Physical->Height = 0;
|
|
Physical->y = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void VirtToPhy(const rect* Virtual, rect* Physical, const video* p)
|
|
{
|
|
if (Virtual)
|
|
{
|
|
*Physical = *Virtual;
|
|
|
|
if (p->Pixel.Flags & PF_PIXELDOUBLE)
|
|
{
|
|
Physical->x >>= 1;
|
|
Physical->y >>= 1;
|
|
Physical->Width >>= 1;
|
|
Physical->Height >>= 1;
|
|
}
|
|
|
|
if (p->Direction & DIR_SWAPXY)
|
|
SwapRect(Physical);
|
|
|
|
if (p->Direction & DIR_MIRRORLEFTRIGHT)
|
|
Physical->x = p->Width - Physical->x - Physical->Width;
|
|
|
|
if (p->Direction & DIR_MIRRORUPDOWN)
|
|
Physical->y = p->Height - Physical->y - Physical->Height;
|
|
|
|
ClipRectPhy(Physical,p);
|
|
}
|
|
else
|
|
{
|
|
Physical->x = 0;
|
|
Physical->y = 0;
|
|
Physical->Width = p->Width;
|
|
Physical->Height = p->Height;
|
|
}
|
|
}
|
|
|
|
void PhyToVirt(const rect* Physical, rect* Virtual, const video* p)
|
|
{
|
|
if (Physical)
|
|
*Virtual = *Physical;
|
|
else
|
|
{
|
|
Virtual->x = 0;
|
|
Virtual->y = 0;
|
|
Virtual->Width = p->Width;
|
|
Virtual->Height = p->Height;
|
|
}
|
|
|
|
if (p->Direction & DIR_MIRRORLEFTRIGHT)
|
|
Virtual->x = p->Width - Virtual->x - Virtual->Width;
|
|
|
|
if (p->Direction & DIR_MIRRORUPDOWN)
|
|
Virtual->y = p->Height - Virtual->y - Virtual->Height;
|
|
|
|
if (p->Direction & DIR_SWAPXY)
|
|
SwapRect(Virtual);
|
|
|
|
if (p->Pixel.Flags & PF_PIXELDOUBLE)
|
|
{
|
|
Virtual->x <<= 1;
|
|
Virtual->y <<= 1;
|
|
Virtual->Width <<= 1;
|
|
Virtual->Height <<= 1;
|
|
}
|
|
}
|
|
|