Apple-2-Tools/ciderpress
1
0
Fork 0
mirror of https://github.com/fadden/ciderpress.git synced 2024-11-26 02:49:20 +00:00
Code Issues Projects Releases Wiki Activity
e4cf9d8ba5
ciderpress/reformat/DoubleHiRes.cpp

535 lines
20 KiB
C++
Raw Normal View History

initial import
2007-03-27 17:47:10 +00:00
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Multiple conversions for double-hi-res graphics.
*/
#include "StdAfx.h"
#include "DoubleHiRes.h"
#include "HiRes.h"
/*
* The screen layout is described in detail in Apple //e technote #3.
*
* Summary: pixel data is byte-interleaved between main and auxilliary
* 8K pages. Seven pixels of each byte contribute to the image; the high
* bit of each byte is ignored. There are 16 possible colors, which match
* up with the 16 lo-res colors.
*
* The interference patterns caused by adjacent colors are extremely
* difficult to model accurately, especially considering that RGB and
* composite outputs seem to be different.
*/
/*
* Decide whether or not we want to handle this file.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDHR::Examine(ReformatHolder* pHolder)
initial import
2007-03-27 17:47:10 +00:00
{
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
ReformatHolder::ReformatApplies applies = ReformatHolder::kApplicNot;
long fileLen = pHolder->GetSourceLen(ReformatHolder::kPartData);
long fileType = pHolder->GetFileType();
long auxType = pHolder->GetAuxType();
long dhrAlg;
bool relaxed;
relaxed = pHolder->GetOption(ReformatHolder::kOptRelaxGfxTypeCheck) != 0;
if ((fileType == kTypeFOT && auxType < 0x4000 && fileLen == 16384) ||
(relaxed &&
(
(fileType == kTypeBIN && fileLen == 16376) ||
(fileType == kTypeBIN && fileLen == 16380) ||
(fileType == kTypeBIN && fileLen == 16384)
)
))
{
applies = ReformatHolder::kApplicProbably;
}
pHolder->SetApplic(ReformatHolder::kReformatDHR_Latched, applies,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
pHolder->SetApplic(ReformatHolder::kReformatDHR_BW, applies,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
pHolder->SetApplic(ReformatHolder::kReformatDHR_Plain140, applies,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
pHolder->SetApplic(ReformatHolder::kReformatDHR_Window, applies,
ReformatHolder::kApplicNot, ReformatHolder::kApplicNot);
/*
* Set the "preferred" flag on one option.
*/
dhrAlg = pHolder->GetOption(ReformatHolder::kOptDHRAlgorithm);
switch ((Algorithms) dhrAlg) {
case kDHRLatched:
pHolder->SetApplicPreferred(ReformatHolder::kReformatDHR_Latched);
break;
case kDHRBlackWhite:
pHolder->SetApplicPreferred(ReformatHolder::kReformatDHR_BW);
break;
case kDHRPlain140:
pHolder->SetApplicPreferred(ReformatHolder::kReformatDHR_Plain140);
break;
case kDHRWindow:
pHolder->SetApplicPreferred(ReformatHolder::kReformatDHR_Window);
break;
default:
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("GLITCH: DHR algorithm %d not recognized", dhrAlg);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
break;
}
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Convert a Double-Hi-Res image to a bitmap.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
int ReformatDHR::Process(const ReformatHolder* pHolder,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
ReformatHolder::ReformatID id, ReformatHolder::ReformatPart part,
ReformatOutput* pOutput)
initial import
2007-03-27 17:47:10 +00:00
{
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
MyDIBitmap* pDib;
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* srcBuf = pHolder->GetSourceBuf(part);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
long srcLen = pHolder->GetSourceLen(part);
int retval = -1;
switch (id) {
case ReformatHolder::kReformatDHR_Latched:
fAlgorithm = kDHRLatched;
break;
case ReformatHolder::kReformatDHR_BW:
fAlgorithm = kDHRBlackWhite;
break;
case ReformatHolder::kReformatDHR_Plain140:
fAlgorithm = kDHRPlain140;
break;
case ReformatHolder::kReformatDHR_Window:
fAlgorithm = kDHRWindow;
break;
default:
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("GLITCH: bad id %d", id);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
fAlgorithm = kDHRLatched;
break;
}
if (srcLen > kExpectedSize || srcLen < kExpectedSize-8) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" DHR file is not ~%d bytes long (got %d)",
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
kExpectedSize, srcLen);
goto bail;
}
/* line layout is same as standard hires */
ReformatHiRes::InitLineOffset(fLineOffset);
InitColorLookup();
pDib = DHRScreenToBitmap(srcBuf);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (pDib == NULL)
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
goto bail;
SetResultBuffer(pOutput, pDib);
retval = 0;
initial import
2007-03-27 17:47:10 +00:00
bail:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return retval;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Initialize the 4-bit-window color lookup table.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
void ReformatDHR::InitColorLookup(void)
initial import
2007-03-27 17:47:10 +00:00
{
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
for (int ii = 0; ii < 4; ii++) {
for (int jj = 0; jj < kNumDHRColors; jj++) {
int num = jj;
for (int kk = 0; kk < ii; kk++) {
if (num & 0x01)
num |= 0x10;
num >>= 1;
num &= 0x0f;
}
fColorLookup[ii][jj] = num;
}
}
return;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Convert a buffer of double-hires data to a 16-color DIB.
*/
More source code shuffling Moved comments and return types, switched to uint types, added "override" keyword.
2014-11-25 22:34:14 +00:00
MyDIBitmap* ReformatDHR::DHRScreenToBitmap(const uint8_t* buf)
initial import
2007-03-27 17:47:10 +00:00
{
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
MyDIBitmap* pDib = new MyDIBitmap;
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint8_t* outBuf;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
const int kMaxLook = 4; // padding to adjust for lookbehind/lookahead
int pixelBits[kMaxLook+kPixelsPerLine+kMaxLook]; // 560 mono pixels
unsigned int colorBuf[kOutputWidth]; // 560 color pixels
int line;
/* color map */
enum {
kColorBlack = 0, // 0000
kColorRed, // 0001
kColorBrown, // 0010
kColorOrange, // 0011 hcolor=5
kColorDarkGreen, // 0100
kColorGrey1, // 0101
kColorGreen, // 0110 hcolor=1
kColorYellow, // 0111
kColorDarkBlue, // 1000
kColorPurple, // 1001 hcolor=2
kColorGrey2, // 1010
kColorPink, // 1011
kColorMediumBlue, // 1100 hcolor=6
kColorLightBlue, // 1101
kColorAqua, // 1110
kColorWhite, // 1110
kNumColors
};
RGBQUAD colorConv[kNumColors];
colorConv[0] = fPalette[kPaletteBlack];
colorConv[1] = fPalette[kPaletteRed];
colorConv[2] = fPalette[kPaletteBrown];
colorConv[3] = fPalette[kPaletteOrange];
colorConv[4] = fPalette[kPaletteDarkGreen];
colorConv[5] = fPalette[kPaletteDarkGrey];
colorConv[6] = fPalette[kPaletteGreen];
colorConv[7] = fPalette[kPaletteYellow];
colorConv[8] = fPalette[kPaletteDarkBlue];
colorConv[9] = fPalette[kPalettePurple];
colorConv[10] = fPalette[kPaletteLightGrey];
colorConv[11] = fPalette[kPalettePink];
colorConv[12] = fPalette[kPaletteMediumBlue];
colorConv[13] = fPalette[kPaletteLightBlue];
colorConv[14] = fPalette[kPaletteAqua];
colorConv[15] = fPalette[kPaletteWhite];
ASSERT(kNumColors == kPaletteSize);
ASSERT(kNumDHRColors == kNumColors);
ASSERT(kOutputWidth == kPixelsPerLine);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (pDib == NULL)
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
goto bail;
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
outBuf = (uint8_t*) pDib->Create(kOutputWidth, kOutputHeight,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
4, kNumColors);
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (outBuf == NULL) {
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
delete pDib;
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
pDib = NULL;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
goto bail;
}
pDib->SetColorTable(colorConv);
/*
* Run through the lines.
*
* This is reasonably inefficient, since I'm splitting things into
* their constituent bits and then, for the most part, just stuffing
* them right back together. Someday, if fatally bored, this should
* be optimized.
*/
for (line = 0; line < kNumLines; line++) {
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
const uint8_t* lineData = buf + fLineOffset[line];
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
int* bitPtr = pixelBits + kMaxLook;
/* this is really just to clear the fore and aft MaxLook bits */
memset(pixelBits, 0, sizeof(pixelBits));
/* unravel the bits */
for (int byt = 0; byt < kPixelsPerLine / 7; byt++) {
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint8_t val;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
if (byt & 0x01) {
/* odd pixels come from main memory */
val = *(lineData+kPageSize);
lineData++;
} else {
/* even pixels come from aux mem */
val = *lineData;
}
for (int bit = 0; bit < 7; bit++) {
*bitPtr++ = val & 0x01;
val >>= 1;
}
}
ASSERT(lineData <= buf + kPageSize);
ASSERT((char*)bitPtr == (char*)pixelBits +
sizeof(pixelBits) - kMaxLook*sizeof(pixelBits[0]));
/*
* Convert the bits to colors.
*/
int idx;
if (fAlgorithm == kDHRBlackWhite) {
for (idx = 0; idx < kPixelsPerLine; idx ++) {
int bufTarget = idx;
if (!pixelBits[idx]) {
colorBuf[bufTarget] = kColorBlack;
} else {
colorBuf[bufTarget] = kColorWhite;
}
}
} else if (fAlgorithm == kDHRPlain140) {
/*
* Very simple: every four pixels is a solid color. Not too
* close to reality, but easy to implement.
*/
int pixVal = 0;
bitPtr = pixelBits + kMaxLook;
for (idx = 0; idx < kPixelsPerLine/4; idx++) {
pixVal = *bitPtr++;
pixVal = (pixVal << 1) | (*bitPtr++);
pixVal = (pixVal << 1) | (*bitPtr++);
pixVal = (pixVal << 1) | (*bitPtr++);
colorBuf[idx*4] = pixVal;
colorBuf[idx*4+1] = pixVal;
colorBuf[idx*4+2] = pixVal;
colorBuf[idx*4+3] = pixVal;
}
ASSERT(bitPtr == pixelBits + sizeof(pixelBits)/sizeof(pixelBits[0]) - kMaxLook);
} else if (fAlgorithm == kDHRWindow) {
/*
* The way we determine the value of the color at pixel N
* is by looking at the pixels at N-3, N-2, N-1, and N.
*
* We manage this with a continously shifting 4-bit-wide
* window.
*
* Note to self: interesting case at line 87, pixels 200-240,
* in "screen2".
*/
int pixVal = 0;
bitPtr = pixelBits + kMaxLook;
for (idx = 0; idx < kPixelsPerLine; idx++) {
pixVal = (pixVal << 1) & 0x0f;
if (*bitPtr++)
pixVal |= 1;
colorBuf[idx] = fColorLookup[(idx+1) & 0x03][pixVal];
}
ASSERT(bitPtr <= pixelBits + sizeof(pixelBits)/sizeof(pixelBits[0]));
initial import
2007-03-27 17:47:10 +00:00
#if 0
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
/*
* Zero-stop pass, where we set the luminosity to zero if we
* see four zeros in a row.
*/
bitPtr = pixelBits + kMaxLook;
for (idx = 0; idx < kPixelsPerLine; idx++) {
if (!bitPtr[idx] && !bitPtr[idx+1] &&
!bitPtr[idx+2] && !bitPtr[idx+3])
{
//if (line == 87 && idx > 200 && idx < 240) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
// LOGI(" %4d ERASE", idx);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
//}
/*colorBuf[idx] =*/ colorBuf[idx+1] =
colorBuf[idx+2] = /*colorBuf[idx+3] =*/ kColorBlack;
}
}
initial import
2007-03-27 17:47:10 +00:00
#endif
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
} else if (fAlgorithm == kDHRLatched) {
/*
* We determine the value of the color at pixel N is by looking
* at the pixels at N-3, N-2, N-1, and N. When we see a color
* transition, we also look at (N+1..N+4) to special-case
* white/black transitions. This is necessary to reduce the
* color fringes around sharply defined objects.
*
* Once a color is "latched", we keep outputting that color
* until we find a new one that we like more.
*
* We manage this with a continously shifting 8-bit-wide window.
*
* Note to self: interesting case at line=98, pixels 50-80.
*/
unsigned int whole;
int newColor, oldColor;
bitPtr = pixelBits;
whole = 0;
for (idx = 0; idx < 8; idx++) {
whole <<= 1;
if (*bitPtr++)
whole |= 1;
}
ASSERT((whole & (~0xff)) == 0);
/* grab the color of the "previous" 4 pixels */
oldColor = fColorLookup[idx & 0x03][whole & 0x0f];
for (idx = 0; idx < kPixelsPerLine; idx++, bitPtr++) {
//if (line == 98 && idx > 50 && idx < 80) {
// if (!(idx % 4)) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
// LOGI(" idx %3d: bits=0x%02x PPPPCNNN",
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
// idx, whole & 0xff);
// }
//}
/* shift another bit in, to give us 3 prev and 4 next */
/* looks like PPPCNNNN */
ASSERT(*bitPtr == 0 || *bitPtr == 1);
whole = (whole << 1) | *bitPtr;
whole &= 0xff; // not needed; useful for printfs
/* get the new color (from PPPC bits) */
newColor = fColorLookup[(idx+1) & 0x03][(whole & 0xf0) >> 4];
//if (line == 98 && idx > 50 && idx < 80) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
// LOGI(" idx %3d: old=%-2d new=%-2d (bits=0x%02x)", idx,
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
// oldColor, newColor, whole & 0xff);
//}
if (newColor != oldColor) {
/*
* Transition to new color; check for white/black blocks
* in *next* chunk of pixels. The goal is to eliminate
* color fringes on white/black boundaries, which are the
* most easily visible.
*/
int shift1, shift2, shift3;
shift1 = (whole >> 3) & 0x0f; // PPCN
shift2 = (whole >> 2) & 0x0f; // PCNN
shift3 = (whole >> 1) & 0x0f; // CNNN
if (shift1 == 0x0f || shift2 == 0x0f || shift3 == 0x0f)
newColor = kColorWhite;
else if (shift1 == 0 || shift2 == 0 || shift3 == 0)
newColor = kColorBlack;
//if (line == 98 && idx > 50 && idx < 80) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
// LOGI(" idx %3d: S new=%-2d", idx, newColor);
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
//}
}
//if (line == 98 && idx > 50 && idx < 80) {
//newColor = kColorYellow;
//}
colorBuf[idx] = newColor;
/*
* Use the new color as the old color for the next iteration.
* This is *NOT* the same as getting the color from PPPP
* before shifting next round, because we might have
* overridden white or black above. In that case, the new
* color would be compared against white or black in the
* transition check, instead of comparing against the actual
* color of the PPPP pixels.
*/
oldColor = newColor; // latch it
//oldColor = fColorLookup[idx & 0x03][whole & 0x0f];
}
ASSERT(bitPtr <= pixelBits + sizeof(pixelBits)/sizeof(pixelBits[0]));
} else {
ASSERT(false);
initial import
2007-03-27 17:47:10 +00:00
#if defined(DHR_MULTIPASS)
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
unsigned int colorBuf1[kMaxLook+kOutputWidth+kMaxLook];
int pixVal = 0;
bitPtr = pixelBits + kMaxLook;
/*
* Start simple.
*/
memset(colorBuf1, 0, sizeof(colorBuf1));
for (idx = 0; idx < kPixelsPerLine/4; idx++) {
pixVal = *bitPtr++;
pixVal = (pixVal << 1) | (int)(*bitPtr++);
pixVal = (pixVal << 1) | (int)(*bitPtr++);
pixVal = (pixVal << 1) | (int)(*bitPtr++);
colorBuf1[idx*4 +kMaxLook] = pixVal;
colorBuf1[idx*4+1 +kMaxLook] = pixVal;
colorBuf1[idx*4+2 +kMaxLook] = pixVal;
colorBuf1[idx*4+3 +kMaxLook] = pixVal;
}
ASSERT(bitPtr <= pixelBits + sizeof(pixelBits)/sizeof(pixelBits[0]));
/*
* Now go back and patch all of the transitions between colors.
* The most significant are transitions to and from black,
* which have to truncate bits.
*/
for (idx = 3; idx < kMaxLook+kPixelsPerLine; idx += 4) {
if (colorBuf1[idx] != colorBuf1[idx+1]) {
/* color change */
if (colorBuf1[idx] == 0) {
/* trim pixels on left */
pixVal = colorBuf1[idx+1];
ASSERT(pixVal != 0);
unsigned int* iptr = &colorBuf1[idx+1];
while (!(pixVal & 0x08)) {
*iptr++ = kColorBlack;
pixVal <<= 1;
}
} else if (colorBuf1[idx+1] == 0) {
/* trim pixels on right */
pixVal = colorBuf1[idx];
ASSERT(pixVal != 0);
unsigned int* iptr = &colorBuf1[idx];
while (!(pixVal & 0x01)) {
*iptr-- = kColorBlack;
pixVal >>= 1;
}
} else {
/*
* The center four pixels have a color determined
* like this:
*
* orange = 0011
* pink = 1011
*
* Take last two of orange and first two of pink,
* and swap them so first two of pink come first,
* e.g. 1011. The color, which also happens to be
* pink, is what we set the middle four pixels to.
*
* Can't explain it, but that's how it works...
* usually.
*/
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint8_t mergePix;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
mergePix = colorBuf1[idx] & 0x03;
mergePix |= colorBuf1[idx+1] & 0x0c;
ASSERT((mergePix & 0xf0) == 0);
if (line == 191) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("idx=0x%02x idx+1=0x%02x merge=0x%02x",
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
colorBuf1[idx], colorBuf1[idx+1], mergePix);
}
colorBuf1[idx-1] = colorBuf1[idx] = colorBuf1[idx+1] =
colorBuf1[idx+2] = mergePix;
}
}
}
memcpy(colorBuf, colorBuf1+kMaxLook, sizeof(colorBuf));
initial import
2007-03-27 17:47:10 +00:00
#endif
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
} /* color algorithm choices */
initial import
2007-03-27 17:47:10 +00:00
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
/* convert colors to 4-bit bitmap pixels, with line-doubling */
initial import
2007-03-27 17:47:10 +00:00
#define SetPix(x, y, twoval) \
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
outBuf[((kOutputHeight-1) - (y)) * (kOutputWidth/2) + (x)] = twoval
Use types with explicit sizes Much of what the "reformat" code does involves processing data that is 8, 16, or 32 bits. We want to use size-specific types from stdint.h (e.g. uint16_t) rather than "unsigned short". This was a quick pass to replace the various "unsigned" declarations. More can be done here and elsewhere.
2014-11-21 02:10:18 +00:00
uint8_t pix4;
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
for (int pix = 0; pix < kPixelsPerLine/2; pix++) {
int bufPosn = pix * 2;
ASSERT(colorBuf[bufPosn] < kNumColors);
ASSERT(colorBuf[bufPosn+1] < kNumColors);
pix4 = colorBuf[bufPosn] << 4 | colorBuf[bufPosn+1];
SetPix(pix, line*2, pix4);
SetPix(pix, line*2+1, pix4);
}
} /*for each line*/
initial import
2007-03-27 17:47:10 +00:00
#undef SetPix
bail:
Normalize indentation and EOL This updates all source files to use spaces instead of tabs for indentation. It also normalizes the end-of-line markers to be Windows-style CRLF, and ensures that all files end with EOL. No substantive changes were made; "diff -w" is empty.
2014-11-04 00:26:53 +00:00
return pDib;
initial import
2007-03-27 17:47:10 +00:00
}
Reference in New Issue Copy Permalink