Bool VGetSurfAddrBy32(GALINFOPTR galInfo,int maxsize, int *phyaddr,int *lgaddr,int *width,int *height,int *stride)
{
static int gphyaddr;
static int glgaddr;
static int gwidth;
static int gheight;
static int gstride;
static int lastmaxsize=0;
gceSTATUS status = gcvSTATUS_OK;
VIVGPUPtr gpuctx = (VIVGPUPtr) (galInfo->mGpu);
if (maxsize <MAX_WIDTH)
maxsize=MAX_WIDTH;
if (_vsurf32.surf && (maxsize >lastmaxsize)) {
if (VDestroySurf32()!=TRUE)
TRACE_EXIT(FALSE);
lastmaxsize=maxsize;
}
if (_vsurf32.surf==NULL) {
lastmaxsize=maxsize;
status=gcoSURF_Construct(gpuctx->mDriver->mHal,maxsize,maxsize,1,gcvSURF_BITMAP,gcvSURF_A8R8G8B8,gcvPOOL_DEFAULT,&(_vsurf32.surf));
if (status!=gcvSTATUS_OK)
TRACE_EXIT(FALSE);
status=gcoSURF_GetAlignedSize(_vsurf32.surf,&gwidth,&gheight,&gstride);
if (status!=gcvSTATUS_OK)
TRACE_EXIT(FALSE);
status=gcoSURF_Lock(_vsurf32.surf, &gphyaddr, (void *)&glgaddr);
_vsurf32.lineaddr=glgaddr;
}
*phyaddr=gphyaddr;
*lgaddr=glgaddr;
*width=gwidth;
*height=gheight;
*stride=gstride;
TRACE_EXIT(TRUE);
}
gceSTATUS
_FitSurface(
IN gcsCOPYBIT_CONTEXT * Context,
IN gcsSURFACE * Surface,
IN gctUINT32 Width,
IN gctUINT32 Height
)
{
gceSTATUS status = gcvSTATUS_OK;
if (Surface == gcvNULL)
{
return gcvSTATUS_INVALID_ARGUMENT;
}
do
{
/* Create the tmp Surfaceace if necessary. */
if ((Surface->surface == gcvNULL)
|| (Surface->width < Width)
|| (Surface->height < Height)
)
{
/* Destroy last surface. */
if (Surface->surface != gcvNULL)
{
if (Surface->logical != gcvNULL)
{
gcmERR_BREAK(
gcoSURF_Unlock(Surface->surface,
Surface->logical));
}
gcmERR_BREAK(
gcoSURF_Destroy(Surface->surface));
}
/* New surface values. */
Surface->format = gcvSURF_A8R8G8B8;
Surface->width = Width;
Surface->height = Height;
gcmERR_BREAK(
gcoSURF_Construct(gcvNULL,
Surface->width,
Surface->height,
1,
gcvSURF_BITMAP,
Surface->format,
gcvPOOL_DEFAULT,
&Surface->surface));
gcmERR_BREAK(
gcoSURF_Lock(Surface->surface,
&Surface->physical,
&Surface->logical));
gcmERR_BREAK(
gcoSURF_GetAlignedSize(Surface->surface,
&Surface->alignedWidth,
&Surface->alignedHeight,
&Surface->stride));
}
}
while (gcvFALSE);
return status;
}
gceSTATUS
_StretchBlitPE1x(
IN gcsCOPYBIT_CONTEXT * Context,
IN struct copybit_image_t const * Dest,
IN struct copybit_image_t const * Source,
IN struct copybit_rect_t const * DestRect,
IN struct copybit_rect_t const * SourceRect,
IN struct copybit_region_t const * Clip)
{
gceSTATUS status = gcvSTATUS_OK;
gceSURF_FORMAT siFormat;
gceSURF_FORMAT diFormat;
gctUINT32 diPhysical = ~0;
gctUINT32 diAlignedWidth;
gctUINT32 diAlignedHeight;
gctINT diStride;
gcsRECT srcRect;
gcsRECT dstRect;
copybit_rect_t rect;
gctUINT32 srcPhysical = ~0;
gctINT srcStride;
gctUINT32 srcAlignedWidth;
gctUINT32 srcAlignedHeight;
gceSURF_FORMAT srcFormat;
gctUINT32 dstPhysical = ~0;
gctINT dstStride;
gctUINT32 dstAlignedWidth;
gctUINT32 dstAlignedHeight;
gceSURF_FORMAT dstFormat;
gctBOOL stretch = gcvFALSE;
gctBOOL yuvFormat = gcvFALSE;
gctBOOL perpixelAlpha;
gc_private_handle_t* dsthnd = (gc_private_handle_t *) Dest->handle;
gc_private_handle_t* srchnd = (gc_private_handle_t *) Source->handle;
LOGV("Blit from Source hnd=%p, to Dest hnd=%p", srchnd, dsthnd);
if (gc_private_handle_t::validate(dsthnd) < 0)
{
gcmTRACE(gcvLEVEL_ERROR,
"Invalid hnd in funciton %s",
__func__);
return gcvSTATUS_INVALID_ARGUMENT;
}
siFormat = (gceSURF_FORMAT) srchnd->format;
diFormat = (gceSURF_FORMAT) dsthnd->format;
if ((siFormat == gcvSURF_UNKNOWN)
|| (diFormat == gcvSURF_UNKNOWN)
)
{
gcmTRACE(gcvLEVEL_ERROR,
"Image format not support in copybit!");
return gcvSTATUS_INVALID_ARGUMENT;
}
/* Convert to supported Source format. */
siFormat = (siFormat == gcvSURF_A8B8G8R8) ? gcvSURF_A8R8G8B8 : siFormat;
siFormat = (siFormat == gcvSURF_X8B8G8R8) ? gcvSURF_X8R8G8B8 : siFormat;
/* Convert to supported Dest format. */
diFormat = (diFormat == gcvSURF_A8B8G8R8) ? gcvSURF_A8R8G8B8 : diFormat;
diFormat = (diFormat == gcvSURF_X8B8G8R8) ? gcvSURF_X8R8G8B8 : diFormat;
do
{
srcPhysical = srchnd->phys;
gcoSURF_GetAlignedSize((gcoSURF) srchnd->surface,
&srcAlignedWidth,
&srcAlignedHeight,
&srcStride);
diPhysical = dsthnd->phys;
gcoSURF_GetAlignedSize((gcoSURF) dsthnd->surface,
&diAlignedWidth,
&diAlignedHeight,
&diStride);
if ((((gcoSURF)srchnd->surface)->info.type == gcvSURF_BITMAP) &&
!(srchnd->flags & gc_private_handle_t::PRIV_FLAGS_FRAMEBUFFER))
{
/* Clean the CPU cache. Source would've been rendered by the CPU. */
gcmERR_BREAK(
gcoSURF_CPUCacheOperation(
(gcoSURF) srchnd->surface,
gcvCACHE_CLEAN
)
);
}
perpixelAlpha = _HasAlpha(siFormat) &&
(dsthnd->flags & gc_private_handle_t::PRIV_FLAGS_FRAMEBUFFER) &&
!(srchnd->flags & gc_private_handle_t::PRIV_FLAGS_FRAMEBUFFER);
if (Context->perpixelAlpha != perpixelAlpha)
{
Context->perpixelAlpha = perpixelAlpha;
if (Context->planeAlpha == 0xff)
{
Context->dirty.s.alphaKey = 1;
}
}
/* Need temp surface if source has alpha channel, but dest not. */
Context->needAlphaDest = Context->perpixelAlpha &&
!_HasAlpha(diFormat);
if (Context->needAlphaDest)
{
gcsRECT tempRect;
tempRect.left = gcmMAX(0, DestRect->l);
tempRect.top = gcmMAX(0, DestRect->t);
tempRect.right = gcmMIN((int32_t) Dest->w, DestRect->r);
tempRect.bottom = gcmMIN((int32_t) Dest->h, DestRect->b);
gcmERR_BREAK(
_FitSurface(Context,
&Context->alphaDest,
Dest->w,
Dest->h));
if (Context->alphaDest.surface == gcvNULL)
{
gcmTRACE(gcvLEVEL_ERROR,
"fail to construct tmp surface for per_pixel_alpha");
break;
}
/* Copy dest surface to temp surface. */
gcmERR_BREAK(
_MonoBlit(Context,
diPhysical,
diStride,
diFormat,
Context->alphaDest.physical,
Context->alphaDest.stride,
Context->alphaDest.format,
&tempRect));
}
gcmERR_BREAK(
_UploadStates(Context));
if (Context->needAlphaDest)
{
dstPhysical = Context->alphaDest.physical;
dstStride = Context->alphaDest.stride;
dstAlignedWidth = Context->alphaDest.alignedWidth;
dstAlignedHeight = Context->alphaDest.alignedHeight;
dstFormat = Context->alphaDest.format;
}
else
{
dstPhysical = diPhysical;
dstStride = diStride;
dstAlignedWidth = diAlignedWidth;
dstAlignedHeight = diAlignedHeight;
dstFormat = diFormat;
}
srcFormat = siFormat;
if (Context->transform == COPYBIT_TRANSFORM_ROT_270)
{
srcRect.left = SourceRect->t;
srcRect.top = Source->w - SourceRect->r;
srcRect.right = SourceRect->b;
srcRect.bottom = Source->w - SourceRect->l;
}
else
{
srcRect.left = SourceRect->l;
srcRect.top = SourceRect->t;
srcRect.right = SourceRect->r;
srcRect.bottom = SourceRect->b;
}
if (Context->transform == COPYBIT_TRANSFORM_ROT_90)
{
dstRect.left = DestRect->t;
dstRect.top = Dest->w - DestRect->r;
dstRect.right = DestRect->b;
dstRect.bottom = Dest->w - DestRect->l;
}
else
{
dstRect.left = DestRect->l;
dstRect.top = DestRect->t;
dstRect.right = DestRect->r;
dstRect.bottom = DestRect->b;
}
/* Check yuv format. */
yuvFormat = (srcFormat == gcvSURF_YUY2 || srcFormat == gcvSURF_UYVY);
stretch =
(srcRect.right - srcRect.left) != (dstRect.right - dstRect.left) ||
(srcRect.bottom - srcRect.top) != (dstRect.bottom - dstRect.top);
/* Upload stretch factor. */
if (stretch)
{
int hFactor;
int vFactor;
if ((dstRect.right-dstRect.left) > 1 && (dstRect.bottom-dstRect.top) > 1)
{
hFactor = ((srcRect.right - srcRect.left - 1) << 16) /
(dstRect.right - dstRect.left - 1);
vFactor = ((srcRect.bottom - srcRect.top - 1) << 16) /
(dstRect.bottom - dstRect.top - 1);
}
else
{
hFactor = 0;
vFactor = 0;
}
gcmERR_BREAK(
gco2D_SetStretchFactors(Context->engine,
hFactor,
vFactor));
}
/* Prepare source and target for normal blit. */
gcmERR_BREAK(
gco2D_SetColorSource(Context->engine,
srcPhysical,
srcStride,
srcFormat,
Context->srcRotation,
srcAlignedWidth,
gcvFALSE,
gcvSURF_OPAQUE,
0));
gcmERR_BREAK(
gco2D_SetSource(Context->engine,
&srcRect));
gcmERR_BREAK(
gco2D_SetTarget(Context->engine,
dstPhysical,
dstStride,
Context->dstRotation,
dstAlignedWidth));
gcsRECT srcRectBackup = srcRect;
gcsRECT dstRectBackup = dstRect;
/* Go though all clip rectangles. */
while (Clip->next(Clip, &rect))
{
gcsRECT clipRect;
srcRect = srcRectBackup;
dstRect = dstRectBackup;
if (Context->transform == COPYBIT_TRANSFORM_ROT_90)
{
clipRect.left = rect.t;
clipRect.top = Dest->w - rect.r;
clipRect.right = rect.b;
clipRect.bottom = Dest->w - rect.l;
}
else if (Context->transform == COPYBIT_TRANSFORM_ROT_180)
{
float hfactor = (float) (SourceRect->r - SourceRect->l)
/ (DestRect->r - DestRect->l);
float vfactor = (float) (SourceRect->b - SourceRect->t)
/ (DestRect->b - DestRect->t);
/* Intersect. */
clipRect.left = gcmMAX(dstRect.left, rect.l);
clipRect.top = gcmMAX(dstRect.top, rect.t);
clipRect.right = gcmMIN(dstRect.right, rect.r);
clipRect.bottom = gcmMIN(dstRect.bottom, rect.b);
/* Adjust src rectangle. */
srcRect.left += (int) ((dstRect.right - clipRect.right) * hfactor);
srcRect.top += (int) ((dstRect.bottom - clipRect.bottom) * vfactor);
srcRect.right -= (int) ((clipRect.left - dstRect.left) * hfactor);
srcRect.bottom -= (int) ((clipRect.top - dstRect.top) * vfactor);
/* Set dstRect to clip rectangle. */
dstRect = clipRect;
if ((srcRect.left != srcRectBackup.left)
|| (srcRect.right != srcRectBackup.right)
|| (srcRect.top != srcRectBackup.top)
|| (srcRect.bottom != srcRectBackup.bottom)
)
{
gcmERR_BREAK(
gco2D_SetSource(Context->engine,
&srcRect));
}
}
else
{
clipRect.left = rect.l;
clipRect.top = rect.t;
clipRect.right = rect.r;
clipRect.bottom = rect.b;
}
/* Clamp clip rectangle. */
if (clipRect.right > dstRect.right)
clipRect.right = dstRect.right;
if (clipRect.bottom > dstRect.bottom)
clipRect.bottom = dstRect.bottom;
if (clipRect.left < dstRect.left)
clipRect.left = dstRect.left;
if (clipRect.top < dstRect.top)
clipRect.top = dstRect.top;
gcmERR_BREAK(
gco2D_SetClipping(Context->engine,
&clipRect));
if (yuvFormat)
{
/* TODO: FilterBlit does not support rotation before PE20. */
/* Video filter blit */
/* 1. SetClipping() has no effect for FilterBlit()
* so we use dstSubRect to realize clipping effect
* 2. Only FilterBlit support yuv format covertion.
*/
gcsRECT dstSubRect;
int dstWidth = dstRect.right - dstRect.left;
int dstHeight = dstRect.bottom - dstRect.top;
int clipWidth = clipRect.right - clipRect.left;
int clipHeight = clipRect.bottom - clipRect.top;
dstSubRect.left = clipRect.left - dstRect.left;
dstSubRect.top = clipRect.top - dstRect.top;
dstSubRect.right = dstWidth < clipWidth ?
dstSubRect.left + dstWidth :
dstSubRect.left + clipWidth;
dstSubRect.bottom = dstHeight < clipHeight ?
dstSubRect.top + dstHeight :
dstSubRect.top + clipHeight;
gcmERR_BREAK(
gco2D_SetKernelSize(Context->engine,
gcdFILTER_BLOCK_SIZE,
gcdFILTER_BLOCK_SIZE));
gcmERR_BREAK(
gco2D_SetFilterType(Context->engine,
gcvFILTER_SYNC));
gcmERR_BREAK(
gco2D_FilterBlit(Context->engine,
srcPhysical,
srcStride,
0, 0, 0, 0,
srcFormat,
Context->srcRotation,
srcAlignedWidth,
&srcRect,
dstPhysical,
dstStride,
dstFormat,
Context->dstRotation,
dstAlignedWidth,
&dstRect,
&dstSubRect));
}
else if (Context->blur)
{
/* TODO: FilterBlit does not support rotation before PE20. */
gcsRECT dstSubRect;
dstSubRect.left = 0;
dstSubRect.top = 0;
dstSubRect.right = dstRect.right - dstRect.left;
dstSubRect.bottom = dstRect.bottom - dstRect.top;
/* Blur blit. */
gcmERR_BREAK(
gco2D_SetKernelSize(Context->engine,
gcdFILTER_BLOCK_SIZE,
gcdFILTER_BLOCK_SIZE));
gcmERR_BREAK(
gco2D_SetFilterType(Context->engine,
gcvFILTER_BLUR));
gcmERR_BREAK(
gco2D_FilterBlit(Context->engine,
srcPhysical,
srcStride,
0, 0, 0, 0,
srcFormat,
gcvSURF_0_DEGREE,
srcAlignedWidth,
&srcRect,
dstPhysical,
dstStride,
dstFormat,
gcvSURF_0_DEGREE,
dstAlignedWidth,
&dstRect,
&dstSubRect));
gcmERR_BREAK(
gco2D_FilterBlit(Context->engine,
dstPhysical,
dstStride,
0, 0, 0, 0,
dstFormat,
gcvSURF_0_DEGREE,
dstAlignedWidth,
&dstRect,
dstPhysical,
dstStride,
dstFormat,
gcvSURF_0_DEGREE,
dstAlignedWidth,
&dstRect,
&dstSubRect));
/* TODO: surfaceflinger set blur issue. */
Context->blur = COPYBIT_DISABLE;
}
else if (stretch == gcvFALSE)
{
/* BitBlit. */
gcmERR_BREAK(
gco2D_Blit(Context->engine,
1,
&dstRect,
0xCC,
0xCC,
dstFormat));
}
else
{
/* Normal stretch blit. */
gcmERR_BREAK(
gco2D_StretchBlit(Context->engine,
1,
&dstRect,
0xCC,
0xCC,
dstFormat));
}
}
if (gcmIS_ERROR(status))
{
break;
}
if (Context->needAlphaDest)
{
gcsRECT tempRect;
tempRect.left = gcmMAX(0, DestRect->l);
tempRect.top = gcmMAX(0, DestRect->t);
tempRect.right = gcmMIN((int32_t) Dest->w, DestRect->r);
tempRect.bottom = gcmMIN((int32_t) Dest->h, DestRect->b);
/* Blit back to actual dest. */
gcmERR_BREAK(
_MonoBlit(Context,
Context->alphaDest.physical,
Context->alphaDest.stride,
Context->alphaDest.format,
diPhysical,
diStride,
diFormat,
&tempRect));
}
/* Flush and commit. */
gcmERR_BREAK(
gco2D_Flush(Context->engine));
gcmERR_BREAK(
gcoHAL_Commit(gcvNULL, gcvFALSE));
}
while (gcvFALSE);
return status;
}