Diff of /cpyBuf.cpp [000000] .. [68cdf8]  Maximize  Restore

Switch to side-by-side view

--- a
+++ b/cpyBuf.cpp
@@ -0,0 +1,198 @@
+
+// PTLens, Copyright (C) 2004, Thomas Niemann
+// email: thomasn@epaperpress.com, subject=ptlens
+// 
+// This program is free software; you can redistribute 
+// it and/or modify it under the terms of the GNU
+// General Public License as published by the Free 
+// Software Foundation; either version 2 of the 
+// License, or (at your option) any later version. 
+//
+// This program is distributed in the hope that it will 
+// be useful, but WITHOUT ANY WARRANTY; without even 
+// the implied warranty of MERCHANTABILITY or FITNESS 
+// FOR A PARTICULAR PURPOSE. See the GNU General Public 
+// License for more details. 
+// 
+// You should have received a copy of the GNU General 
+// Public License along with this program; if not, 
+// write to the Free Software Foundation, Inc., 675 
+// Mass Ave, Cambridge, MA 02139, USA.
+
+#include "main.h"
+
+int cpyBufToPs(void *buf) {
+
+	// some local variables for efficiency
+	int16 tileHeight = gFr->filterRect.bottom - gFr->filterRect.top;
+	int16 tileWidth = gFr->filterRect.right - gFr->filterRect.left;
+	Rect *outRect = &gFr->outRect;
+	Rect *filterRect = &gFr->filterRect;
+	int16 imageWidth = PHO.imageWidth;
+	int16 imageHeight = PHO.imageHeight;
+	int32 imageDepth = PHO.imageDepth;
+	int32 bytesPerPixel = (imageDepth/8) * 3;
+
+	// round up to the nearest horizontal and vertical tile count
+	uint16 tilesVert = (uint16)((tileHeight - 1 + imageHeight) / tileHeight);
+	uint16 tilesHoriz = (uint16)((tileWidth - 1 + imageWidth) / tileWidth);
+
+	// Fixed numbers are 16.16 values 
+	// the first 16 bits represent the whole number
+	// the last 16 bits represent the fraction
+	gFr->inputRate = (int32)1 << 16;
+	gFr->maskRate = (int32)1 << 16;
+ 
+	// loop through each tile makeing sure we don't go over the bounds
+	// of the imageHeight or imageWidth
+	for (uint16 vertTile = 0; vertTile < tilesVert; vertTile++)	{
+		for (uint16 horizTile = 0; horizTile < tilesHoriz; horizTile++) {
+			outRect->top = (int16)(vertTile * tileHeight);
+			outRect->left = (int16)(horizTile * tileWidth);
+			outRect->bottom = (int16)(outRect->top + tileHeight);
+			outRect->right = (int16)(outRect->left + tileWidth);
+
+			if (outRect->bottom > imageHeight)
+				outRect->bottom = imageHeight;
+			if (outRect->right > imageWidth)
+				outRect->right = imageWidth;
+
+			for (uint16 plane = 0; plane < 3; plane++) {
+				// we want one plane at a time, small memory foot print is good
+				gFr->outLoPlane = plane;
+				gFr->outHiPlane = plane;
+	
+				// update the gFr with our latest request
+				*gResult = gFr->advanceState();
+				if (*gResult != noErr) 
+					return display("cpyBufToPs: advanceState");
+				
+				// copy one channel at a time
+				if (imageDepth == 8) {
+					uint8* pixel = (uint8*)gFr->outData;
+					uint16 rectHeight = (uint16)(outRect->bottom - outRect->top);
+					uint16 rectWidth = (uint16)(outRect->right - outRect->left);
+
+					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
+						Ptr dissolve = (char *)buf + bytesPerPixel * 
+							(imageWidth * (outRect->top + pixelY) + outRect->left) + plane;
+						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
+							*pixel++ = *dissolve;
+							dissolve += bytesPerPixel;
+						}
+						pixel += gFr->outRowBytes - rectWidth;
+					}
+				} else {
+					// assume 16-bit
+					uint16* pixel = (uint16*)gFr->outData;
+					uint16 rectHeight = (uint16)(outRect->bottom - outRect->top);
+					uint16 rectWidth = (uint16)(outRect->right - outRect->left);
+					int bytesPerPixel2 = bytesPerPixel >> 1;
+
+					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
+						uint16 *dissolve = (uint16 *)((char *)buf + bytesPerPixel * 
+							(imageWidth * (outRect->top + pixelY) + outRect->left)
+							+ 2*plane);
+						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
+							// convert 0..65535 to 0..32768
+							*pixel++ = (*dissolve + 1U) >> 1;
+							dissolve += bytesPerPixel2;
+						}
+						pixel += (gFr->outRowBytes - 2*rectWidth) >> 1;
+					}							
+				}
+			}
+
+		}
+	}
+
+	return 0;
+}
+
+int cpyPsToBuf(void *buf) {
+	// some local variables for efficiency
+	int16 tileHeight = gFr->filterRect.bottom - gFr->filterRect.top;
+	int16 tileWidth = gFr->filterRect.right - gFr->filterRect.left;
+	Rect *inRect = &gFr->inRect;
+	Rect *filterRect = &gFr->filterRect;
+	int16 imageWidth = PHO.imageWidth;
+	int16 imageHeight = PHO.imageHeight;
+	int32 imageDepth = PHO.imageDepth;
+	int32 bytesPerPixel = (imageDepth/8) * 3;
+
+	// round up to the nearest horizontal and vertical tile count
+	uint16 tilesVert = (uint16)((tileHeight - 1 + imageHeight) / tileHeight);
+	uint16 tilesHoriz = (uint16)((tileWidth - 1 + imageWidth) / tileWidth);
+
+	// Fixed numbers are 16.16 values 
+	// the first 16 bits represent the whole number
+	// the last 16 bits represent the fraction
+	gFr->inputRate = (int32)1 << 16;
+	gFr->maskRate = (int32)1 << 16;
+ 
+	// loop through each tile makeing sure we don't go over the bounds
+	// of the imageHeight or imageWidth
+	for (uint16 vertTile = 0; vertTile < tilesVert; vertTile++)	{
+		for (uint16 horizTile = 0; horizTile < tilesHoriz; horizTile++)	{
+			inRect->top = (int16)(vertTile * tileHeight);
+			inRect->left = (int16)(horizTile * tileWidth);
+			inRect->bottom = (int16)(inRect->top + tileHeight);
+			inRect->right = (int16)(inRect->left + tileWidth);
+
+			if (inRect->bottom > imageHeight)
+				inRect->bottom = imageHeight;
+			if (inRect->right > imageWidth)
+				inRect->right = imageWidth;
+
+			for (uint16 plane = 0; plane < 3; plane++) {
+				// we want one plane at a time, small memory foot print is good
+				gFr->inLoPlane = plane;
+				gFr->inHiPlane = plane;
+	
+				// update the gFr with our latest request
+				*gResult = gFr->advanceState();
+				if (*gResult != noErr) 
+					return display("cpyPsToBuf: advanceState");
+
+				// copy one channel at a time
+				if (imageDepth == 8) {
+					uint8* pixel = (uint8*)gFr->inData;
+					uint16 rectHeight = (uint16)(inRect->bottom - inRect->top);
+					uint16 rectWidth = (uint16)(inRect->right - inRect->left);
+
+					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
+						Ptr dissolve = (char *)buf + bytesPerPixel * 
+							(imageWidth * (inRect->top + pixelY) + inRect->left) + plane;
+						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
+							*dissolve = *pixel++;
+							dissolve += bytesPerPixel;
+						}
+						pixel += gFr->inRowBytes - rectWidth;
+					}
+				} else {
+					// assume 16-bit
+					uint16* pixel = (uint16*)gFr->inData;
+					uint16 rectHeight = (uint16)(inRect->bottom - inRect->top);
+					uint16 rectWidth = (uint16)(inRect->right - inRect->left);
+					int bytesPerPixel2 = bytesPerPixel >> 1;
+
+					for(uint16 pixelY = 0; pixelY < rectHeight; pixelY++) {
+						uint16 *dissolve = (uint16 *)((char *)buf + 
+							bytesPerPixel * 
+							(imageWidth * (inRect->top + pixelY) + inRect->left)
+							+ 2*plane);
+						for(uint16 pixelX = 0; pixelX < rectWidth; pixelX++) {
+							// convert 0..32768 to 0..65535
+							*dissolve = (*pixel++ * 65535U + 16384U) >> 15;
+							dissolve += bytesPerPixel2;
+						}
+						pixel += (gFr->inRowBytes - 2*rectWidth) >> 1;
+					}				
+				}
+			}
+
+		}
+	}
+
+	return 0;
+}