Embedded/pikapython
1
0
Fork 0
mirror of https://gitee.com/Lyon1998/pikapython.git synced 2025-01-15 17:02:53 +08:00
Code Issues Packages Projects Releases Wiki Activity
pikapython/package/Arm2D/arm_2d_alpha_blending.c

2445 lines
88 KiB
C
Raw Normal View History

add arm2d lib
2021-11-09 22:19:51 +08:00
/*
* Copyright (C) 2010-2020 Arm Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* ----------------------------------------------------------------------
* Project: Arm-2D Library
* Title: arm-2d.c
* Description: APIs for various alpha related operations
*
* $Date: 03. Oct 2021
* $Revision: V.0.9.1
*
* Target Processor: Cortex-M cores
*
* -------------------------------------------------------------------- */
/*============================ INCLUDES ======================================*/
#define __ARM_2D_IMPL__
#include "arm_2d.h"
#include "__arm_2d_impl.h"
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# pragma clang diagnostic ignored "-Wreserved-identifier"
# pragma clang diagnostic ignored "-Wincompatible-pointer-types-discards-qualifiers"
# pragma clang diagnostic ignored "-Wmissing-variable-declarations"
# pragma clang diagnostic ignored "-Wcast-qual"
# pragma clang diagnostic ignored "-Wcast-align"
# pragma clang diagnostic ignored "-Wextra-semi-stmt"
# pragma clang diagnostic ignored "-Wsign-conversion"
# pragma clang diagnostic ignored "-Wunused-function"
# pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
# pragma clang diagnostic ignored "-Wdouble-promotion"
# pragma clang diagnostic ignored "-Wunused-parameter"
# pragma clang diagnostic ignored "-Wimplicit-float-conversion"
# pragma clang diagnostic ignored "-Wimplicit-int-conversion"
# pragma clang diagnostic ignored "-Wtautological-pointer-compare"
# pragma clang diagnostic ignored "-Wmissing-prototypes"
# pragma clang diagnostic ignored "-Wreserved-identifier"
# pragma clang diagnostic ignored "-Wsign-compare"
#elif defined(__IS_COMPILER_ARM_COMPILER_5__)
# pragma diag_suppress 174,177,188,68,513,144
#endif
/*============================ MACROS ========================================*/
/*============================ MACROFIED FUNCTIONS ===========================*/
/*============================ TYPES =========================================*/
/*============================ GLOBAL VARIABLES ==============================*/
/*============================ PROTOTYPES ====================================*/
/*============================ LOCAL VARIABLES ===============================*/
/*============================ IMPLEMENTATION ================================*/
/*----------------------------------------------------------------------------*
* Accelerable Low Level APIs *
*----------------------------------------------------------------------------*/
/*! adding support with c code template */
#define __API_COLOUR gray8
#define __API_INT_TYPE uint8_t
#define __API_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_GRAY8
#include "__arm_2d_alpha_blending.inc"
#define __API_COLOUR rgb565
#define __API_INT_TYPE uint16_t
#define __API_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_RGB565
#define __PATCH_ALPHA_BLENDING
#include "__arm_2d_alpha_blending.inc"
/*! adding support with c code template */
#define __API_COLOUR cccn888
#define __API_INT_TYPE uint32_t
#define __API_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_CCCN888
#include "__arm_2d_alpha_blending.inc"
#define __API_CAFWM_COLOUR gray8
#define __API_CAFWM_INT_TYPE uint8_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 8
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_GRAY8
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_CFG_1_HORIZONTAL_LINE 1
#define __API_CAFWM_COLOUR gray8
#define __API_CAFWM_INT_TYPE uint8_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 8
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_GRAY8
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_CFG_CHANNEL_8in32_SUPPORT 1
#define __API_CAFWM_COLOUR gray8
#define __API_CAFWM_INT_TYPE uint8_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 8
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_GRAY8
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_COLOUR rgb565
#define __API_CAFWM_INT_TYPE uint16_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 16
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_RGB565
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_CFG_1_HORIZONTAL_LINE 1
#define __API_CAFWM_COLOUR rgb565
#define __API_CAFWM_INT_TYPE uint16_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 16
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_RGB565
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_CFG_CHANNEL_8in32_SUPPORT 1
#define __API_CAFWM_COLOUR rgb565
#define __API_CAFWM_INT_TYPE uint16_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 16
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_RGB565
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_COLOUR cccn888
#define __API_CAFWM_INT_TYPE uint32_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 32
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_CCCN888
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_CFG_1_HORIZONTAL_LINE 1
#define __API_CAFWM_COLOUR cccn888
#define __API_CAFWM_INT_TYPE uint32_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 32
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_CCCN888
#include "__arm_2d_alpha_mask.inc"
#define __API_CAFWM_CFG_CHANNEL_8in32_SUPPORT 1
#define __API_CAFWM_COLOUR cccn888
#define __API_CAFWM_INT_TYPE uint32_t
#define __API_CAFWM_INT_TYPE_BIT_NUM 32
#define __API_CAFWM_PIXEL_BLENDING __ARM_2D_PIXEL_BLENDING_CCCN888
#include "__arm_2d_alpha_mask.inc"
#define __API_ABW_COLOUR gray8
#define __API_ABW_INT_TYPE uint8_t
#define __API_ABW_INT_TYPE_BIT_NUM 8
#define __API_ABW_COLOUR_SZ ARM_2D_COLOUR_SZ_8BIT
#include "__arm_2d_alpha_blending_wrapper.inc"
#define __API_ABW_COLOUR rgb565
#define __API_ABW_INT_TYPE uint16_t
#define __API_ABW_INT_TYPE_BIT_NUM 16
#define __API_ABW_COLOUR_SZ ARM_2D_COLOUR_SZ_16BIT
#include "__arm_2d_alpha_blending_wrapper.inc"
#define __API_ABW_COLOUR cccn888
#define __API_ABW_INT_TYPE uint32_t
#define __API_ABW_INT_TYPE_BIT_NUM 32
#define __API_ABW_COLOUR_SZ ARM_2D_COLOUR_SZ_32BIT
#include "__arm_2d_alpha_blending_wrapper.inc"
extern
void __arm_2d_impl_rgb565_alpha_blending_direct(
const uint16_t *phwSource,
const uint16_t *phwBackground,
uint16_t *phwDestination,
uint32_t wPixelCount,
uint_fast8_t chRatio);
extern
void __arm_2d_impl_cccn888_alpha_blending_direct(
const uint32_t *__RESTRICT pwSource,
const uint32_t *__RESTRICT pwBackground,
uint32_t *pwDestination,
uint32_t wPixelCount,
uint_fast8_t chRatio);
/*----------------------------------------------------------------------------*
* Copy tile to destination with specified masks *
*----------------------------------------------------------------------------*/
static
arm_2d_err_t __arm_2dp_tile_copy_with_mask_validate(
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptSrcMask,
const arm_2d_tile_t *ptTarget,
const arm_2d_tile_t *ptDesMask,
uint32_t wMode)
{
if (NULL != ptSrcMask) {
//! valid source mask tile
if (0 == ptSrcMask->bHasEnforcedColour) {
return ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptSrcMask->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptSrcMask->tColourInfo.chScheme)) {
return ARM_2D_ERR_INVALID_PARAM;
}
arm_2d_cmp_t tCompare = arm_2d_tile_shape_compare(ptSrcMask, ptSource);
/*! \note the source mask tile should be bigger than or equals to the
*! source tile
*/
if (ARM_2D_CMP_SMALLER == tCompare) {
return ARM_2D_ERR_INVALID_PARAM;
}
}
if (NULL != ptDesMask) {
//! valid target mask tile
if (0 == ptDesMask->bHasEnforcedColour) {
return ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptDesMask->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptDesMask->tColourInfo.chScheme)) {
return ARM_2D_ERR_INVALID_PARAM;
}
/*! \note the target mask tile should be bigger than or equals to the
*! target tile in width
*/
if (ARM_2D_CMP_SMALLER == arm_2d_tile_width_compare(ptDesMask, ptTarget)) {
return ARM_2D_ERR_INVALID_PARAM;
}
if (ARM_2D_CMP_SMALLER == arm_2d_tile_height_compare(ptDesMask, ptTarget)) {
if (1 != ptDesMask->tRegion.tSize.iHeight) {
return ARM_2D_ERR_INVALID_PARAM;
} else if (ARM_2D_CHANNEL_8in32 == ptDesMask->tColourInfo.chScheme) {
/*! does NOT support a target mask consists of 1 horizontal line
*! in the special colour 'ARM_2D_CHANNEL_8in32'.
*/
return ARM_2D_ERR_INVALID_PARAM;
}
}
}
return ARM_2D_ERR_NONE;
}
ARM_NONNULL(2,3,4,5)
arm_fsm_rt_t arm_2dp_gray8_tile_copy_with_masks(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptSrcMask,
const arm_2d_tile_t *ptTarget,
const arm_2d_tile_t *ptDesMask,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptSrcMask);
assert(NULL != ptTarget);
assert(NULL != ptDesMask);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, ptSrcMask,
ptTarget, ptDesMask, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_MASK_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = ptSrcMask;
this.Mask.ptTargetSide = ptDesMask;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3,4,5)
arm_fsm_rt_t arm_2dp_rgb565_tile_copy_with_masks(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptSrcMask,
const arm_2d_tile_t *ptTarget,
const arm_2d_tile_t *ptDesMask,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptSrcMask);
assert(NULL != ptTarget);
assert(NULL != ptDesMask);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, ptSrcMask,
ptTarget, ptDesMask, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_MASK_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = ptSrcMask;
this.Mask.ptTargetSide = ptDesMask;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3,4,5)
arm_fsm_rt_t arm_2dp_cccn888_tile_copy_with_masks(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptSrcMask,
const arm_2d_tile_t *ptTarget,
const arm_2d_tile_t *ptDesMask,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptSrcMask);
assert(NULL != ptTarget);
assert(NULL != ptDesMask);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, ptSrcMask,
ptTarget, ptDesMask, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_MASK_CCCN888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = ptSrcMask;
this.Mask.ptTargetSide = ptDesMask;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
/*----------------------------------------------------------------------------*
* Copy tile to destination with a specified source mask *
*----------------------------------------------------------------------------*/
ARM_NONNULL(2,3,4)
arm_fsm_rt_t arm_2dp_gray8_tile_copy_with_src_mask(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptSrcMask,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptSrcMask);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, ptSrcMask,
ptTarget, NULL, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_SRC_MASK_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = ptSrcMask;
this.Mask.ptTargetSide = NULL;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3,4)
arm_fsm_rt_t arm_2dp_rgb565_tile_copy_with_src_mask(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptSrcMask,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptSrcMask);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, ptSrcMask,
ptTarget, NULL, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_SRC_MASK_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = ptSrcMask;
this.Mask.ptTargetSide = NULL;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3,4)
arm_fsm_rt_t arm_2dp_cccn888_tile_copy_with_src_mask(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptSrcMask,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptSrcMask);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, ptSrcMask,
ptTarget, NULL, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_SRC_MASK_CCCN888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = ptSrcMask;
this.Mask.ptTargetSide = NULL;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
/*----------------------------------------------------------------------------*
* Copy tile to destination with a specified target mask *
*----------------------------------------------------------------------------*/
ARM_NONNULL(2,3,4)
arm_fsm_rt_t arm_2dp_gray8_tile_copy_with_des_mask(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_tile_t *ptDesMask,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
assert(NULL != ptDesMask);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, NULL,
ptTarget, ptDesMask, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_DES_MASK_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = NULL;
this.Mask.ptTargetSide = ptDesMask;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3,4)
arm_fsm_rt_t arm_2dp_rgb565_tile_copy_with_des_mask(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_tile_t *ptDesMask,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
assert(NULL != ptDesMask);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, NULL,
ptTarget, ptDesMask, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_DES_MASK_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = NULL;
this.Mask.ptTargetSide = ptDesMask;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3,4)
arm_fsm_rt_t arm_2dp_cccn888_tile_copy_with_des_mask(
arm_2d_op_cp_msk_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_tile_t *ptDesMask,
const arm_2d_region_t *ptRegion,
uint32_t wMode)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
assert(NULL != ptDesMask);
ARM_2D_IMPL(arm_2d_op_cp_msk_t, ptOP);
arm_2d_err_t tErr = __arm_2dp_tile_copy_with_mask_validate(
ptSource, NULL,
ptTarget, ptDesMask, wMode);
if (tErr < 0) {
return (arm_fsm_rt_t)tErr;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_TILE_COPY_WITH_DES_MASK_CCCN888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = wMode;
this.Mask.ptSourceSide = NULL;
this.Mask.ptTargetSide = ptDesMask;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
/*----------------------------------------------------------------------------*
* Copy tile to destination with specified transparency ratio (0~255) *
*----------------------------------------------------------------------------*/
ARM_NONNULL(2,3)
arm_fsm_rt_t arm_2dp_gray8_alpha_blending(
arm_2d_op_alpha_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint_fast8_t chRatio)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_alpha_t, ptOP);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_BLENDING_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = 0;
this.chRatio = chRatio;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3)
arm_fsm_rt_t arm_2dp_rgb565_alpha_blending(
arm_2d_op_alpha_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint_fast8_t chRatio)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_alpha_t, ptOP);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_BLENDING_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = 0;
this.chRatio = chRatio;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3)
arm_fsm_rt_t arm_2dp_cccn888_alpha_blending( arm_2d_op_alpha_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint_fast8_t chRatio)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_alpha_t, ptOP);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_BLENDING_RGB888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = 0;
this.chRatio = chRatio;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
arm_fsm_rt_t __arm_2d_gray8_sw_alpha_blending(__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_t, ptTask->ptOP)
assert(ARM_2D_COLOUR_RGB565 == OP_CORE.ptOp->Info.Colour.chScheme);
#if 0 // todo: might implement this in the future
if ( (ptTask->Param.tCopy.tSource.iStride
== ptTask->Param.tCopy.tTarget.iStride)
&& (ptTask->Param.tCopy.tSource.iStride
== ptTask->Param.tCopy.tCopySize.iWidth)) {
//! direct blending
__arm_2d_impl_gray8_alpha_blending_direct(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tCopySize.iHeight
* ptTask->Param.tCopy.tCopySize.iWidth,
this.chRatio);
} else
#endif
{
__arm_2d_impl_gray8_alpha_blending(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tSource.iStride,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
&(ptTask->Param.tCopy.tCopySize),
this.chRatio);
}
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_rgb565_sw_alpha_blending(__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_t, ptTask->ptOP)
assert(ARM_2D_COLOUR_RGB565 == OP_CORE.ptOp->Info.Colour.chScheme);
if ( (ptTask->Param.tCopy.tSource.iStride
== ptTask->Param.tCopy.tTarget.iStride)
&& (ptTask->Param.tCopy.tSource.iStride
== ptTask->Param.tCopy.tCopySize.iWidth)) {
//! direct blending
__arm_2d_impl_rgb565_alpha_blending_direct(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tCopySize.iHeight
* ptTask->Param.tCopy.tCopySize.iWidth,
this.chRatio);
} else {
__arm_2d_impl_rgb565_alpha_blending(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tSource.iStride,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
&(ptTask->Param.tCopy.tCopySize),
this.chRatio);
}
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_cccn888_sw_alpha_blending(__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_t, ptTask->ptOP)
assert(ARM_2D_COLOUR_SZ_32BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
if ( (ptTask->Param.tCopy.tSource.iStride
== ptTask->Param.tCopy.tTarget.iStride)
&& (ptTask->Param.tCopy.tSource.iStride
== ptTask->Param.tCopy.tCopySize.iWidth)) {
//! direct blending
__arm_2d_impl_cccn888_alpha_blending_direct(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tCopySize.iHeight
* ptTask->Param.tCopy.tCopySize.iWidth,
this.chRatio);
} else {
__arm_2d_impl_cccn888_alpha_blending(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tSource.iStride,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
&(ptTask->Param.tCopy.tCopySize),
this.chRatio);
}
return arm_fsm_rt_cpl;
}
/*----------------------------------------------------------------------------*
* Fill a specified region with a given colour and transparency ratio (0~255) *
*----------------------------------------------------------------------------*/
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_gray8_fill_colour_with_opacity(
arm_2d_op_fill_cl_opc_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint8_t chColour,
uint_fast8_t chRatio)
{
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_fill_cl_opc_t, ptOP);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_COLOUR_FILL_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.chColour = chColour;
this.chRatio = chRatio;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_rgb565_fill_colour_with_opacity(
arm_2d_op_fill_cl_opc_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
arm_2d_color_rgb565_t tColour,
uint_fast8_t chRatio)
{
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_fill_cl_opc_t, ptOP);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_COLOUR_FILL_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.hwColour = tColour.tValue;
this.chRatio = chRatio;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_cccn888_fill_colour_with_opacity(
arm_2d_op_fill_cl_opc_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
arm_2d_color_rgb888_t tColour,
uint_fast8_t chRatio)
{
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_fill_cl_opc_t, ptOP);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_COLOUR_FILL_RGB888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.wColour = tColour.tValue;
this.chRatio = chRatio;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
arm_fsm_rt_t __arm_2d_gray8_sw_colour_filling_with_opacity(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_fill_cl_opc_t, ptTask->ptOP)
assert(ARM_2D_COLOUR_GRAY8 == OP_CORE.ptOp->Info.Colour.chScheme);
__arm_2d_impl_gray8_colour_filling_with_opacity(
ptTask->Param.tTileProcess.pBuffer,
ptTask->Param.tTileProcess.iStride,
&(ptTask->Param.tTileProcess.tValidRegion.tSize),
this.chColour,
this.chRatio);
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_rgb565_sw_colour_filling_with_opacity(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_fill_cl_opc_t, ptTask->ptOP)
assert(ARM_2D_COLOUR_RGB565 == OP_CORE.ptOp->Info.Colour.chScheme);
__arm_2d_impl_rgb565_colour_filling_with_opacity(
ptTask->Param.tTileProcess.pBuffer,
ptTask->Param.tTileProcess.iStride,
&(ptTask->Param.tTileProcess.tValidRegion.tSize),
this.hwColour,
this.chRatio);
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_cccn888_sw_colour_filling_with_opacity(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_fill_cl_opc_t, ptTask->ptOP)
assert(ARM_2D_COLOUR_SZ_32BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
__arm_2d_impl_cccn888_colour_filling_with_opacity(
ptTask->Param.tTileProcess.pBuffer,
ptTask->Param.tTileProcess.iStride,
&(ptTask->Param.tTileProcess.tValidRegion.tSize),
this.wColour,
this.chRatio);
return arm_fsm_rt_cpl;
}
/*----------------------------------------------------------------------------*
* Fill tile with a specified colour and an alpha mask *
*----------------------------------------------------------------------------*/
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_gray8_fill_colour_with_mask(
arm_2d_op_fill_cl_msk_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
const arm_2d_tile_t *ptAlpha,
uint8_t chColour)
{
assert(NULL != ptTarget);
if (NULL == ptAlpha) {
return arm_2dp_c8bit_fill_colour( (arm_2d_op_fill_cl_t *)ptOP,
ptTarget,
ptRegion,
chColour);
} else{
ARM_2D_IMPL(arm_2d_op_fill_cl_msk_t, ptOP);
//! valid alpha mask tile
if (0 == ptAlpha->bHasEnforcedColour) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptAlpha->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptAlpha->tColourInfo.chScheme)) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Mask.ptTile = ptAlpha;
this.wMode = 0;
this.chColour = chColour;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
}
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_rgb565_fill_colour_with_mask(
arm_2d_op_fill_cl_msk_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
const arm_2d_tile_t *ptAlpha,
arm_2d_color_rgb565_t tColour)
{
assert(NULL != ptTarget);
if (NULL == ptAlpha) {
return arm_2dp_rgb16_fill_colour( (arm_2d_op_fill_cl_t *)ptOP,
ptTarget,
ptRegion,
tColour.tValue);
} else{
ARM_2D_IMPL(arm_2d_op_fill_cl_msk_t, ptOP);
//! valid alpha mask tile
if (0 == ptAlpha->bHasEnforcedColour) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptAlpha->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptAlpha->tColourInfo.chScheme)) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Mask.ptTile = ptAlpha;
this.wMode = 0;
this.hwColour = tColour.tValue;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
}
ARM_NONNULL(2,4)
arm_fsm_rt_t arm_2dp_cccn888_fill_colour_with_mask(
arm_2d_op_fill_cl_msk_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
const arm_2d_tile_t *ptAlpha,
arm_2d_color_cccn888_t tColour)
{
assert(NULL != ptTarget);
assert(NULL != ptAlpha);
if (NULL == ptAlpha) {
return arm_2dp_rgb32_fill_colour( (arm_2d_op_fill_cl_t *)ptOP,
ptTarget,
ptRegion,
tColour.tValue);
} else{
ARM_2D_IMPL(arm_2d_op_fill_cl_msk_t, ptOP);
//! valid alpha mask tile
if (0 == ptAlpha->bHasEnforcedColour) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptAlpha->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptAlpha->tColourInfo.chScheme)) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_CCCN888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Mask.ptTile = ptAlpha;
this.wMode = 0;
this.wColour = tColour.tValue;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
}
arm_fsm_rt_t __arm_2d_gray8_sw_colour_filling_with_mask(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_fill_cl_msk_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_SZ_16BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
if (ARM_2D_CHANNEL_8in32 == ptTask->Param.tCopy.tSource.tColour.chScheme) {
#if !__ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__
return (arm_fsm_rt_t)ARM_2D_ERR_UNSUPPORTED_COLOUR;
#else
__arm_2d_impl_gray8_colour_filling_channel_mask(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.chColour);
#endif
} else {
__arm_2d_impl_gray8_colour_filling_mask(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.chColour);
}
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_rgb565_sw_colour_filling_with_mask(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_fill_cl_msk_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_SZ_16BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
if (ARM_2D_CHANNEL_8in32 == ptTask->Param.tCopy.tSource.tColour.chScheme) {
#if !__ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__
return (arm_fsm_rt_t)ARM_2D_ERR_UNSUPPORTED_COLOUR;
#else
__arm_2d_impl_rgb565_colour_filling_channel_mask(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour);
#endif
} else {
__arm_2d_impl_rgb565_colour_filling_mask(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour);
}
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_cccn888_sw_colour_filling_with_mask(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_fill_cl_msk_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_SZ_32BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
if (ARM_2D_CHANNEL_8in32 == ptTask->Param.tCopy.tSource.tColour.chScheme) {
#if !__ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__
return (arm_fsm_rt_t)ARM_2D_ERR_UNSUPPORTED_COLOUR;
#else
__arm_2d_impl_cccn888_colour_filling_channel_mask(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour);
#endif
} else {
__arm_2d_impl_cccn888_colour_filling_mask(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour);
}
return arm_fsm_rt_cpl;
}
/*----------------------------------------------------------------------------*
* Fill tile with a specified colour, an alpha mask and a specified opacity *
*----------------------------------------------------------------------------*/
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_gray8_fill_colour_with_mask_and_opacity(
arm_2d_op_alpha_fill_cl_msk_opc_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
const arm_2d_tile_t *ptAlpha,
uint8_t chColour,
uint8_t chOpacity)
{
assert(NULL != ptTarget);
if (NULL == ptAlpha) {
return arm_2dp_gray8_fill_colour_with_opacity(
(arm_2d_op_fill_cl_opc_t *)ptOP,
ptTarget,
ptRegion,
chColour,
chOpacity);
} else{
ARM_2D_IMPL(arm_2d_op_alpha_fill_cl_msk_opc_t, ptOP);
//! valid alpha mask tile
if (0 == ptAlpha->bHasEnforcedColour) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptAlpha->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptAlpha->tColourInfo.chScheme)) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_AND_OPACITY_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Mask.ptTile = ptAlpha;
this.wMode = 0;
this.chColour = chColour;
this.chOpacity = chOpacity;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
}
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_rgb565_fill_colour_with_mask_and_opacity(
arm_2d_op_alpha_fill_cl_msk_opc_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
const arm_2d_tile_t *ptAlpha,
arm_2d_color_rgb565_t tColour,
uint8_t chOpacity)
{
assert(NULL != ptTarget);
if (NULL == ptAlpha) {
return arm_2dp_rgb565_fill_colour_with_opacity(
(arm_2d_op_fill_cl_opc_t *)ptOP,
ptTarget,
ptRegion,
tColour,
chOpacity);
} else{
ARM_2D_IMPL(arm_2d_op_alpha_fill_cl_msk_opc_t, ptOP);
//! valid alpha mask tile
if (0 == ptAlpha->bHasEnforcedColour) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptAlpha->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptAlpha->tColourInfo.chScheme)) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_AND_OPACITY_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Mask.ptTile = ptAlpha;
this.wMode = 0;
this.hwColour = tColour.tValue;
this.chOpacity = chOpacity;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
}
ARM_NONNULL(2)
arm_fsm_rt_t arm_2dp_cccn888_fill_colour_with_mask_and_opacity(
arm_2d_op_alpha_fill_cl_msk_opc_t *ptOP,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
const arm_2d_tile_t *ptAlpha,
arm_2d_color_rgb888_t tColour,
uint8_t chOpacity)
{
assert(NULL != ptTarget);
if (NULL == ptAlpha) {
return arm_2dp_cccn888_fill_colour_with_opacity(
(arm_2d_op_fill_cl_opc_t *)ptOP,
ptTarget,
ptRegion,
tColour,
chOpacity);
} else{
ARM_2D_IMPL(arm_2d_op_alpha_fill_cl_msk_opc_t, ptOP);
//! valid alpha mask tile
if (0 == ptAlpha->bHasEnforcedColour) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
} else if ( (ARM_2D_COLOUR_SZ_8BIT != ptAlpha->tColourInfo.u3ColourSZ)
&& (ARM_2D_CHANNEL_8in32 != ptAlpha->tColourInfo.chScheme)) {
return (arm_fsm_rt_t)ARM_2D_ERR_INVALID_PARAM;
}
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_AND_OPACITY_CCCN888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Mask.ptTile = ptAlpha;
this.wMode = 0;
this.wColour = tColour.tValue;
this.chOpacity = chOpacity;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
}
arm_fsm_rt_t __arm_2d_gray8_sw_colour_filling_with_mask_and_opacity(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_fill_cl_msk_opc_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_SZ_16BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
if (ARM_2D_CHANNEL_8in32 == ptTask->Param.tCopy.tSource.tColour.chScheme) {
#if !__ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__
return (arm_fsm_rt_t)ARM_2D_ERR_UNSUPPORTED_COLOUR;
#else
__arm_2d_impl_gray8_colour_filling_channel_mask_opacity(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.chColour,
this.chOpacity);
#endif
} else {
__arm_2d_impl_gray8_colour_filling_mask_opacity(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.chColour,
this.chOpacity);
}
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_rgb565_sw_colour_filling_with_mask_and_opacity(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_fill_cl_msk_opc_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_SZ_16BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
if (ARM_2D_CHANNEL_8in32 == ptTask->Param.tCopy.tSource.tColour.chScheme) {
#if !__ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__
return (arm_fsm_rt_t)ARM_2D_ERR_UNSUPPORTED_COLOUR;
#else
__arm_2d_impl_rgb565_colour_filling_channel_mask_opacity(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour,
this.chOpacity);
#endif
} else {
__arm_2d_impl_rgb565_colour_filling_mask_opacity(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour,
this.chOpacity);
}
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_cccn888_sw_colour_filling_with_mask_and_opacity(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_fill_cl_msk_opc_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_SZ_32BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
if (ARM_2D_CHANNEL_8in32 == ptTask->Param.tCopy.tSource.tColour.chScheme) {
#if !__ARM_2D_CFG_SUPPORT_COLOUR_CHANNEL_ACCESS__
return (arm_fsm_rt_t)ARM_2D_ERR_UNSUPPORTED_COLOUR;
#else
__arm_2d_impl_cccn888_colour_filling_channel_mask_opacity(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour,
this.chOpacity);
#endif
} else {
__arm_2d_impl_cccn888_colour_filling_mask_opacity(
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
ptTask->Param.tCopy.tSource.pBuffer, //!< alpha tile
ptTask->Param.tCopy.tSource.iStride, //!< alpha tile
&(ptTask->Param.tCopy.tCopySize),
this.hwColour,
this.chOpacity);
}
return arm_fsm_rt_cpl;
}
/*----------------------------------------------------------------------------*
* Blend tile and background with a specified transparency ratio(0~255) and a *
* specified transparency color mask *
*----------------------------------------------------------------------------*/
ARM_NONNULL(2,3)
arm_fsm_rt_t arm_2dp_gray8_alpha_blending_with_colour_keying(
arm_2d_op_alpha_cl_key_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint_fast8_t chRatio,
uint8_t chColour)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_alpha_cl_key_t);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_BLENDING_WITH_COLOUR_KEYING_GRAY8;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = 0;
this.chRatio = chRatio;
this.chColour = chColour;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3)
arm_fsm_rt_t arm_2dp_rgb565_alpha_blending_with_colour_keying(
arm_2d_op_alpha_cl_key_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint_fast8_t chRatio,
arm_2d_color_rgb565_t tColour)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_alpha_cl_key_t);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = &ARM_2D_OP_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB565;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = 0;
this.chRatio = chRatio;
this.hwColour = tColour.tValue;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
ARM_NONNULL(2,3)
arm_fsm_rt_t arm_2dp_cccn888_alpha_blending_with_colour_keying(
arm_2d_op_alpha_cl_key_t *ptOP,
const arm_2d_tile_t *ptSource,
const arm_2d_tile_t *ptTarget,
const arm_2d_region_t *ptRegion,
uint_fast8_t chRatio,
arm_2d_color_rgb888_t tColour)
{
assert(NULL != ptSource);
assert(NULL != ptTarget);
ARM_2D_IMPL(arm_2d_op_alpha_cl_key_t);
if (!__arm_2d_op_acquire((arm_2d_op_core_t *)ptThis)) {
return arm_fsm_rt_on_going;
}
//memset(ptThis, 0, sizeof(*ptThis));
OP_CORE.ptOp = & ARM_2D_OP_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB888;
this.Target.ptTile = ptTarget;
this.Target.ptRegion = ptRegion;
this.Source.ptTile = ptSource;
this.wMode = 0;
this.chRatio = chRatio;
this.wColour = tColour.tValue;
return __arm_2d_op_invoke((arm_2d_op_core_t *)ptThis);
}
arm_fsm_rt_t __arm_2d_gray8_sw_alpha_blending_with_colour_keying(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_cl_key_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_GRAY8 == OP_CORE.ptOp->Info.Colour.chScheme);
__arm_2d_impl_gray8_alpha_blending_colour_keying(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tSource.iStride,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
&ptTask->Param.tCopy.tCopySize,
this.chRatio,
this.chColour);
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_rgb565_sw_alpha_blending_with_colour_keying(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_cl_key_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_RGB565 == OP_CORE.ptOp->Info.Colour.chScheme);
__arm_2d_impl_rgb565_alpha_blending_colour_keying(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tSource.iStride,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
&ptTask->Param.tCopy.tCopySize,
this.chRatio,
this.hwColour);
return arm_fsm_rt_cpl;
}
arm_fsm_rt_t __arm_2d_cccn888_sw_alpha_blending_with_colour_keying(
__arm_2d_sub_task_t *ptTask)
{
ARM_2D_IMPL(arm_2d_op_alpha_cl_key_t, ptTask->ptOP)
//assert(ARM_2D_COLOUR_SZ_32BIT == OP_CORE.ptOp->Info.Colour.u3ColourSZ);
__arm_2d_impl_cccn888_alpha_blending_colour_keying(
ptTask->Param.tCopy.tSource.pBuffer,
ptTask->Param.tCopy.tSource.iStride,
ptTask->Param.tCopy.tTarget.pBuffer,
ptTask->Param.tCopy.tTarget.iStride,
&ptTask->Param.tCopy.tCopySize,
this.chRatio,
this.wColour);
return arm_fsm_rt_cpl;
}
/*----------------------------------------------------------------------------*
* Accelerable Low Level APIs *
*----------------------------------------------------------------------------*/
__WEAK
void __arm_2d_impl_rgb565_alpha_blending( uint16_t *__RESTRICT phwSourceBase,
int16_t iSourceStride,
uint16_t *__RESTRICT phwTargetBase,
int16_t iTargetStride,
arm_2d_size_t *__RESTRICT ptCopySize,
uint_fast8_t chRatio)
{
uint32_t iHeight = ptCopySize->iHeight;
uint32_t iWidth = ptCopySize->iWidth;
uint16_t ratioCompl = 256 - chRatio;
ARM_2D_UNUSED(ratioCompl);
for (uint32_t y = 0; y < iHeight; y++) {
#if (defined (__ARM_ARCH_8_1M_MAIN__) && (__ARM_ARCH_8_1M_MAIN__ == 1))
/* M55 NOMVE optimization */
register unsigned loopCnt __asm("lr");
loopCnt = iWidth;
__asm volatile(
" dls lr, lr \n"
".p2align 2 \n"
"1: \n"
/* read source / target pixel */
" ldrh r4, [%[src]], #2 \n"
" ldrh r5, [%[pTarget]] \n"
/* unpack R */
" and r0, r4, #31 \n"
" and r1, r5, #31 \n"
/* unpack B */
" lsr r2, r4, #11 \n"
" lsr r3, r5, #11 \n"
/* unpack G */
" ubfx r4, r4, #5, #6 \n"
" ubfx r5, r5, #5, #6 \n"
/* mix */
" mul r0, r0, %[ratio0] \n"
" mul r4, r4, %[ratio0] \n"
" mul r2, r2, %[ratio0] \n"
" mla r0, %[ratio1], r1, r0 \n"
" mla r1, %[ratio1], r5, r4 \n"
/* pack R */
" ubfx r0, r0, #8, #5 \n"
/* shift & mask G */
" and r1, %[cst], r1, lsr #3 \n"
/* MLA moved here to fill stall */
" mla r5, %[ratio1], r3, r2 \n"
/* pack G */
" add r0, r0, r1 \n"
/* pack R */
" bic r1, r5, #255 \n"
" orr r0, r0, r1, lsl #3 \n"
" strh r0, [%[pTarget]], #2 \n"
" le lr, 1b \n"
: [src] "+r" (phwSourceBase), [pTarget] "+r" (phwTargetBase),
[cnt] "+r" (loopCnt)
: [ratio1] "r" ((256 - (uint_fast16_t)chRatio) ),
[ratio0] "r" (chRatio), [cst] "r" (0x7e0 /* mask G */)
: "r0", "r1", "r2", "r3",
"r4", "r5", "memory"
);
#else
for (uint32_t x = 0; x < iWidth; x++) {
__arm_2d_color_fast_rgb_t srcPix, targetPix;
__arm_2d_rgb565_unpack(*phwSourceBase++, &srcPix);
__arm_2d_rgb565_unpack(*phwTargetBase, &targetPix);
for (int i = 0; i < 3; i++) {
uint16_t tmp =
(uint16_t) (srcPix.RGB[i] * chRatio) +
(targetPix.RGB[i] * ratioCompl);
targetPix.RGB[i] = (uint16_t) (tmp >> 8);
}
/* pack merged stream */
*phwTargetBase++ = __arm_2d_rgb565_pack(&targetPix);
}
#endif
phwSourceBase += (iSourceStride - iWidth);
phwTargetBase += (iTargetStride - iWidth);
}
}
__WEAK
void __arm_2d_impl_rgb565_alpha_blending_direct(const uint16_t *phwSource,
const uint16_t *phwBackground,
uint16_t *phwDestination,
uint32_t wPixelCount,
uint_fast8_t chRatio)
{
uint16_t ratioCompl = 256 - chRatio;
ARM_2D_UNUSED(ratioCompl);
#if (defined (__ARM_ARCH_8_1M_MAIN__) && (__ARM_ARCH_8_1M_MAIN__ == 1))
/* M55 NOMVE optimization */
register unsigned loopCnt __asm("lr");
loopCnt = wPixelCount;
__asm volatile(
" dls lr, lr \n"
".p2align 2 \n"
"1: \n"
/* read source / target pixel */
" ldrh r4, [%[src]], #2 \n"
" ldrh r5, [%[backgrd]], #2 \n"
/* unpack R */
" and r0, r4, #31 \n"
" and r1, r5, #31 \n"
/* unpack B */
" lsr r2, r4, #11 \n"
" lsr r3, r5, #11 \n"
/* unpack G */
" ubfx r4, r4, #5, #6 \n"
" ubfx r5, r5, #5, #6 \n"
/* mix */
" mul r0, r0, %[ratio0] \n"
" mul r4, r4, %[ratio0] \n"
" mul r2, r2, %[ratio0] \n"
" mla r0, %[ratio1], r1, r0 \n"
" mla r1, %[ratio1], r5, r4 \n"
/* pack R */
" ubfx r0, r0, #8, #5 \n"
/* shift & mask G */
" and r1, %[cst], r1, lsr #3 \n"
/* MLA moved here to fill stall */
" mla r5, %[ratio1], r3, r2 \n"
/* pack G */
" add r0, r0, r1 \n"
/* pack R */
" bic r1, r5, #255 \n"
" orr r0, r0, r1, lsl #3 \n"
" strh r0, [%[pTarget]], #2 \n"
" le lr, 1b \n"
: [src] "+r" (phwSource), [backgrd] "+r" (phwBackground),
[pTarget] "+r" (phwDestination), [cnt] "+r" (loopCnt)
: [ratio1] "r" ((256 - (uint_fast16_t)chRatio) ),
[ratio0] "r" (chRatio), [cst] "r" (0x7e0 /* mask G */)
: "r0", "r1", "r2", "r3",
"r4", "r5", "memory"
);
#else
do {
__arm_2d_color_fast_rgb_t wSourcePixel, wBackgroundPixel, wTargetPixel;
__arm_2d_rgb565_unpack(*phwSource++, &wSourcePixel);
__arm_2d_rgb565_unpack(*phwBackground++, &wBackgroundPixel);
for (int i = 0; i < 3; i++) {
uint16_t tmp =
(uint16_t) (wSourcePixel.RGB[i] * chRatio) +
(wBackgroundPixel.RGB[i] * ratioCompl);
wTargetPixel.RGB[i] = (uint16_t) (tmp >> 8);
}
*phwDestination++ = __arm_2d_rgb565_pack(&wTargetPixel);
} while (--wPixelCount);
#endif
}
__WEAK
void __arm_2d_impl_cccn888_alpha_blending_direct(const uint32_t *pwSource,
const uint32_t *pwBackground,
uint32_t *pwDestination,
uint32_t wPixelCount,
uint_fast8_t chRatio)
{
do {
uint_fast8_t n = sizeof(uint32_t) - 1;
const uint8_t *pchSrc = (uint8_t *)(pwSource++);
const uint8_t *pchBG = (uint8_t *)(pwBackground++);
uint8_t *pchDes = (uint8_t *)(pwDestination++);
do {
*pchDes++ = ( ((uint_fast16_t)(*pchSrc++) * chRatio)
+ ( (uint_fast16_t)(*pchBG++)
* (256 - (uint_fast16_t)chRatio))) >> 8;
} while(--n);
} while(--wPixelCount);
}
/*----------------------------------------------------------------------------*
* Low Level IO Interfaces *
*----------------------------------------------------------------------------*/
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_GRAY8,
__arm_2d_gray8_sw_colour_filling_with_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_RGB565,
__arm_2d_rgb565_sw_colour_filling_with_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_RGB888,
__arm_2d_cccn888_sw_colour_filling_with_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_AND_OPACITY_GRAY8,
__arm_2d_gray8_sw_colour_filling_with_mask_and_opacity);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_AND_OPACITY_RGB565,
__arm_2d_rgb565_sw_colour_filling_with_mask_and_opacity);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_AND_OPACITY_CCCN888,
__arm_2d_cccn888_sw_colour_filling_with_mask_and_opacity);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_GRAY8,
__arm_2d_gray8_sw_alpha_blending);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_RGB565,
__arm_2d_rgb565_sw_alpha_blending);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_RGB888,
__arm_2d_cccn888_sw_alpha_blending);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_MASKS_GRAY8,
__arm_2d_gray8_sw_tile_copy_with_masks);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_MASKS_GRAY8,
__arm_2d_gray8_sw_tile_fill_with_masks);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_MASKS_RGB565,
__arm_2d_rgb565_sw_tile_copy_with_masks);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_MASKS_RGB565,
__arm_2d_rgb565_sw_tile_fill_with_masks);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_MASKS_CCCN888,
__arm_2d_cccn888_sw_tile_copy_with_masks);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_MASKS_CCCN888,
__arm_2d_cccn888_sw_tile_fill_with_masks);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_SRC_MASK_GRAY8,
__arm_2d_gray8_sw_tile_copy_with_src_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_SRC_MASK_GRAY8,
__arm_2d_gray8_sw_tile_fill_with_src_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_SRC_MASK_RGB565,
__arm_2d_rgb565_sw_tile_copy_with_src_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_SRC_MASK_RGB565,
__arm_2d_rgb565_sw_tile_fill_with_src_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_SRC_MASK_CCCN888,
__arm_2d_cccn888_sw_tile_copy_with_src_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_SRC_MASK_CCCN888,
__arm_2d_cccn888_sw_tile_fill_with_src_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_DES_MASK_GRAY8,
__arm_2d_gray8_sw_tile_copy_with_des_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_DES_MASK_GRAY8,
__arm_2d_gray8_sw_tile_fill_with_des_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_DES_MASK_RGB565,
__arm_2d_rgb565_sw_tile_copy_with_des_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_DES_MASK_RGB565,
__arm_2d_rgb565_sw_tile_fill_with_des_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_COPY_WITH_DES_MASK_CCCN888,
__arm_2d_cccn888_sw_tile_copy_with_des_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_FILL_WITH_DES_MASK_CCCN888,
__arm_2d_cccn888_sw_tile_fill_with_des_mask);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_WITH_COLOUR_KEYING_GRAY8,
__arm_2d_gray8_sw_alpha_blending_with_colour_keying);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB565,
__arm_2d_rgb565_sw_alpha_blending_with_colour_keying);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB888,
__arm_2d_cccn888_sw_alpha_blending_with_colour_keying);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_FILL_COLOUR_GRAY8,
__arm_2d_gray8_sw_colour_filling_with_opacity);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_FILL_COLOUR_RGB565,
__arm_2d_rgb565_sw_colour_filling_with_opacity);
__WEAK
def_low_lv_io(__ARM_2D_IO_ALPHA_FILL_COLOUR_RGB888,
__arm_2d_cccn888_sw_colour_filling_with_opacity);
const __arm_2d_op_info_t ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bAllowEnforcedColour = true,
},
.chOpIndex = __ARM_2D_OP_IDX_FILL_COLOUR_WITH_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_GRAY8),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bAllowEnforcedColour = true,
},
.chOpIndex = __ARM_2D_OP_IDX_FILL_COLOUR_WITH_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_RGB565),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_CCCN888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB888,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bAllowEnforcedColour = true,
},
.chOpIndex = __ARM_2D_OP_IDX_FILL_COLOUR_WITH_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_RGB888),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_AND_OPACITY_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bAllowEnforcedColour = true,
},
.chOpIndex = __ARM_2D_OP_IDX_FILL_COLOUR_WITH_MASK_AND_OPACITY,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_AND_OPACITY_GRAY8),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_AND_OPACITY_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bAllowEnforcedColour = true,
},
.chOpIndex = __ARM_2D_OP_IDX_FILL_COLOUR_WITH_MASK_AND_OPACITY,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_AND_OPACITY_RGB565),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_FILL_COLOUR_WITH_ALPHA_MASK_AND_OPACITY_CCCN888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB888,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bAllowEnforcedColour = true,
},
.chOpIndex = __ARM_2D_OP_IDX_FILL_COLOUR_WITH_MASK_AND_OPACITY,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_FILL_COLOUR_ALPHA_MASK_AND_OPACITY_CCCN888),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_BLENDING_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_BLENDING,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_GRAY8),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_BLENDING_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_BLENDING,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_RGB565),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_BLENDING_RGB888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB888,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_BLENDING,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_RGB888),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_BLENDING_WITH_COLOUR_KEYING_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_BLENDING_WITH_COLOUR_KEYING,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_WITH_COLOUR_KEYING_GRAY8),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_BLENDING_WITH_COLOUR_KEYING,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB565),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB888,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_BLENDING_WITH_COLOUR_KEYING,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_BLENDING_WITH_COLOUR_KEYING_RGB888),
.ptFillLike = NULL,
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_COLOUR_FILL_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = false,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_FILL_COLOUR,
.LowLevelIO = {
.ptTileProcessLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_FILL_COLOUR_GRAY8),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_COLOUR_FILL_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = false,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_FILL_COLOUR,
.LowLevelIO = {
.ptTileProcessLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_FILL_COLOUR_RGB565),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_ALPHA_COLOUR_FILL_RGB888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB888,
},
.Param = {
.bHasSource = false,
.bHasTarget = true,
},
.chOpIndex = __ARM_2D_OP_IDX_ALPHA_FILL_COLOUR,
.LowLevelIO = {
.ptTileProcessLike = ref_low_lv_io(__ARM_2D_IO_ALPHA_FILL_COLOUR_RGB888),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_MASK_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = true,
.bHasDesMask = true,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_MASKS_GRAY8),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_MASKS_GRAY8),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_MASK_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = true,
.bHasDesMask = true,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_MASKS_RGB565),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_MASKS_RGB565),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_MASK_CCCN888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_CCCN888,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = true,
.bHasDesMask = true,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_MASKS_CCCN888),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_MASKS_CCCN888),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_SRC_MASK_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = true,
.bHasDesMask = false,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_SRC_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_SRC_MASK_GRAY8),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_SRC_MASK_GRAY8),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_SRC_MASK_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = true,
.bHasDesMask = false,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_SRC_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_SRC_MASK_RGB565),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_SRC_MASK_RGB565),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_SRC_MASK_CCCN888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_CCCN888,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = true,
.bHasDesMask = false,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_SRC_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_SRC_MASK_CCCN888),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_SRC_MASK_CCCN888),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_DES_MASK_GRAY8 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_GRAY8,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = false,
.bHasDesMask = true,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_DES_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_DES_MASK_GRAY8),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_DES_MASK_GRAY8),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_DES_MASK_RGB565 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_RGB565,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = false,
.bHasDesMask = true,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_DES_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_DES_MASK_RGB565),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_DES_MASK_RGB565),
},
},
};
const __arm_2d_op_info_t ARM_2D_OP_TILE_COPY_WITH_DES_MASK_CCCN888 = {
.Info = {
.Colour = {
.chScheme = ARM_2D_COLOUR_CCCN888,
},
.Param = {
.bHasSource = true,
.bHasTarget = true,
.bHasSrcMask = false,
.bHasDesMask = true,
},
.chOpIndex = __ARM_2D_OP_IDX_COPY_WITH_DES_MASK,
.LowLevelIO = {
.ptCopyLike = ref_low_lv_io(__ARM_2D_IO_COPY_WITH_DES_MASK_CCCN888),
.ptFillLike = ref_low_lv_io(__ARM_2D_IO_FILL_WITH_DES_MASK_CCCN888),
},
},
};
#if defined(__clang__)
# pragma clang diagnostic pop
#elif defined(__IS_COMPILER_ARM_COMPILER_5__)
# pragma diag_warning 174,177,188,68,513,144
#endif
#ifdef __cplusplus
}
#endif
Reference in New Issue Copy Permalink