/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* FUNCTIONS
* mlib_v_ImageChannelInsert_U8
* mlib_v_ImageChannelInsert_U8_12_A8D1X8
* mlib_v_ImageChannelInsert_U8_12_A8D2X8
* mlib_v_ImageChannelInsert_U8_12_D1
* mlib_v_ImageChannelInsert_U8_12
* mlib_v_ImageChannelInsert_U8_13_A8D1X8
* mlib_v_ImageChannelInsert_U8_13_A8D2X8
* mlib_v_ImageChannelInsert_U8_13_D1
* mlib_v_ImageChannelInsert_U8_13
* mlib_v_ImageChannelInsert_U8_14_A8D1X8
* mlib_v_ImageChannelInsert_U8_14_A8D2X8
* mlib_v_ImageChannelInsert_U8_14_D1
* mlib_v_ImageChannelInsert_U8_14
* mlib_v_ImageChannelInsert_S16
* mlib_v_ImageChannelInsert_S16_12_A8D1X4
* mlib_v_ImageChannelInsert_S16_12_A8D2X4
* mlib_v_ImageChannelInsert_S16_12_D1
* mlib_v_ImageChannelInsert_S16_12
* mlib_v_ImageChannelInsert_S16_13_A8D1X4
* mlib_v_ImageChannelInsert_S16_13_A8D2X4
* mlib_v_ImageChannelInsert_S16_13_D1
* mlib_v_ImageChannelInsert_S16_13
* mlib_v_ImageChannelInsert_S16_14_A8D1X4
* mlib_v_ImageChannelInsert_S16_14_A8D2X4
* mlib_v_ImageChannelInsert_S16_14_D1
* mlib_v_ImageChannelInsert_S16_14
* mlib_v_ImageChannelInsert_S32
* mlib_v_ImageChannelInsert_D64
*
* ARGUMENT
* src pointer to source image data
* dst pointer to destination image data
* slb source image line stride in bytes
* dlb destination image line stride in bytes
* dsize image data size in pixels
* xsize image width in pixels
* ysize image height in lines
* cmask channel mask
*
* DESCRIPTION
* Copy the 1-channel source image into the selected channel
* of the destination image -- VIS version low level functions.
*
* NOTE
* These functions are separated from mlib_v_ImageChannelInsert.c
* for loop unrolling and structure clarity.
*/
#include "vis_proto.h"
#include "mlib_image.h"
#include "mlib_v_ImageChannelInsert.h"
/***************************************************************/
/* general channel insertion: slower due to the inner loop */
{
mlib_s32 i, j, k; /* indices for x, y, channel */
for (i = (channeld - 1), k = 0; i >= 0; i--) {
if ((cmask & (1 << i)) == 0)
deltac[k]++;
else
k++;
}
for (i = 1; i < channels; i++) {
}
if (channels == 2) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 2;
}
}
}
else if (channels == 3) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 3;
}
}
}
}
/***************************************************************/
/* general channel insertion: slower due to the inner loop */
{
mlib_s32 i, j, k; /* indices for x, y, channel */
for (i = (channeld - 1), k = 0; i >= 0; i--) {
if ((cmask & (1 << i)) == 0)
deltac[k]++;
else
k++;
}
for (i = 1; i < channels; i++) {
}
if (channels == 1) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp++;
}
}
}
else if (channels == 2) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 2;
}
}
}
else if (channels == 3) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 3;
}
}
}
}
/***************************************************************/
/* general channel insertion: slower due to the inner loop */
{
mlib_s32 i, j, k; /* indices for x, y, channel */
for (i = (channeld - 1), k = 0; i >= 0; i--) {
if ((cmask & (1 << i)) == 0)
deltac[k]++;
else
k++;
}
for (i = 1; i < channels; i++) {
}
if (channels == 2) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 2;
}
}
}
else if (channels == 3) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 3;
}
}
}
}
/***************************************************************/
/* general channel insertion: slower due to the inner loop */
{
mlib_s32 i, j, k; /* indices for x, y, channel */
for (i = (channeld - 1), k = 0; i >= 0; i--) {
if ((cmask & (1 << i)) == 0)
deltac[k]++;
else
k++;
}
for (i = 1; i < channels; i++) {
}
if (channels == 1) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp++;
}
}
}
else if (channels == 2) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 2;
}
}
}
else if (channels == 3) {
for (j = 0; j < height; j++) {
#pragma pipeloop(0)
for (i = 0; i < width; i++) {
sp += 3;
}
}
}
}
/***************************************************************/
/***************************************************************/
/* insert one channel to a 2-channel image.
* both source and destination image data are 8-byte aligned.
* dsize is multiple of 8.
*/
{
mlib_s32 i;
#pragma pipeloop(0)
for (i = 0; i < dsize / 8; i++) {
}
}
/***************************************************************/
/* insert one channel to a 2-channel image.
* both source and destination image data are 8-byte aligned.
* xsize is multiple of 8.
*/
{
mlib_s32 i, j;
for (j = 0; j < ysize; j++) {
#pragma pipeloop(0)
for (i = 0; i < xsize / 8; i++) {
}
}
}
/***************************************************************/
/* insert one channel to a 2-channel image.
*/
{
mlib_s32 i, n;
/* prepare the source address */
/* prepare the destination addresses */
/* calculate the src's offset over dst */
if (doff % 2 != 0) {
}
if (off == 0) { /* src and dst have same alignment */
/* load 8 bytes */
/* insert, including some garbage at the start point */
/* store 16 bytes result */
}
/* 8-pixel column loop, emask not needed */
#pragma pipeloop(0)
for (i = 0; i < n; i++) {
}
}
/* end point handling */
}
}
}
else if (off < 0) {
vis_alignaddr((void *)0, off);
/* generate edge mask for the start point */
/* load 8 bytes */
/* insert and store 16 bytes */
}
/* 8-pixel column loop, emask not needed */
#pragma pipeloop(0)
for (i = 0; i < n; i++) {
}
}
/* end point handling */
}
}
}
else if (off < 8) {
vis_alignaddr((void *)0, off);
/* generate edge mask for the start point */
/* load 16 bytes */
/* insert and store 16 bytes */
}
/* 8-pixel column loop, emask not needed */
#pragma pipeloop(0)
for (i = 0; i < n; i++) {
}
}
/* end point handling */
}
}
}
else { /* (off >= 8) */
vis_alignaddr((void *)0, off);
/* generate edge mask for the start point */
/* load 16 bytes */
/* insert and store 16 bytes */
}
/* 8-pixel column loop, emask not needed */
#pragma pipeloop(0)
for (i = 0; i < n; i++) {
}
}
/* end point handling */
}
}
}
}
/***************************************************************/
/* insert one channel to a 2-channel image.
*/
{
mlib_s32 j;
#pragma pipeloop(0)
for (j = 0; j < ysize; j++) {
}
}
/***************************************************************/
/***************************************************************/
/***************************************************************/
vis_alignaddr((void *)0, off); \
vis_alignaddr((void *)0, 1); \
/***************************************************************/
{
mlib_s32 i;
#pragma pipeloop(0)
for (i = 0; i < dsize / 8; i++) {
}
}
/***************************************************************/
{
mlib_s32 i, j;
vis_alignaddr((void *)0, 1);
for (j = 0; j < ysize; j++) {
#pragma pipeloop(0)
for (i = 0; i < xsize / 8; i++) {
}
}
}
/***************************************************************/
{
mlib_s32 i;
/* prepare the src address */
/* prepare the dst address */
#pragma pipeloop(0)
for (i = 0; i < dsize / 8; i++) {
}
/* right end handling */
vis_alignaddr((void *)0, off);
vis_alignaddr((void *)0, 1);
da += 3;
da += 3;
da += 3;
da += 3;
da += 3;
da += 3;
}
}
}
}
}
}
}
}
/***************************************************************/
{
mlib_s32 j;
#pragma pipeloop(0)
for (j = 0; j < ysize; j++) {
}
}
/***************************************************************/
/***************************************************************/
{
mlib_s32 i;
#pragma pipeloop(0)
for (i = 0; i < dsize / 8; i++) {
}
}
/***************************************************************/
{
mlib_s32 i, j;
for (j = 0; j < ysize; j++) {
#pragma pipeloop(0)
for (i = 0; i < xsize / 8; i++) {
}
}
}
/***************************************************************/
{
mlib_s32 i, n;
/* prepare the source address */
/* prepare the destination addresses */
if (doff == 0) { /* dst is 8-byte aligned */
vis_alignaddr((void *)0, soff);
}
}
}
/* 8-pixel column loop, emask not needed */
#pragma pipeloop(0)
for (i = 0; i < n; i++) {
}
}
/* end point handling */
}
}
}
}
}
else { /* dst is not 8-byte aligned */
vis_alignaddr((void *)0, soff);
vis_alignaddr((void *)0, -doff);
}
}
}
/* 8-pixel column loop, emask not needed */
#pragma pipeloop(0)
for (i = 0; i < n; i++) {
vis_alignaddr((void *)0, soff);
vis_alignaddr((void *)0, -doff);
}
}
/* end point handling */
vis_alignaddr((void *)0, soff);
vis_alignaddr((void *)0, -doff);
}
}
}
}
}
}
/***************************************************************/
{
mlib_s32 j;
#pragma pipeloop(0)
for (j = 0; j < ysize; j++) {
}
}
/***************************************************************/
/***************************************************************/
vis_alignaddr((void *)0, off); \
vis_alignaddr((void *)0, 2); \
/***************************************************************/
{
mlib_s32 i;
vis_alignaddr((void *)0, 2);
#pragma pipeloop(0)
for (i = 0; i < dsize / 4; i++) {
}
}
/***************************************************************/
{
mlib_s32 i, j;
vis_alignaddr((void *)0, 2);
for (j = 0; j < ysize; j++) {
#pragma pipeloop(0)
for (i = 0; i < xsize / 4; i++) {
}
}
}
/***************************************************************/
{
mlib_s32 i;
/* prepare the src address */
#pragma pipeloop(0)
for (i = 0; i < dsize / 4; i++) {
}
/* right end handling */
vis_alignaddr((void *)0, off);
vis_alignaddr((void *)0, 2);
da += 2;
da += 2;
}
}
}
}
/***************************************************************/
{
mlib_s32 j;
#pragma pipeloop(0)
for (j = 0; j < ysize; j++) {
}
}
/***************************************************************/
{
mlib_s32 i;
vis_alignaddr((void *)0, 2);
#pragma pipeloop(0)
for (i = 0; i < dsize / 4; i++) {
}
}
/***************************************************************/
{
mlib_s32 i, j;
vis_alignaddr((void *)0, 2);
for (j = 0; j < ysize; j++) {
#pragma pipeloop(0)
for (i = 0; i < xsize / 4; i++) {
}
}
}
/***************************************************************/
{
mlib_s32 i;
/* prepare the src address */
#pragma pipeloop(0)
for (i = 0; i < dsize / 4; i++) {
}
/* right end handling */
vis_alignaddr((void *)0, off);
vis_alignaddr((void *)0, 2);
da += 3;
da += 3;
}
}
}
}
/***************************************************************/
{
mlib_s32 j;
#pragma pipeloop(0)
for (j = 0; j < ysize; j++) {
}
}
/***************************************************************/
/* obsolete: it is slower than the vis_st_u16() version*/ \
/***************************************************************/
{
mlib_s32 i;
vis_alignaddr((void *)0, 2);
#pragma pipeloop(0)
for (i = 0; i < dsize / 4; i++) {
}
}
/***************************************************************/
{
mlib_s32 i, j;
vis_alignaddr((void *)0, 2);
for (j = 0; j < ysize; j++) {
#pragma pipeloop(0)
for (i = 0; i < xsize / 4; i++) {
}
}
}
/***************************************************************/
{
mlib_s32 i;
/* prepare the src address */
#pragma pipeloop(0)
for (i = 0; i < dsize / 4; i++) {
}
/* right end handling */
vis_alignaddr((void *)0, off);
vis_alignaddr((void *)0, 2);
da += 4;
da += 4;
}
}
}
}
/***************************************************************/
{
mlib_s32 j;
#pragma pipeloop(0)
for (j = 0; j < ysize; j++) {
}
}
/***************************************************************/