| /*====================================================================* |
| - Copyright (C) 2001 Leptonica. All rights reserved. |
| - This software is distributed in the hope that it will be |
| - useful, but with NO WARRANTY OF ANY KIND. |
| - No author or distributor accepts responsibility to anyone for the |
| - consequences of using this software, or for whether it serves any |
| - particular purpose or works at all, unless he or she says so in |
| - writing. Everyone is granted permission to copy, modify and |
| - redistribute this source code, for commercial or non-commercial |
| - purposes, with the following restrictions: (1) the origin of this |
| - source code must not be misrepresented; (2) modified versions must |
| - be plainly marked as such; and (3) this notice may not be removed |
| - or altered from any source or modified source distribution. |
| *====================================================================*/ |
| |
| /* |
| * ropiplow.c |
| * |
| * Low level in-place full height vertical block transfer |
| * |
| * void rasteropVipLow() |
| * |
| * Low level in-place full width horizontal block transfer |
| * |
| * void rasteropHipLow() |
| * void shiftDataHorizontalLow() |
| */ |
| |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "allheaders.h" |
| |
| |
| #define COMBINE_PARTIAL(d, s, m) ( ((d) & ~(m)) | ((s) & (m)) ) |
| |
| static const l_uint32 lmask32[] = {0x0, |
| 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, |
| 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000, |
| 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000, |
| 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, |
| 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000, |
| 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00, |
| 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, |
| 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff}; |
| |
| static const l_uint32 rmask32[] = {0x0, |
| 0x00000001, 0x00000003, 0x00000007, 0x0000000f, |
| 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, |
| 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff, |
| 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff, |
| 0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff, |
| 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff, |
| 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff, |
| 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff}; |
| |
| |
| /*--------------------------------------------------------------------* |
| * Low-level Vertical In-place Rasterop * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * rasteropVipLow() |
| * |
| * Input: data (ptr to image data) |
| * pixw (width) |
| * pixh (height) |
| * depth (depth) |
| * wpl (wpl) |
| * x (x val of UL corner of rectangle) |
| * w (width of rectangle) |
| * shift (+ shifts data downward in vertical column) |
| * Return: 0 if OK; 1 on error. |
| * |
| * Notes: |
| * (1) This clears the pixels that are left exposed after the |
| * translation. You can consider them as pixels that are |
| * shifted in from outside the image. This can be later |
| * overridden by the incolor parameter in higher-level functions |
| * that call this. For example, for images with depth > 1, |
| * these pixels are cleared to black; to be white they |
| * must later be SET to white. See, e.g., pixRasteropVip(). |
| * (2) This function scales the width to accommodate any depth, |
| * performs clipping, and then does the in-place rasterop. |
| */ |
| void |
| rasteropVipLow(l_uint32 *data, |
| l_int32 pixw, |
| l_int32 pixh, |
| l_int32 depth, |
| l_int32 wpl, |
| l_int32 x, |
| l_int32 w, |
| l_int32 shift) |
| { |
| l_int32 fwpartb; /* boolean (1, 0) if first word is partial */ |
| l_int32 fwpart2b; /* boolean (1, 0) if first word is doubly partial */ |
| l_uint32 fwmask; /* mask for first partial word */ |
| l_int32 fwbits; /* first word bits in ovrhang */ |
| l_uint32 *pdfwpart; /* ptr to first partial dest word */ |
| l_uint32 *psfwpart; /* ptr to first partial src word */ |
| l_int32 fwfullb; /* boolean (1, 0) if there exists a full word */ |
| l_int32 nfullw; /* number of full words */ |
| l_uint32 *pdfwfull; /* ptr to first full dest word */ |
| l_uint32 *psfwfull; /* ptr to first full src word */ |
| l_int32 lwpartb; /* boolean (1, 0) if last word is partial */ |
| l_uint32 lwmask; /* mask for last partial word */ |
| l_int32 lwbits; /* last word bits in ovrhang */ |
| l_uint32 *pdlwpart; /* ptr to last partial dest word */ |
| l_uint32 *pslwpart; /* ptr to last partial src word */ |
| l_int32 dirwpl; /* directed wpl (-wpl * sign(shift)) */ |
| l_int32 absshift; /* absolute value of shift; for use in iterator */ |
| l_int32 vlimit; /* vertical limit value for iterations */ |
| l_int32 i, j; |
| |
| |
| /*--------------------------------------------------------* |
| * Scale horizontal dimensions by depth * |
| *--------------------------------------------------------*/ |
| if (depth != 1) { |
| pixw *= depth; |
| x *= depth; |
| w *= depth; |
| } |
| |
| |
| /*--------------------------------------------------------* |
| * Clip horizontally * |
| *--------------------------------------------------------*/ |
| if (x < 0) { |
| w += x; /* reduce w */ |
| x = 0; /* clip to x = 0 */ |
| } |
| if (x >= pixw || w <= 0) /* no part of vertical slice is in the image */ |
| return; |
| |
| if (x + w > pixw) |
| w = pixw - x; /* clip to x + w = pixw */ |
| |
| /*--------------------------------------------------------* |
| * Preliminary calculations * |
| *--------------------------------------------------------*/ |
| /* is the first word partial? */ |
| if ((x & 31) == 0) { /* if not */ |
| fwpartb = 0; |
| fwbits = 0; |
| } |
| else { /* if so */ |
| fwpartb = 1; |
| fwbits = 32 - (x & 31); |
| fwmask = rmask32[fwbits]; |
| if (shift >= 0) { /* go up from bottom */ |
| pdfwpart = data + wpl * (pixh - 1) + (x >> 5); |
| psfwpart = data + wpl * (pixh - 1 - shift) + (x >> 5); |
| } |
| else { /* go down from top */ |
| pdfwpart = data + (x >> 5); |
| psfwpart = data - wpl * shift + (x >> 5); |
| } |
| } |
| |
| /* is the first word doubly partial? */ |
| if (w >= fwbits) /* if not */ |
| fwpart2b = 0; |
| else { /* if so */ |
| fwpart2b = 1; |
| fwmask &= lmask32[32 - fwbits + w]; |
| } |
| |
| /* is there a full dest word? */ |
| if (fwpart2b == 1) { /* not */ |
| fwfullb = 0; |
| nfullw = 0; |
| } |
| else { |
| nfullw = (w - fwbits) >> 5; |
| if (nfullw == 0) /* if not */ |
| fwfullb = 0; |
| else { /* if so */ |
| fwfullb = 1; |
| if (fwpartb) { |
| pdfwfull = pdfwpart + 1; |
| psfwfull = psfwpart + 1; |
| } |
| else { |
| if (shift >= 0) { /* go up from bottom */ |
| pdfwfull = data + wpl * (pixh - 1) + (x >> 5); |
| psfwfull = data + wpl * (pixh - 1 - shift) + (x >> 5); |
| } |
| else { /* go down from top */ |
| pdfwfull = data + (x >> 5); |
| psfwfull = data - wpl * shift + (x >> 5); |
| } |
| } |
| } |
| } |
| |
| /* is the last word partial? */ |
| lwbits = (x + w) & 31; |
| if (fwpart2b == 1 || lwbits == 0) /* if not */ |
| lwpartb = 0; |
| else { |
| lwpartb = 1; |
| lwmask = lmask32[lwbits]; |
| if (fwpartb) { |
| pdlwpart = pdfwpart + 1 + nfullw; |
| pslwpart = psfwpart + 1 + nfullw; |
| } |
| else { |
| if (shift >= 0) { /* go up from bottom */ |
| pdlwpart = data + wpl * (pixh - 1) + (x >> 5) + nfullw; |
| pslwpart = data + wpl * (pixh - 1 - shift) + (x >> 5) + nfullw; |
| } |
| else { /* go down from top */ |
| pdlwpart = data + (x >> 5) + nfullw; |
| pslwpart = data - wpl * shift + (x >> 5) + nfullw; |
| } |
| } |
| } |
| |
| /* determine the direction of flow from the shift |
| * If the shift >= 0, data flows downard from src |
| * to dest, starting at the bottom and working up. |
| * If shift < 0, data flows upward from src to |
| * dest, starting at the top and working down. */ |
| dirwpl = (shift >= 0) ? -wpl : wpl; |
| absshift = L_ABS(shift); |
| vlimit = L_MAX(0, pixh - absshift); |
| |
| |
| /*--------------------------------------------------------* |
| * Now we're ready to do the ops * |
| *--------------------------------------------------------*/ |
| |
| /* Do the first partial word */ |
| if (fwpartb) { |
| for (i = 0; i < vlimit; i++) { |
| *pdfwpart = COMBINE_PARTIAL(*pdfwpart, *psfwpart, fwmask); |
| pdfwpart += dirwpl; |
| psfwpart += dirwpl; |
| } |
| |
| /* Clear the incoming pixels */ |
| for (i = vlimit; i < pixh; i++) { |
| *pdfwpart = COMBINE_PARTIAL(*pdfwpart, 0x0, fwmask); |
| pdfwpart += dirwpl; |
| } |
| } |
| |
| /* Do the full words */ |
| if (fwfullb) { |
| for (i = 0; i < vlimit; i++) { |
| for (j = 0; j < nfullw; j++) |
| *(pdfwfull + j) = *(psfwfull + j); |
| pdfwfull += dirwpl; |
| psfwfull += dirwpl; |
| } |
| |
| /* Clear the incoming pixels */ |
| for (i = vlimit; i < pixh; i++) { |
| for (j = 0; j < nfullw; j++) |
| *(pdfwfull + j) = 0x0; |
| pdfwfull += dirwpl; |
| } |
| } |
| |
| /* Do the last partial word */ |
| if (lwpartb) { |
| for (i = 0; i < vlimit; i++) { |
| *pdlwpart = COMBINE_PARTIAL(*pdlwpart, *pslwpart, lwmask); |
| pdlwpart += dirwpl; |
| pslwpart += dirwpl; |
| } |
| |
| /* Clear the incoming pixels */ |
| for (i = vlimit; i < pixh; i++) { |
| *pdlwpart = COMBINE_PARTIAL(*pdlwpart, 0x0, lwmask); |
| pdlwpart += dirwpl; |
| } |
| } |
| |
| return; |
| } |
| |
| |
| |
| /*--------------------------------------------------------------------* |
| * Low-level Horizontal In-place Rasterop * |
| *--------------------------------------------------------------------*/ |
| /*! |
| * rasteropHipLow() |
| * |
| * Input: data (ptr to image data) |
| * pixh (height) |
| * depth (depth) |
| * wpl (wpl) |
| * y (y val of UL corner of rectangle) |
| * h (height of rectangle) |
| * shift (+ shifts data downward in vertical column) |
| * Return: 0 if OK; 1 on error. |
| * |
| * Notes: |
| * (1) This clears the pixels that are left exposed after the rasterop. |
| * Therefore, for Pix with depth > 1, these pixels become black, |
| * and must be subsequently SET if they are to be white. |
| * For example, see pixRasteropHip(). |
| * (2) This function performs clipping and calls shiftDataHorizontalLine() |
| * to do the in-place rasterop on each line. |
| */ |
| void |
| rasteropHipLow(l_uint32 *data, |
| l_int32 pixh, |
| l_int32 depth, |
| l_int32 wpl, |
| l_int32 y, |
| l_int32 h, |
| l_int32 shift) |
| { |
| l_int32 i; |
| l_uint32 *line; |
| |
| /* clip band if necessary */ |
| if (y < 0) { |
| h += y; /* reduce h */ |
| y = 0; /* clip to y = 0 */ |
| } |
| if (h <= 0 || y > pixh) /* no part of horizontal slice is in the image */ |
| return; |
| |
| if (y + h > pixh) |
| h = pixh - y; /* clip to y + h = pixh */ |
| |
| for (i = y; i < y + h; i++) { |
| line = data + i * wpl; |
| shiftDataHorizontalLow(line, wpl, line, wpl, shift * depth); |
| } |
| } |
| |
| |
| /*! |
| * shiftDataHorizontalLow() |
| * |
| * Input: datad (ptr to beginning of dest line) |
| * wpld (wpl of dest) |
| * datas (ptr to beginning of src line) |
| * wpls (wpl of src) |
| * shift (horizontal shift of block; >0 is to right) |
| * Return: void |
| * |
| * Notes: |
| * (1) This can also be used for in-place operation; see, e.g., |
| * rasteropHipLow(). |
| * (2) We are clearing the pixels that are shifted in from |
| * outside the image. This can be overridden by the |
| * incolor parameter in higher-level functions that call this. |
| */ |
| void |
| shiftDataHorizontalLow(l_uint32 *datad, |
| l_int32 wpld, |
| l_uint32 *datas, |
| l_int32 wpls, |
| l_int32 shift) |
| { |
| l_int32 j, firstdw, wpl, rshift, lshift; |
| l_uint32 *lined, *lines; |
| |
| lined = datad; |
| lines = datas; |
| |
| if (shift >= 0) { /* src shift to right; data flows to |
| * right, starting at right edge and |
| * progressing leftward. */ |
| firstdw = shift / 32; |
| wpl = L_MIN(wpls, wpld - firstdw); |
| lined += firstdw + wpl - 1; |
| lines += wpl - 1; |
| rshift = shift & 31; |
| if (rshift == 0) { |
| for (j = 0; j < wpl; j++) |
| *lined-- = *lines--; |
| |
| /* clear out the rest to the left edge */ |
| for (j = 0; j < firstdw; j++) |
| *lined-- = 0; |
| } |
| else { |
| lshift = 32 - rshift; |
| for (j = 1; j < wpl; j++) { |
| *lined-- = *(lines - 1) << lshift | *lines >> rshift; |
| lines--; |
| } |
| *lined = *lines >> rshift; /* partial first */ |
| |
| /* clear out the rest to the left edge */ |
| *lined &= ~lmask32[rshift]; |
| lined--; |
| for (j = 0; j < firstdw; j++) |
| *lined-- = 0; |
| } |
| } |
| else { /* src shift to left; data flows to left, starting |
| * at left edge and progressing rightward. */ |
| firstdw = (-shift) / 32; |
| wpl = L_MIN(wpls - firstdw, wpld); |
| lines += firstdw; |
| lshift = (-shift) & 31; |
| if (lshift == 0) { |
| for (j = 0; j < wpl; j++) |
| *lined++ = *lines++; |
| |
| /* clear out the rest to the right edge */ |
| for (j = 0; j < firstdw; j++) |
| *lined++ = 0; |
| } |
| else { |
| rshift = 32 - lshift; |
| for (j = 1; j < wpl; j++) { |
| *lined++ = *lines << lshift | *(lines + 1) >> rshift; |
| lines++; |
| } |
| *lined = *lines << lshift; /* partial last */ |
| |
| /* clear out the rest to the right edge */ |
| /* first clear the lshift pixels of this partial word */ |
| *lined &= ~rmask32[lshift]; |
| lined++; |
| /* then the remaining words to the right edge */ |
| for (j = 0; j < firstdw; j++) |
| *lined++ = 0; |
| } |
| } |
| |
| return; |
| } |
| |
