i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Style cleanup.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@37370 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Wim van der Meer
2010-07-03 10:23:04 +00:00
parent 4225e5b785
commit 568716bed7
14 changed files with 1179 additions and 888 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/print/drivers/pcl6/DeltaRowCompression.cpp
+45 -27
View File
@@ -1,45 +1,57 @@
/*
** DeltaRowCompression.cpp
** Copyright 2005, Michael Pfeiffer, [email protected]. All rights reserved.
** Copyright 2005, Michael Pfeiffer, [email protected].
** All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/
#include "DeltaRowCompression.h"
#include <SupportDefs.h>
#include "DeltaRowCompression.h"
#include <memory.h>
AbstractDeltaRowCompressor::AbstractDeltaRowCompressor(int rowSize, uchar initialSeed)
: fSeedRow(new uchar[rowSize])
, fSize(rowSize)
, fInitialSeed(initialSeed)
#include <SupportDefs.h>
AbstractDeltaRowCompressor::AbstractDeltaRowCompressor(int rowSize,
uchar initialSeed)
:
fSeedRow(new uchar[rowSize]),
fSize(rowSize),
fInitialSeed(initialSeed)
{
Reset();
}
AbstractDeltaRowCompressor::~AbstractDeltaRowCompressor()
{
delete fSeedRow;
fSeedRow = NULL;
}
status_t AbstractDeltaRowCompressor::InitCheck()
status_t
AbstractDeltaRowCompressor::InitCheck()
{
if (fSeedRow != NULL) {
if (fSeedRow != NULL)
return B_OK;
} else {
else
return B_NO_MEMORY;
}
}
void AbstractDeltaRowCompressor::Reset()
void
AbstractDeltaRowCompressor::Reset()
{
if (fSeedRow != NULL) {
if (fSeedRow != NULL)
memset(fSeedRow, fInitialSeed, fSize);
}
}
int AbstractDeltaRowCompressor::CompressRaw(const uchar* row, bool updateSeedRow, bool updateDeltaRow)
int
AbstractDeltaRowCompressor::CompressRaw(const uchar* row, bool updateSeedRow,
bool updateDeltaRow)
{
int index = DiffersIndex(row, 0);
if (index == -1) {
@@ -56,24 +68,21 @@ int AbstractDeltaRowCompressor::CompressRaw(const uchar* row, bool updateSeedRow
// delta starts at index and contains length bytes
do {
// control byte limits data bytes to 8 bytes
int deltaBytes = length;
if (length > 8) {
if (length > 8)
deltaBytes = 8;
}
// calculate offset
int totalOffset = index - seedRowIndex;
bool needsOffsetBytes = totalOffset > 30;
int offset = totalOffset;
// control byte limits offset value to 31
if (needsOffsetBytes) {
if (needsOffsetBytes)
offset = 31;
}
// write control byte (delta bytes bits 5-7; offset bits 0-4)
Put(((deltaBytes-1) << 5) | offset);
Put(((deltaBytes - 1) << 5) | offset);
if (needsOffsetBytes) {
// write additional offset bytes after control byte
@@ -112,18 +121,25 @@ int AbstractDeltaRowCompressor::CompressRaw(const uchar* row, bool updateSeedRow
return fDeltaRowIndex;
}
int AbstractDeltaRowCompressor::CalculateSize(const uchar* row, bool updateSeedRow)
int
AbstractDeltaRowCompressor::CalculateSize(const uchar* row, bool updateSeedRow)
{
return CompressRaw(row, updateSeedRow, false);
}
void AbstractDeltaRowCompressor::Compress(const uchar* row)
void
AbstractDeltaRowCompressor::Compress(const uchar* row)
{
CompressRaw(row, true, true);
}
#ifdef TEST_DELTA_ROW_COMPRESSION
void test(AbstractDeltaRowCompressor* compressor, uchar* row) {
void
test(AbstractDeltaRowCompressor* compressor, uchar* row) {
int size = compressor->CalculateSize(row);
printf("size %d\n", size);
@@ -139,7 +155,9 @@ void test(AbstractDeltaRowCompressor* compressor, uchar* row) {
printf("\n");
}
int main(int argc, char *argv[])
int
main(int argc, char* argv[])
{
int n = 5;
uchar row1[] = {0, 0, 0, 0, 0};
@@ -152,4 +170,4 @@ int main(int argc, char *argv[])
test(&compressor, row3);
}
#endif
#endif // TEST_DELTA_ROW_COMPRESSION
src/add-ons/print/drivers/pcl6/DeltaRowCompression.h
+66 -61
View File
@@ -1,118 +1,123 @@
/*
** DeltaRowCompression.h
** Copyright 2005, Michael Pfeiffer, [email protected]. All rights reserved.
** Copyright 2005, Michael Pfeiffer, [email protected].
** All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/
#ifndef _DELTA_ROW_COMPRESSION_H
#define _DELTA_ROW_COMPRESSION_H
#include <Debug.h>
class AbstractDeltaRowCompressor {
public:
AbstractDeltaRowCompressor(int rowSize, uchar initialSeed);
virtual ~AbstractDeltaRowCompressor();
AbstractDeltaRowCompressor(int rowSize,
uchar initialSeed);
virtual ~AbstractDeltaRowCompressor();
// InitCheck returns B_OK on successful construction of this object or
// B_NO_MEMORY if the buffer for the seed row could not be allocated.
status_t InitCheck();
status_t InitCheck();
// Clears the seed row to the initial seed specified in the constructor
void Reset();
void Reset();
// Returns the size of the delta row.
// The size is 0 if the row is equal to the seed row (previous row).
// The seed row is updated only if updateSeedRow is true.
int CalculateSize(const uchar* row, bool updateSeedRow = false);
int CalculateSize(const uchar* row,
bool updateSeedRow = false);
// Compresses the row using the delta row compression algorithm.
// The seed row is updated.
void Compress(const uchar* row);
void Compress(const uchar* row);
protected:
// append byte to delta row
virtual void AppendByteToDeltaRow(uchar byte) = 0;
virtual void AppendByteToDeltaRow(uchar byte) = 0;
// returns the current size of the delta row
inline int CurrentDeltaRowSize() {
return fDeltaRowIndex;
}
inline int CurrentDeltaRowSize()
{
return fDeltaRowIndex;
}
private:
// Returns the index where seed row and row differ
// or -1 if both arrays are equal.
inline int DiffersIndex(const uchar* row, int index)
{
while (index < fSize) {
if (fSeedRow[index] != row[index]) {
return index;
}
index ++;
}
return -1;
}
inline int DiffersIndex(const uchar* row, int index)
{
while (index < fSize) {
if (fSeedRow[index] != row[index])
return index;
index ++;
}
return -1;
}
// Returns the number of bytes that row differs from seed row
// starting at the specified index.
inline int DiffersLength(const uchar* row, int index)
{
int startIndex = index;
while (index < fSize) {
if (fSeedRow[index] == row[index]) {
break;
}
index ++;
}
return index - startIndex;
}
inline int DiffersLength(const uchar* row, int index)
{
int startIndex = index;
while (index < fSize) {
if (fSeedRow[index] == row[index])
break;
index ++;
}
return index - startIndex;
}
// Compresses row with delta row compression algorithm.
// The seed row is updated only if updateSeedRow is true.
// If updateDeltaRow is true the method AppendByteToDeltaRow is called.
int CompressRaw(const uchar* row, bool updateSeedRow, bool updateDeltaRow);
int CompressRaw(const uchar* row, bool updateSeedRow,
bool updateDeltaRow);
// write byte to delta row and calculate size of delta row
void Put(uchar byte) {
if (fUpdateDeltaRow) {
AppendByteToDeltaRow(byte);
}
fDeltaRowIndex ++;
}
void Put(uchar byte)
{
if (fUpdateDeltaRow)
AppendByteToDeltaRow(byte);
fDeltaRowIndex ++;
}
uchar* fSeedRow; // the seed row
int fSize; // the size of the seed row in bytes
uchar fInitialSeed; // the value to initialize the seed row with
uchar* fSeedRow; // the seed row
int fSize; // the size of the seed row in bytes
uchar fInitialSeed;
// the value to initialize the seed row with
int fDeltaRowIndex; // the index of the next byte to be written into the delta row
bool fUpdateDeltaRow; // write delta row
int fDeltaRowIndex;
// the index of the next byte to be written into
// the delta row
bool fUpdateDeltaRow; // write delta row
};
class DeltaRowCompressor : public AbstractDeltaRowCompressor
{
public:
DeltaRowCompressor(int rowSize, uchar initialSeed)
: AbstractDeltaRowCompressor(rowSize, initialSeed)
{
// nothing to do
}
DeltaRowCompressor(int rowSize, uchar initialSeed)
:
AbstractDeltaRowCompressor(rowSize, initialSeed)
{}
// The delta row to be written to.
void SetDeltaRow(uchar* deltaRow) {
fDeltaRow = deltaRow;
}
void SetDeltaRow(uchar* deltaRow)
{
fDeltaRow = deltaRow;
}
protected:
virtual void AppendByteToDeltaRow(uchar byte) {
fDeltaRow[CurrentDeltaRowSize()] = byte;
}
virtual void AppendByteToDeltaRow(uchar byte)
{
fDeltaRow[CurrentDeltaRowSize()] = byte;
}
private:
uchar* fDeltaRow; // the delta row
uchar* fDeltaRow; // the delta row
};
#endif
src/add-ons/print/drivers/pcl6/PCL6.cpp
+165 -100
View File
@@ -4,22 +4,24 @@
* Copyright 2003 Michael Pfeiffer.
*/
#include "PCL6.h"
#include <memory.h>
#include <Alert.h>
#include <Bitmap.h>
#include <File.h>
#include <memory>
#include "DbgMsg.h"
#include "DeltaRowCompression.h"
#include "Halftone.h"
#include "JobData.h"
#include "PackBits.h"
#include "PCL6.h"
#include "PCL6Cap.h"
#include "PCL6Config.h"
#include "PrinterData.h"
#include "PCL6Rasterizer.h"
#include "PrinterData.h"
#include "UIDriver.h"
#include "ValidRect.h"
@@ -29,74 +31,87 @@ using namespace std;
#define std
#endif
// DeltaRowStreamCompressor writes the delta row directly to the
// in the contructor specified stream.
class DeltaRowStreamCompressor : public AbstractDeltaRowCompressor
{
public:
DeltaRowStreamCompressor(int rowSize, uchar initialSeed, PCL6Writer *writer)
: AbstractDeltaRowCompressor(rowSize, initialSeed)
, fWriter(writer)
{
// nothing to do
}
DeltaRowStreamCompressor(int rowSize, uchar initialSeed,
PCL6Writer* writer)
:
AbstractDeltaRowCompressor(rowSize, initialSeed),
fWriter(writer)
{}
protected:
void AppendByteToDeltaRow(uchar byte) {
fWriter->Append(byte);
}
void AppendByteToDeltaRow(uchar byte)
{
fWriter->Append(byte);
}
private:
PCL6Writer *fWriter;
PCL6Writer* fWriter;
};
PCL6Driver::PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap)
: GraphicsDriver(msg, printer_data, printer_cap)
PCL6Driver::PCL6Driver(BMessage* msg, PrinterData* printer_data,
const PrinterCap* printer_cap)
:
GraphicsDriver(msg, printer_data, printer_cap)
{
fHalftone = NULL;
fWriter = NULL;
}
void PCL6Driver::write(const uint8 *data, uint32 size)
void
PCL6Driver::write(const uint8* data, uint32 size)
{
writeSpoolData(data, size);
}
bool PCL6Driver::startDoc()
bool
PCL6Driver::startDoc()
{
try {
jobStart();
fHalftone = new Halftone(getJobData()->getSurfaceType(), getJobData()->getGamma(), getJobData()->getInkDensity(), getJobData()->getDitherType());
fHalftone = new Halftone(getJobData()->getSurfaceType(),
getJobData()->getGamma(), getJobData()->getInkDensity(),
getJobData()->getDitherType());
return true;
}
catch (TransportException &err) {
catch (TransportException& err) {
return false;
}
}
bool PCL6Driver::endDoc(bool)
bool
PCL6Driver::endDoc(bool)
{
try {
if (fHalftone) {
if (fHalftone)
delete fHalftone;
}
jobEnd();
return true;
}
catch (TransportException &err) {
catch (TransportException& err) {
return false;
}
}
bool PCL6Driver::nextBand(BBitmap *bitmap, BPoint *offset)
bool
PCL6Driver::nextBand(BBitmap* bitmap, BPoint* offset)
{
DBGMSG(("> nextBand\n"));
try {
int y = (int)offset->y;
PCL6Rasterizer *rasterizer;
PCL6Rasterizer* rasterizer;
if (useColorMode()) {
#if COLOR_DEPTH == 8
rasterizer = new ColorRGBRasterizer(fHalftone);
@@ -105,25 +120,27 @@ bool PCL6Driver::nextBand(BBitmap *bitmap, BPoint *offset)
#else
#error COLOR_DEPTH must be either 1 or 8!
#endif
} else {
} else
rasterizer = new MonochromeRasterizer(fHalftone);
}
auto_ptr<Rasterizer> _rasterizer(rasterizer);
bool valid = rasterizer->SetBitmap((int)offset->x, (int)offset->y, bitmap, getPageHeight());
bool valid = rasterizer->SetBitmap((int)offset->x, (int)offset->y,
bitmap, getPageHeight());
if (valid) {
rasterizer->InitializeBuffer();
// Use compressor to calculate delta row size
DeltaRowCompressor *deltaRowCompressor = NULL;
DeltaRowCompressor* deltaRowCompressor = NULL;
if (supportsDeltaRowCompression()) {
deltaRowCompressor = new DeltaRowCompressor(rasterizer->GetOutRowSize(), 0);
deltaRowCompressor =
new DeltaRowCompressor(rasterizer->GetOutRowSize(), 0);
if (deltaRowCompressor->InitCheck() != B_OK) {
delete deltaRowCompressor;
return false;
}
}
auto_ptr<DeltaRowCompressor> _deltaRowCompressor(deltaRowCompressor);
auto_ptr<DeltaRowCompressor>_deltaRowCompressor(deltaRowCompressor);
int deltaRowSize = 0;
// remember position
@@ -131,22 +148,26 @@ bool PCL6Driver::nextBand(BBitmap *bitmap, BPoint *offset)
int yPage = rasterizer->GetY();
while (rasterizer->HasNextLine()) {
const uchar *rowBuffer = (uchar*)rasterizer->RasterizeNextLine();
const uchar* rowBuffer =
static_cast<const uchar*>(rasterizer->RasterizeNextLine());
if (deltaRowCompressor != NULL) {
int size = deltaRowCompressor->CalculateSize(rowBuffer, true);
deltaRowSize += size + 2; // two bytes for the row byte count
int size =
deltaRowCompressor->CalculateSize(rowBuffer, true);
deltaRowSize += size + 2;
// two bytes for the row byte count
}
}
y = rasterizer->GetY();
uchar *outBuffer = rasterizer->GetOutBuffer();
uchar* outBuffer = rasterizer->GetOutBuffer();
int outBufferSize = rasterizer->GetOutBufferSize();
int outRowSize = rasterizer->GetOutRowSize();
int width = rasterizer->GetWidth();
int height = rasterizer->GetHeight();
writeBitmap(outBuffer, outBufferSize, outRowSize, xPage, yPage, width, height, deltaRowSize);
writeBitmap(outBuffer, outBufferSize, outRowSize, xPage, yPage,
width, height, deltaRowSize);
}
if (y >= getPageHeight()) {
@@ -158,14 +179,17 @@ bool PCL6Driver::nextBand(BBitmap *bitmap, BPoint *offset)
return true;
}
catch (TransportException &err) {
BAlert *alert = new BAlert("", err.what(), "OK");
catch (TransportException& err) {
BAlert* alert = new BAlert("", err.what(), "OK");
alert->Go();
return false;
}
}
void PCL6Driver::writeBitmap(const uchar* buffer, int outSize, int rowSize, int x, int y, int width, int height, int deltaRowSize)
void
PCL6Driver::writeBitmap(const uchar* buffer, int outSize, int rowSize, int x,
int y, int width, int height, int deltaRowSize)
{
// choose the best compression method
PCL6Writer::Compression compressionMethod = PCL6Writer::kNoCompression;
@@ -193,43 +217,55 @@ void PCL6Driver::writeBitmap(const uchar* buffer, int outSize, int rowSize, int
startRasterGraphics(x, y, width, height, compressionMethod);
rasterGraphics(buffer, outSize, dataSize, rowSize, height, compressionMethod);
rasterGraphics(buffer, outSize, dataSize, rowSize, height,
compressionMethod);
endRasterGraphics();
#if DISPLAY_COMPRESSION_STATISTICS
fprintf(stderr, "Out Size %d %2.2f\n", (int)outSize, 100.0);
#if ENABLE_RLE_COMPRESSION
fprintf(stderr, "RLE Size %d %2.2f\n", (int)rleSize, 100.0 * rleSize / outSize);
fprintf(stderr, "RLE Size %d %2.2f\n", (int)rleSize,
100.0 * rleSize / outSize);
#endif
#if ENABLE_DELTA_ROW_COMPRESSION
fprintf(stderr, "Delta Row Size %d %2.2f\n", (int)deltaRowSize, 100.0 * deltaRowSize / outSize);
fprintf(stderr, "Delta Row Size %d %2.2f\n", (int)deltaRowSize,
100.0 * deltaRowSize / outSize);
#endif
fprintf(stderr, "Data Size %d %2.2f\n", (int)dataSize, 100.0 * dataSize / outSize);
fprintf(stderr, "Data Size %d %2.2f\n", (int)dataSize,
100.0 * dataSize / outSize);
#endif
}
void PCL6Driver::jobStart()
void
PCL6Driver::jobStart()
{
// PCL6 begin
fWriter = new PCL6Writer(this);
PCL6Writer::ProtocolClass pc = (PCL6Writer::ProtocolClass)getProtocolClass();
fWriter->PJLHeader(pc, getJobData()->getXres(), "Copyright (c) 2003, 2004 Haiku");
fWriter->BeginSession(getJobData()->getXres(), getJobData()->getYres(), PCL6Writer::kInch, PCL6Writer::kBackChAndErrPage);
PCL6Writer::ProtocolClass pc =
(PCL6Writer::ProtocolClass)getProtocolClass();
fWriter->PJLHeader(pc, getJobData()->getXres(),
"Copyright (c) 2003, 2004 Haiku");
fWriter->BeginSession(getJobData()->getXres(), getJobData()->getYres(),
PCL6Writer::kInch, PCL6Writer::kBackChAndErrPage);
fWriter->OpenDataSource();
fMediaSide = PCL6Writer::kFrontMediaSide;
}
bool PCL6Driver::startPage(int)
bool
PCL6Driver::startPage(int)
{
PCL6Writer::Orientation orientation = PCL6Writer::kPortrait;
if (getJobData()->getOrientation() == JobData::kLandscape) {
orientation = PCL6Writer::kLandscape;
}
PCL6Writer::MediaSize mediaSize = PCL6Driver::mediaSize(getJobData()->getPaper());
PCL6Writer::MediaSource mediaSource = PCL6Driver::mediaSource(getJobData()->getPaperSource());
PCL6Writer::MediaSize mediaSize =
PCL6Driver::mediaSize(getJobData()->getPaper());
PCL6Writer::MediaSource mediaSource =
PCL6Driver::mediaSource(getJobData()->getPaperSource());
if (getJobData()->getPrintStyle() == JobData::kSimplex) {
fWriter->BeginPage(orientation, mediaSize, mediaSource);
} else if (getJobData()->getPrintStyle() == JobData::kDuplex) {
@@ -237,27 +273,29 @@ bool PCL6Driver::startPage(int)
fWriter->BeginPage(orientation, mediaSize, mediaSource,
PCL6Writer::kDuplexVerticalBinding, fMediaSide);
if (fMediaSide == PCL6Writer::kFrontMediaSide) {
if (fMediaSide == PCL6Writer::kFrontMediaSide)
fMediaSide = PCL6Writer::kBackMediaSide;
} else {
else
fMediaSide = PCL6Writer::kFrontMediaSide;
}
} else {
} else
return false;
}
// PageOrigin from Windows NT printer driver
int x = 142 * getJobData()->getXres() / 600;
int y = 100 * getJobData()->getYres() / 600;
fWriter->SetPageOrigin(x, y);
fWriter->SetColorSpace(useColorMode() ? PCL6Writer::kRGB : PCL6Writer::kGray);
fWriter->SetColorSpace(useColorMode() ? PCL6Writer::kRGB
: PCL6Writer::kGray);
fWriter->SetPaintTxMode(PCL6Writer::kOpaque);
fWriter->SetSourceTxMode(PCL6Writer::kOpaque);
fWriter->SetROP(204);
return true;
}
void PCL6Driver::startRasterGraphics(int x, int y, int width, int height, PCL6Writer::Compression compressionMethod)
void
PCL6Driver::startRasterGraphics(int x, int y, int width, int height,
PCL6Writer::Compression compressionMethod)
{
PCL6Writer::ColorDepth colorDepth;
if (useColorMode()) {
@@ -268,26 +306,25 @@ void PCL6Driver::startRasterGraphics(int x, int y, int width, int height, PCL6Wr
#else
#error COLOR_DEPTH must be either 1 or 8!
#endif
} else {
} else
colorDepth = PCL6Writer::k1Bit;
}
fWriter->BeginImage(PCL6Writer::kDirectPixel, colorDepth, width, height, width, height);
fWriter->BeginImage(PCL6Writer::kDirectPixel, colorDepth, width, height,
width, height);
fWriter->ReadImage(compressionMethod, 0, height);
}
void PCL6Driver::endRasterGraphics()
void
PCL6Driver::endRasterGraphics()
{
fWriter->EndImage();
}
void PCL6Driver::rasterGraphics(
const uchar *buffer,
int bufferSize,
int dataSize,
int rowSize,
int height,
int compressionMethod
)
void
PCL6Driver::rasterGraphics(const uchar* buffer, int bufferSize, int dataSize,
int rowSize, int height, int compressionMethod)
{
// write bitmap byte size
fWriter->EmbeddedDataPrefix32(dataSize);
@@ -295,7 +332,7 @@ void PCL6Driver::rasterGraphics(
// write data
if (compressionMethod == PCL6Writer::kRLECompression) {
// use RLE compression
uchar *outBuffer = new uchar[dataSize];
uchar* outBuffer = new uchar[dataSize];
pack_bits(outBuffer, buffer, bufferSize);
fWriter->Append(outBuffer, dataSize);
delete[] outBuffer;
@@ -326,18 +363,22 @@ void PCL6Driver::rasterGraphics(
}
}
bool PCL6Driver::endPage(int)
bool
PCL6Driver::endPage(int)
{
try {
fWriter->EndPage(getJobData()->getCopies());
return true;
}
catch (TransportException &err) {
catch (TransportException& err) {
return false;
}
}
void PCL6Driver::jobEnd()
void
PCL6Driver::jobEnd()
{
fWriter->CloseDataSource();
fWriter->EndSession();
@@ -347,44 +388,60 @@ void PCL6Driver::jobEnd()
fWriter = NULL;
}
void PCL6Driver::move(int x, int y)
void
PCL6Driver::move(int x, int y)
{
fWriter->SetCursor(x, y);
}
bool
PCL6Driver::supportsRLECompression()
{
return getJobData()->getColor() != JobData::kColorCompressionDisabled;
}
bool
PCL6Driver::supportsDeltaRowCompression()
{
return getProtocolClass() >= PCL6Writer::kProtocolClass2_1 &&
getJobData()->getColor() != JobData::kColorCompressionDisabled;
return getProtocolClass() >= PCL6Writer::kProtocolClass2_1
&& getJobData()->getColor() != JobData::kColorCompressionDisabled;
}
bool
PCL6Driver::useColorMode()
{
return getJobData()->getColor() != JobData::kMonochrome;
}
PCL6Writer::MediaSize PCL6Driver::mediaSize(JobData::Paper paper)
PCL6Writer::MediaSize
PCL6Driver::mediaSize(JobData::Paper paper)
{
switch (paper) {
case JobData::kLetter: return PCL6Writer::kLetterPaper;
case JobData::kLegal: return PCL6Writer::kLegalPaper;
case JobData::kA4: return PCL6Writer::kA4Paper;
case JobData::kExecutive: return PCL6Writer::kExecPaper;
case JobData::kLedger: return PCL6Writer::kLedgerPaper;
case JobData::kA3: return PCL6Writer::kA3Paper;
case JobData::kB5: return PCL6Writer::kB5Paper;
case JobData::kJapanesePostcard:
return PCL6Writer::kJPostcard;
case JobData::kA5: return PCL6Writer::kA5Paper;
case JobData::kB4: return PCL6Writer::kJB4Paper;
case JobData::kLetter:
return PCL6Writer::kLetterPaper;
case JobData::kLegal:
return PCL6Writer::kLegalPaper;
case JobData::kA4:
return PCL6Writer::kA4Paper;
case JobData::kExecutive:
return PCL6Writer::kExecPaper;
case JobData::kLedger:
return PCL6Writer::kLedgerPaper;
case JobData::kA3:
return PCL6Writer::kA3Paper;
case JobData::kB5:
return PCL6Writer::kB5Paper;
case JobData::kJapanesePostcard:
return PCL6Writer::kJPostcard;
case JobData::kA5:
return PCL6Writer::kA5Paper;
case JobData::kB4:
return PCL6Writer::kJB4Paper;
/*
case : return PCL6Writer::kCOM10Envelope;
case : return PCL6Writer::kMonarchEnvelope;
@@ -407,20 +464,28 @@ PCL6Writer::MediaSize PCL6Driver::mediaSize(JobData::Paper paper)
}
}
PCL6Writer::MediaSource PCL6Driver::mediaSource(JobData::PaperSource source)
PCL6Writer::MediaSource
PCL6Driver::mediaSource(JobData::PaperSource source)
{
switch (source) {
case JobData::kAuto: return PCL6Writer::kAutoSelect;
case JobData::kCassette1: return PCL6Writer::kDefaultSource;
case JobData::kCassette2: return PCL6Writer::kEnvelopeTray;
case JobData::kLower: return PCL6Writer::kLowerCassette;
case JobData::kUpper: return PCL6Writer::kUpperCassette;
case JobData::kMiddle: return PCL6Writer::kThirdCassette;
case JobData::kManual: return PCL6Writer::kManualFeed;
case JobData::kCassette3: return PCL6Writer::kMultiPurposeTray;
case JobData::kAuto:
return PCL6Writer::kAutoSelect;
case JobData::kCassette1:
return PCL6Writer::kDefaultSource;
case JobData::kCassette2:
return PCL6Writer::kEnvelopeTray;
case JobData::kLower:
return PCL6Writer::kLowerCassette;
case JobData::kUpper:
return PCL6Writer::kUpperCassette;
case JobData::kMiddle:
return PCL6Writer::kThirdCassette;
case JobData::kManual:
return PCL6Writer::kManualFeed;
case JobData::kCassette3:
return PCL6Writer::kMultiPurposeTray;
default:
return PCL6Writer::kAutoSelect;
}
}
src/add-ons/print/drivers/pcl6/PCL6.h
+31 -31
View File
@@ -3,7 +3,6 @@
* Copyright 1999-2000 Y.Takagi. All Rights Reserved.
* Copyright 2003 Michael Pfeiffer.
*/
#ifndef __PCL6_H
#define __PCL6_H
@@ -12,45 +11,46 @@
#include "PCL6Cap.h"
#include "PCL6Writer.h"
class Halftone;
class PCL6Driver : public GraphicsDriver, public PCL6WriterStream
class PCL6Driver : public GraphicsDriver, public PCL6WriterStream
{
public:
PCL6Driver(BMessage *msg, PrinterData *printer_data, const PrinterCap *printer_cap);
PCL6Driver(BMessage* msg, PrinterData* printer_data,
const PrinterCap* printer_cap);
void write(const uint8 *data, uint32 size);
void write(const uint8* data, uint32 size);
protected:
virtual bool startDoc();
virtual bool startPage(int page);
virtual bool nextBand(BBitmap *bitmap, BPoint *offset);
virtual bool endPage(int page);
virtual bool endDoc(bool success);
virtual bool startDoc();
virtual bool startPage(int page);
virtual bool nextBand(BBitmap* bitmap, BPoint* offset);
virtual bool endPage(int page);
virtual bool endDoc(bool success);
private:
bool supportsRLECompression();
bool supportsDeltaRowCompression();
bool useColorMode();
PCL6Writer::MediaSize mediaSize(JobData::Paper paper);
PCL6Writer::MediaSource mediaSource(JobData::PaperSource source);
void move(int x, int y);
void jobStart();
void writeBitmap(const uchar* buffer, int outSize, int rowSize, int x, int y, int width, int height, int deltaRowSize);
void startRasterGraphics(int x, int y, int width, int height, PCL6Writer::Compression compressionMethod);
void endRasterGraphics();
void rasterGraphics(
const uchar *buffer,
int bufferSize,
int dataSize,
int rowSize,
int height,
int compression_method);
void jobEnd();
bool supportsRLECompression();
bool supportsDeltaRowCompression();
bool useColorMode();
PCL6Writer::MediaSize mediaSize(JobData::Paper paper);
PCL6Writer::MediaSource mediaSource(JobData::PaperSource source);
void move(int x, int y);
void jobStart();
void writeBitmap(const uchar* buffer, int outSize, int rowSize,
int x, int y, int width, int height, int deltaRowSize);
void startRasterGraphics(int x, int y, int width, int height,
PCL6Writer::Compression compressionMethod);
void endRasterGraphics();
void rasterGraphics(const uchar* buffer, int bufferSize,
int dataSize, int rowSize, int height,
int compression_method);
void jobEnd();
PCL6Writer *fWriter;
PCL6Writer::MediaSide fMediaSide; // side if in duplex mode
Halftone *fHalftone;
PCL6Writer* fWriter;
PCL6Writer::MediaSide fMediaSide; // side if in duplex mode
Halftone* fHalftone;
};
#endif /* __PCL6_H */
#endif // __PCL6_H
src/add-ons/print/drivers/pcl6/PCL6Cap.cpp
+107 -95
View File
@@ -3,8 +3,8 @@
* Copyright 1999-2000 Y.Takagi. All Rights Reserved.
* Copyright 2003-2007 Michael Pfeiffer.
*/
#include "PCL6Cap.h"
#include "PCL6Config.h"
#include "PCL6Writer.h"
#include "PrinterData.h"
@@ -133,58 +133,65 @@ const PaperCap b4(
// since 2.1
// since 1.1
const PaperSourceCap defaultSource("Default", false, JobData::kCassette1);
const PaperSourceCap autobin("Auto", true, JobData::kAuto);
const PaperSourceCap manualFeed("Manual Feed", false, JobData::kManual);
const PaperSourceCap multiPurposeTray("Multi Purpose Tray", false, JobData::kCassette3);
const PaperSourceCap upperCassette("Upper Cassette", false, JobData::kUpper);
const PaperSourceCap lowerCassette("Lower Cassette", false, JobData::kLower);
const PaperSourceCap envelopeTray("Envelope Tray", false, JobData::kCassette2);
const PaperSourceCap defaultSource("Default", false, JobData::kCassette1);
const PaperSourceCap autobin("Auto", true, JobData::kAuto);
const PaperSourceCap manualFeed("Manual Feed", false, JobData::kManual);
const PaperSourceCap multiPurposeTray("Multi Purpose Tray", false,
JobData::kCassette3);
const PaperSourceCap upperCassette("Upper Cassette", false, JobData::kUpper);
const PaperSourceCap lowerCassette("Lower Cassette", false, JobData::kLower);
const PaperSourceCap envelopeTray("Envelope Tray", false,
JobData::kCassette2);
// since 2.0:
const PaperSourceCap thridCassette("Thrid Cassette", false, JobData::kMiddle);
const ResolutionCap dpi150("150dpi", false, 150, 150);
const ResolutionCap dpi300("300dpi", true, 300, 300);
const ResolutionCap dpi600("600dpi", false, 600, 600);
const ResolutionCap dpi150("150dpi", false, 150, 150);
const ResolutionCap dpi300("300dpi", true, 300, 300);
const ResolutionCap dpi600("600dpi", false, 600, 600);
const ResolutionCap dpi1200("1200dpi", false, 1200, 1200);
const PrintStyleCap simplex("Simplex", true, JobData::kSimplex);
const PrintStyleCap duplex("Duplex", false, JobData::kDuplex);
const ProtocolClassCap pc1_1("PCL 6 Protocol Class 1.1", true, PCL6Writer::kProtocolClass1_1,
"The printer driver supports the following features of protocol class 1.1:\n"
"* Monochrome and Color Printing.\n"
"* Paper Formats: Letter, Legal, A4, A3, A5 and Japanese Postcard.\n"
"* Paper Sources: Auto, Default, Manual Feed, Multi-Purpose Tray, Upper and Lower Cassette and Envelope Tray.\n"
"* Resolutions: 150, 300, 600 and 1200 DPI."
const ProtocolClassCap pc1_1("PCL 6 Protocol Class 1.1", true,
PCL6Writer::kProtocolClass1_1,
"The printer driver supports the following features of protocol class 1.1:"
"\n"
"* Monochrome and Color Printing.\n"
"* Paper Formats: Letter, Legal, A4, A3, A5 and Japanese Postcard.\n"
"* Paper Sources: Auto, Default, Manual Feed, Multi-Purpose Tray, Upper "
"and Lower Cassette and Envelope Tray.\n"
"* Resolutions: 150, 300, 600 and 1200 DPI."
#if ENABLE_RLE_COMPRESSION
"\n* Compression Method: RLE."
"\n* Compression Method: RLE."
#else
"\n* Compression Method: None."
"\n* Compression Method: None."
#endif
);
const ProtocolClassCap pc2_0("PCL 6 Protocol Class 2.0", false, PCL6Writer::kProtocolClass2_0,
"In addition to features of protocol class 1.1, the printer driver supports the "
"following features of protocol class 2.0:\n"
"* Additonal Paper Source: Third Cassette."
// "\n* JPEG compression (not implemented yet)"
const ProtocolClassCap pc2_0("PCL 6 Protocol Class 2.0", false,
PCL6Writer::kProtocolClass2_0,
"In addition to features of protocol class 1.1, the printer driver "
"supports the following features of protocol class 2.0:\n"
"* Additonal Paper Source: Third Cassette."
// "\n* JPEG compression (not implemented yet)"
);
const ProtocolClassCap pc2_1("PCL 6 Protocol Class 2.1", false, PCL6Writer::kProtocolClass2_1,
"In addition to features of previous protocol classes, the printer driver supports the "
"following features of protocol class 2.1:\n"
"* Additional Paper Format: B5."
const ProtocolClassCap pc2_1("PCL 6 Protocol Class 2.1", false,
PCL6Writer::kProtocolClass2_1,
"In addition to features of previous protocol classes, the printer driver "
"supports the following features of protocol class 2.1:\n"
"* Additional Paper Format: B5."
#if ENABLE_DELTA_ROW_COMPRESSION
"\n* Additional Compression Method: Delta Row Compression."
"\n* Additional Compression Method: Delta Row Compression."
#endif
);
// Disable until driver supports new features of protocol class 3.0
//const ProtocolClassCap pc3_0("PCL 6 Protocol Class 3.0", false, PCL6Writer::kProtocolClass3_0,
//"Protocol Class 3.0");
// const ProtocolClassCap pc3_0("PCL 6 Protocol Class 3.0", false,
// PCL6Writer::kProtocolClass3_0, "Protocol Class 3.0");
const PaperCap *papers1_1[] = {
const PaperCap* papers1_1[] = {
&letter,
&legal,
&a4,
@@ -194,7 +201,7 @@ const PaperCap *papers1_1[] = {
&japanese_postcard
};
const PaperCap *papers2_1[] = {
const PaperCap* papers2_1[] = {
&letter,
&legal,
&a4,
@@ -205,7 +212,7 @@ const PaperCap *papers2_1[] = {
&japanese_postcard
};
const PaperSourceCap *paperSources1_1[] = {
const PaperSourceCap* paperSources1_1[] = {
&autobin,
&defaultSource,
&envelopeTray,
@@ -215,7 +222,7 @@ const PaperSourceCap *paperSources1_1[] = {
&multiPurposeTray
};
const PaperSourceCap *paperSources2_0[] = {
const PaperSourceCap* paperSources2_0[] = {
&autobin,
&defaultSource,
&envelopeTray,
@@ -226,19 +233,19 @@ const PaperSourceCap *paperSources2_0[] = {
&multiPurposeTray
};
const ResolutionCap *resolutions[] = {
const ResolutionCap* resolutions[] = {
&dpi150,
&dpi300,
&dpi600,
&dpi1200,
};
const PrintStyleCap *printStyles[] = {
const PrintStyleCap* printStyles[] = {
&simplex,
&duplex
};
const ProtocolClassCap *protocolClasses[] = {
const ProtocolClassCap* protocolClasses[] = {
&pc1_1,
&pc2_0,
&pc2_1
@@ -247,84 +254,89 @@ const ProtocolClassCap *protocolClasses[] = {
};
const ColorCap color("Color", false, JobData::kColor);
const ColorCap colorCompressionDisabled("Color (No Compression)", false, JobData::kColorCompressionDisabled);
const ColorCap colorCompressionDisabled("Color (No Compression)", false,
JobData::kColorCompressionDisabled);
const ColorCap monochrome("Shades of Gray", true, JobData::kMonochrome);
const ColorCap *colors[] = {
const ColorCap* colors[] = {
&color,
&colorCompressionDisabled,
&monochrome
};
PCL6Cap::PCL6Cap(const PrinterData *printer_data)
: PrinterCap(printer_data)
PCL6Cap::PCL6Cap(const PrinterData* printer_data)
:
PrinterCap(printer_data)
{
}
int PCL6Cap::countCap(CapID capid) const
int
PCL6Cap::countCap(CapID capid) const
{
switch (capid) {
case kPaper:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_1) {
return sizeof(papers2_1) / sizeof(papers2_1[0]);
}
return sizeof(papers1_1) / sizeof(papers1_1[0]);
case kPaperSource:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_0) {
return sizeof(paperSources2_0) / sizeof(paperSources2_0[0]);
}
return sizeof(paperSources1_1) / sizeof(paperSources1_1[0]);
case kResolution:
return sizeof(resolutions) / sizeof(resolutions[0]);
case kColor:
return sizeof(colors) / sizeof(colors[0]);
case kPrintStyle:
return sizeof(printStyles) / sizeof(printStyles[0]);
case kProtocolClass:
return sizeof(protocolClasses) / sizeof(protocolClasses[0]);
default:
return 0;
case kPaper:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_1)
return sizeof(papers2_1) / sizeof(papers2_1[0]);
return sizeof(papers1_1) / sizeof(papers1_1[0]);
case kPaperSource:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_0)
return sizeof(paperSources2_0) / sizeof(paperSources2_0[0]);
return sizeof(paperSources1_1) / sizeof(paperSources1_1[0]);
case kResolution:
return sizeof(resolutions) / sizeof(resolutions[0]);
case kColor:
return sizeof(colors) / sizeof(colors[0]);
case kPrintStyle:
return sizeof(printStyles) / sizeof(printStyles[0]);
case kProtocolClass:
return sizeof(protocolClasses) / sizeof(protocolClasses[0]);
default:
return 0;
}
}
const BaseCap **PCL6Cap::enumCap(CapID capid) const
const BaseCap**
PCL6Cap::enumCap(CapID capid) const
{
switch (capid) {
case kPaper:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_1) {
return (const BaseCap **)papers2_1;
}
return (const BaseCap **)papers1_1;
case kPaperSource:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_0) {
return (const BaseCap **)paperSources2_0;
}
return (const BaseCap **)paperSources1_1;
case kResolution:
return (const BaseCap **)resolutions;
case kColor:
return (const BaseCap **)colors;
case kPrintStyle:
return (const BaseCap **)printStyles;
case kProtocolClass:
return (const BaseCap **)protocolClasses;
default:
return NULL;
case kPaper:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_1)
return (const BaseCap **)papers2_1;
return (const BaseCap**)papers1_1;
case kPaperSource:
if (getProtocolClass() >= PCL6Writer::kProtocolClass2_0)
return (const BaseCap **)paperSources2_0;
return (const BaseCap**)paperSources1_1;
case kResolution:
return (const BaseCap**)resolutions;
case kColor:
return (const BaseCap**)colors;
case kPrintStyle:
return (const BaseCap**)printStyles;
case kProtocolClass:
return (const BaseCap**)protocolClasses;
default:
return NULL;
}
}
bool PCL6Cap::isSupport(CapID capid) const
bool
PCL6Cap::isSupport(CapID capid) const
{
switch (capid) {
case kPaper:
case kPaperSource:
case kResolution:
case kColor:
case kCopyCommand:
case kPrintStyle:
case kProtocolClass:
return true;
default:
return false;
case kPaper:
case kPaperSource:
case kResolution:
case kColor:
case kCopyCommand:
case kPrintStyle:
case kProtocolClass:
return true;
default:
return false;
}
}
src/add-ons/print/drivers/pcl6/PCL6Cap.h
+7 -6
View File
@@ -2,18 +2,19 @@
* PCL6Cap.h
* Copyright 1999-2000 Y.Takagi. All Rights Reserved.
*/
#ifndef __PCL6CAP_H
#define __PCL6CAP_H
#include "PrinterCap.h"
class PCL6Cap : public PrinterCap {
public:
PCL6Cap(const PrinterData *printer_data);
virtual int countCap(CapID) const;
virtual bool isSupport(CapID) const;
virtual const BaseCap **enumCap(CapID) const;
PCL6Cap(const PrinterData* printer_data);
virtual int countCap(CapID) const;
virtual bool isSupport(CapID) const;
virtual const BaseCap **enumCap(CapID) const;
};
#endif /* __PCL6CAP_H */
#endif // __PCL6CAP_H
src/add-ons/print/drivers/pcl6/PCL6Config.h
+8 -9
View File
@@ -2,29 +2,28 @@
* PCL6Config.cpp
* Copyright 2005 Michael Pfeiffer.
*/
#ifndef _PCL6_CONFIG
#define _PCL6_CONFIG
// Compression method configuration
// Set to 0 to disable compression and to 1 to enable compression
// Note compression takes place only if it takes less space than uncompressed data!
// Note compression takes place only if it takes less space than uncompressed
// data!
// Run-Length-Encoding Compression
#define ENABLE_RLE_COMPRESSION 1
//#define ENABLE_RLE_COMPRESSION 0
#define ENABLE_RLE_COMPRESSION 1
//#define ENABLE_RLE_COMPRESSION 0
// Delta Row Compression
#define ENABLE_DELTA_ROW_COMPRESSION 1
#define ENABLE_DELTA_ROW_COMPRESSION 1
// Color depth for color printing.
// Use either 1 or 8.
// If 1 bit depth is used, the class Halftone is used for dithering
// otherwise dithering is not performed.
#define COLOR_DEPTH 1
//#define COLOR_DEPTH 8
#define COLOR_DEPTH 1
//#define COLOR_DEPTH 8
#define DISPLAY_COMPRESSION_STATISTICS 0
#define DISPLAY_COMPRESSION_STATISTICS 0
#endif
src/add-ons/print/drivers/pcl6/PCL6Entry.cpp
+12 -5
View File
@@ -4,14 +4,19 @@
* Copyright 2003 Michael Pfeiffer.
*/
#include "PCL6.h"
#include "PCL6Cap.h"
#include "PrinterDriver.h"
class PCL6PrinterDriver : public PrinterDriver
{
public:
PCL6PrinterDriver(BNode* printerFolder) : PrinterDriver(printerFolder) {}
PCL6PrinterDriver(BNode* printerFolder)
:
PrinterDriver(printerFolder)
{}
const char* GetSignature() const
{
@@ -23,7 +28,7 @@ public:
return "PCL6 compatible";
}
const char* GetVersion() const
const char* GetVersion() const
{
return "0.2";
}
@@ -38,14 +43,16 @@ public:
return new PCL6Cap(printerData);
}
GraphicsDriver* InstantiateGraphicsDriver(BMessage* settings, PrinterData* printerData, PrinterCap* printerCap)
GraphicsDriver* InstantiateGraphicsDriver(BMessage* settings,
PrinterData* printerData, PrinterCap* printerCap)
{
return new PCL6Driver(settings, printerData, printerCap);
}
};
PrinterDriver* instantiate_printer_driver(BNode* printerFolder)
PrinterDriver*
instantiate_printer_driver(BNode* printerFolder)
{
return new PCL6PrinterDriver(printerFolder);
}
src/add-ons/print/drivers/pcl6/PCL6Rasterizer.cpp
+125 -100
View File
@@ -1,16 +1,19 @@
/*
** PCL6Rasterizer.cpp
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net. All rights reserved.
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net.
** All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/
#include "PCL6Rasterizer.h"
#include <stdio.h>
#ifdef _PCL6_RASTERIZER_TEST_
static void dump(uchar *buffer, int size);
static void dump_bits(uchar *buffer, int size);
static void dump(uchar* buffer, int size);
static void dump_bits(uchar* buffer, int size);
#define DUMP(text, buffer, size) { fprintf text; dump(buffer, size); }
#define DUMP_BITS(text, buffer, size) { fprintf text; dump_bits(buffer, size); }
@@ -22,17 +25,22 @@ static void dump_bits(uchar *buffer, int size);
#endif
// MonochromeRasterizer
MonochromeRasterizer::MonochromeRasterizer(Halftone *halftone)
: PCL6Rasterizer(halftone)
, fOutBuffer(NULL)
{ }
// #pragma - MonochromeRasterizer
MonochromeRasterizer::MonochromeRasterizer(Halftone* halftone)
:
PCL6Rasterizer(halftone),
fOutBuffer(NULL)
{}
void
MonochromeRasterizer::InitializeBuffer() {
MonochromeRasterizer::InitializeBuffer()
{
fWidthByte = RowBufferSize(GetWidth(), 1, 1);
/* line length is a multiple of 4 bytes */
// line length is a multiple of 4 bytes
fOutRowSize = RowBufferSize(GetWidth(), 1, 4);
fPadBytes = fOutRowSize - fWidthByte;
// Total size
@@ -41,38 +49,42 @@ MonochromeRasterizer::InitializeBuffer() {
fCurrentLine = GetOutBuffer();
}
const void *
MonochromeRasterizer::RasterizeLine(int x, int y, const ColorRGB32Little* source) {
const void*
MonochromeRasterizer::RasterizeLine(int x, int y,
const ColorRGB32Little* source)
{
GetHalftone()->dither(fCurrentLine, (const uchar*)source, x, y, GetWidth());
uchar *out = fCurrentLine;
uchar* out = fCurrentLine;
// invert pixels
for (int w = fWidthByte; w > 0; w --, out ++) {
for (int w = fWidthByte; w > 0; w --, out ++)
*out = ~*out;
}
// pad with 0s
for (int w = fPadBytes; w > 0; w --, out ++) {
// pad with zeros
for (int w = fPadBytes; w > 0; w --, out ++)
*out = 0;
}
void *result = fCurrentLine;
void* result = fCurrentLine;
fCurrentLine += fOutRowSize;
return result;
}
// ColorRGBRasterizer
// #pragma - ColorRGBRasterizer
ColorRGBRasterizer::ColorRGBRasterizer(Halftone* halftone)
:
PCL6Rasterizer(halftone)
{}
ColorRGBRasterizer::ColorRGBRasterizer(Halftone *halftone)
: PCL6Rasterizer(halftone)
{ }
void
ColorRGBRasterizer::InitializeBuffer() {
fWidthByte = RowBufferSize(GetWidth(), 24, 1);
// line length is a multiple of 4 bytes
// line length is a multiple of 4 bytes
fOutRowSize = RowBufferSize(GetWidth(), 24, 4);
fPadBytes = fOutRowSize - fWidthByte;
// Total size
@@ -81,10 +93,12 @@ ColorRGBRasterizer::InitializeBuffer() {
fCurrentLine = GetOutBuffer();
}
const void *
ColorRGBRasterizer::RasterizeLine(int x, int y, const ColorRGB32Little* source) {
uchar *out = fCurrentLine;
const void*
ColorRGBRasterizer::RasterizeLine(int x, int y,
const ColorRGB32Little* source)
{
uchar* out = fCurrentLine;
int width = GetWidth();
for (int w = width; w > 0; w --) {
*out++ = source->red;
@@ -94,29 +108,30 @@ ColorRGBRasterizer::RasterizeLine(int x, int y, const ColorRGB32Little* source)
}
// pad with 0s
for (int w = fPadBytes; w > 0; w --, out ++) {
for (int w = fPadBytes; w > 0; w --, out ++)
*out = 0;
}
void *result = fCurrentLine;
void* result = fCurrentLine;
fCurrentLine += fOutRowSize;
return result;
}
// ColorRasterizer
// #pragma - ColorRasterizer
ColorRasterizer::ColorRasterizer::ColorRasterizer(Halftone *halftone)
: PCL6Rasterizer(halftone)
{
for (int plane = 0; plane < 3; plane ++) {
ColorRasterizer::ColorRasterizer::ColorRasterizer(Halftone* halftone)
:
PCL6Rasterizer(halftone)
{
for (int plane = 0; plane < 3; plane ++)
fPlaneBuffers[plane] = NULL;
}
halftone->setPlanes(Halftone::kPlaneRGB1);
halftone->setBlackValue(Halftone::kLowValueMeansBlack);
}
ColorRasterizer::~ColorRasterizer() {
for (int plane = 0; plane < 3; plane ++) {
delete fPlaneBuffers[plane];
@@ -124,10 +139,11 @@ ColorRasterizer::~ColorRasterizer() {
}
}
void
ColorRasterizer::InitializeBuffer() {
fWidthByte = RowBufferSize(GetWidth(), 3, 1);
// line length is a multiple of 4 bytes
// line length is a multiple of 4 bytes
fOutRowSize = RowBufferSize(GetWidth(), 3, 4);
fPadBytes = fOutRowSize - fWidthByte;
// Total size
@@ -141,21 +157,24 @@ ColorRasterizer::InitializeBuffer() {
}
}
enum {
kRed = 1,
kGreen = 2,
kBlue = 4,
};
const void *
ColorRasterizer::RasterizeLine(int x, int y, const ColorRGB32Little* source) {
DUMP((stderr, "\nRGB32 row at x %d y %d:\n", x, y), (uchar*)source, GetWidth() * 4);
const void*
ColorRasterizer::RasterizeLine(int x, int y, const ColorRGB32Little* source)
{
DUMP((stderr, "\nRGB32 row at x %d y %d:\n", x, y), (uchar*)source,
GetWidth() * 4);
// dither each color component
for (int plane = 0; plane < 3; plane ++) {
GetHalftone()->dither(fPlaneBuffers[plane], (const uchar*)source, x, y, GetWidth());
}
for (int plane = 0; plane < 3; plane ++)
GetHalftone()->dither(fPlaneBuffers[plane], (const uchar*)source, x, y,
GetWidth());
DUMP_BITS((stderr, "red "), fPlaneBuffers[0], fPlaneBufferSize);
DUMP_BITS((stderr, "green "), fPlaneBuffers[1], fPlaneBufferSize);
@@ -166,56 +185,57 @@ ColorRasterizer::RasterizeLine(int x, int y, const ColorRGB32Little* source) {
DUMP_BITS((stderr, "merged\n"), fCurrentLine, fOutRowSize);
DUMP((stderr, "\n"), fCurrentLine, fOutRowSize);
void *result = fCurrentLine;
void* result = fCurrentLine;
fCurrentLine += fOutRowSize;
return result;
}
void
ColorRasterizer::MergePlaneBuffersToCurrentLine()
{
// merge the three planes into output buffer
int remainingPixels = GetWidth();
uchar *out = fCurrentLine;
uchar* out = fCurrentLine;
uchar value = 0;
uchar outMask = 0x80; // current bit mask (1 << (8 - bit)) in output buffer
// iterate over the three plane buffers
for (int i = 0; i < fPlaneBufferSize; i ++) {
int pixels = 8;
if (remainingPixels < 8) {
if (remainingPixels < 8)
pixels = remainingPixels;
}
remainingPixels -= pixels;
if (remainingPixels >= 8) {
register const uchar
red = fPlaneBuffers[0][i],
red = fPlaneBuffers[0][i],
green = fPlaneBuffers[1][i],
blue = fPlaneBuffers[2][i];
blue = fPlaneBuffers[2][i];
register uchar value = 0;
if (red & 0x80) value = 0x80;
if (red & 0x40) value |= 0x10;
if (red & 0x20) value |= 0x02;
if (red & 0x80) value = 0x80;
if (red & 0x40) value |= 0x10;
if (red & 0x20) value |= 0x02;
if (green & 0x80) value |= 0x40;
if (green & 0x40) value |= 0x08;
if (green & 0x20) value |= 0x01;
if (blue & 0x80) value |= 0x20;
if (blue & 0x40) value |= 0x04;
if (blue & 0x80) value |= 0x20;
if (blue & 0x40) value |= 0x04;
*out++ = value;
value = 0;
if (blue & 0x20) value = 0x80;
if (blue & 0x10) value |= 0x10;
if (blue & 0x08) value |= 0x02;
if (blue & 0x20) value = 0x80;
if (blue & 0x10) value |= 0x10;
if (blue & 0x08) value |= 0x02;
if (red & 0x10) value |= 0x40;
if (red & 0x08) value |= 0x08;
if (red & 0x04) value |= 0x01;
if (red & 0x10) value |= 0x40;
if (red & 0x08) value |= 0x08;
if (red & 0x04) value |= 0x01;
if (green & 0x10) value |= 0x20;
if (green & 0x08) value |= 0x04;
@@ -226,39 +246,35 @@ ColorRasterizer::MergePlaneBuffersToCurrentLine()
if (green & 0x02) value |= 0x10;
if (green & 0x01) value |= 0x02;
if (blue & 0x04) value |= 0x40;
if (blue & 0x02) value |= 0x08;
if (blue & 0x01) value |= 0x01;
if (blue & 0x04) value |= 0x40;
if (blue & 0x02) value |= 0x08;
if (blue & 0x01) value |= 0x01;
if (red & 0x02) value |= 0x20;
if (red & 0x01) value |= 0x04;
if (red & 0x02) value |= 0x20;
if (red & 0x01) value |= 0x04;
*out++ = value;
} else {
register const uchar
red = fPlaneBuffers[0][i],
red = fPlaneBuffers[0][i],
green = fPlaneBuffers[1][i],
blue = fPlaneBuffers[2][i];
blue = fPlaneBuffers[2][i];
// for each bit in the current byte of each plane
uchar mask = 0x80;
for (; pixels > 0; pixels --) {
int rgb = 0;
if (red & mask) {
if (red & mask)
rgb |= kRed;
}
if (green & mask) {
if (green & mask)
rgb |= kGreen;
}
if (blue & mask) {
if (blue & mask)
rgb |= kBlue;
}
for (int plane = 0; plane < 3; plane ++) {
// copy pixel value to output value
if (rgb & (1 << plane)) {
if (rgb & (1 << plane))
value |= outMask;
}
// increment output mask
if (outMask == 0x01) {
@@ -267,9 +283,8 @@ ColorRasterizer::MergePlaneBuffersToCurrentLine()
*out = value;
out ++;
value = 0;
} else {
} else
outMask >>= 1;
}
}
mask >>= 1;
}
@@ -287,20 +302,20 @@ ColorRasterizer::MergePlaneBuffersToCurrentLine()
out ++;
}
if (out - fCurrentLine != fWidthByte) {
fprintf(stderr, "Error buffer overflow: %d != %d\n", fWidthByte, (int)(out - fCurrentLine));
}
if (out - fCurrentLine != fWidthByte)
fprintf(stderr, "Error buffer overflow: %d != %d\n", fWidthByte,
static_cast<int>(out - fCurrentLine));
// pad with 0s
for (int w = fPadBytes; w > 0; w --, out ++) {
// pad with zeros
for (int w = fPadBytes; w > 0; w --, out ++)
*out = 0xff;
}
if (out - fCurrentLine != fOutRowSize) {
fprintf(stderr, "Error buffer overflow: %d != %d\n", fOutRowSize, (int)(out - fCurrentLine));
}
if (out - fCurrentLine != fOutRowSize)
fprintf(stderr, "Error buffer overflow: %d != %d\n", fOutRowSize,
static_cast<int>(out - fCurrentLine));
}
#ifdef _PCL6_RASTERIZER_TEST_
#include <Application.h>
#include <Bitmap.h>
@@ -309,7 +324,9 @@ ColorRasterizer::MergePlaneBuffersToCurrentLine()
#define COLUMNS 40
#define BIT_COLUMNS 6
static void dump(uchar *buffer, int size)
static void
dump(uchar* buffer, int size)
{
int x = 0;
for (int i = 0; i < size; i ++) {
@@ -328,7 +345,9 @@ static void dump(uchar *buffer, int size)
fprintf(stderr, "\n");
}
static void dump_bits(uchar *buffer, int size)
static void
dump_bits(uchar* buffer, int size)
{
int x = 0;
for (int i = 0; i < size; i ++) {
@@ -354,25 +373,29 @@ static void dump_bits(uchar *buffer, int size)
fprintf(stderr, "\n");
}
static void fill(uchar *_row, int width, ColorRGB32Little color)
static void
fill(uchar* _row, int width, ColorRGB32Little color)
{
ColorRGB32Little *row = (ColorRGB32Little *)_row;
ColorRGB32Little* row = static_cast<ColorRGB32Little*>(_row);
for (int i = 0; i < width; i ++) {
*row = color;
row ++;
}
}
static void initializeBitmap(BBitmap *bitmap, int width, int height)
static void
initializeBitmap(BBitmap* bitmap, int width, int height)
{
int bpr = bitmap->BytesPerRow();
uchar *row = (uchar*)bitmap->Bits();
uchar* row = (uchar*)bitmap->Bits();
// BGRA
ColorRGB32Little black = {0, 0, 0, 0};
ColorRGB32Little white = {255, 255, 255, 0};
ColorRGB32Little red = {0, 0, 255, 0};
ColorRGB32Little red = {0, 0, 255, 0};
ColorRGB32Little green = {0, 255, 0, 0};
ColorRGB32Little blue = {255, 0, 0, 0};
ColorRGB32Little blue = {255, 0, 0, 0};
fprintf(stderr, "black row\n");
fill(row, width, black);
@@ -387,7 +410,7 @@ static void initializeBitmap(BBitmap *bitmap, int width, int height)
row += bpr;
fprintf(stderr, "red green blue pattern");
ColorRGB32Little *color = (ColorRGB32Little*)row;
ColorRGB32Little* color = (ColorRGB32Little*)row;
for (int i = 0; i < width; i++) {
switch (i % 3) {
case 0:
@@ -404,7 +427,9 @@ static void initializeBitmap(BBitmap *bitmap, int width, int height)
}
}
int main()
int
main()
{
const int width = 10;
const int height = 4;
@@ -417,7 +442,7 @@ int main()
Halftone halftone(B_RGB32, 0.25f, 0.0f, Halftone::kTypeFloydSteinberg);
#endif
ColorRasterizer rasterizer(&halftone);
BBitmap bitmap(BRect(0, 0, width-1, height-1), B_RGB32);
BBitmap bitmap(BRect(0, 0, width - 1, height - 1), B_RGB32);
initializeBitmap(&bitmap, width, height);
@@ -428,4 +453,4 @@ int main()
}
}
#endif
#endif // _PCL6_RASTERIZER_TEST_
src/add-ons/print/drivers/pcl6/PCL6Rasterizer.h
+84 -56
View File
@@ -1,111 +1,139 @@
/*
** PCL6Rasterizer.h
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net. All rights reserved.
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net.
** All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/
#ifndef _PCL6_RASTERIZER_H
#define _PCL6_RASTERIZER_H
#include "Rasterizer.h"
class PCL6Rasterizer : public Rasterizer
{
public:
PCL6Rasterizer(Halftone *halftone)
: Rasterizer(halftone)
, fOutBuffer(NULL)
, fOutBufferSize(0)
{
}
PCL6Rasterizer(Halftone* halftone)
:
Rasterizer(halftone),
fOutBuffer(NULL),
fOutBufferSize(0)
{}
~PCL6Rasterizer()
{
delete fOutBuffer;
fOutBuffer = NULL;
}
~PCL6Rasterizer()
{
delete fOutBuffer;
fOutBuffer = NULL;
}
void SetOutBufferSize(int size) { fOutBufferSize = size; }
int GetOutBufferSize() { return fOutBufferSize; }
uchar *GetOutBuffer() { return fOutBuffer; }
void SetOutBufferSize(int size)
{
fOutBufferSize = size;
}
int GetOutBufferSize()
{
return fOutBufferSize;
}
uchar* GetOutBuffer()
{
return fOutBuffer;
}
virtual void InitializeBuffer() {
fOutBuffer = new uchar[fOutBufferSize];
}
virtual void InitializeBuffer()
{
fOutBuffer = new uchar[fOutBufferSize];
}
virtual int GetOutRowSize() = 0;
virtual int GetOutRowSize() = 0;
private:
uchar *fOutBuffer;
int fOutBufferSize;
uchar* fOutBuffer;
int fOutBufferSize;
};
class MonochromeRasterizer : public PCL6Rasterizer
{
public:
MonochromeRasterizer(Halftone *halftone);
MonochromeRasterizer(Halftone* halftone);
void InitializeBuffer();
void InitializeBuffer();
int GetOutRowSize() { return fOutRowSize; }
int GetOutRowSize()
{
return fOutRowSize;
}
const void *RasterizeLine(int x, int y, const ColorRGB32Little* source);
const void* RasterizeLine(int x, int y,
const ColorRGB32Little* source);
private:
int fWidthByte;
int fOutRowSize;
int fPadBytes;
int fOutSize;
uchar *fOutBuffer;
uchar *fCurrentLine;
int fWidthByte;
int fOutRowSize;
int fPadBytes;
int fOutSize;
uchar* fOutBuffer;
uchar* fCurrentLine;
};
// Output format RGB 8bit per channel
class ColorRGBRasterizer : public PCL6Rasterizer
{
public:
ColorRGBRasterizer(Halftone *halftone) ;
ColorRGBRasterizer(Halftone* halftone);
void InitializeBuffer();
void InitializeBuffer();
int GetOutRowSize() { return fOutRowSize; }
int GetOutRowSize()
{
return fOutRowSize;
}
const void *RasterizeLine(int x, int y, const ColorRGB32Little* source);
const void* RasterizeLine(int x, int y,
const ColorRGB32Little* source);
private:
int fWidthByte;
int fOutRowSize;
int fPadBytes;
uchar *fCurrentLine;
int fWidthByte;
int fOutRowSize;
int fPadBytes;
uchar* fCurrentLine;
};
typedef uchar *PlaneBuffer;
typedef uchar* PlaneBuffer;
// Output format: RGB 1bit per channel
// Class Halftone is used for dithering
class ColorRasterizer : public PCL6Rasterizer
{
public:
ColorRasterizer(Halftone *halftone);
ColorRasterizer(Halftone* halftone);
~ColorRasterizer();
~ColorRasterizer();
void InitializeBuffer();
void InitializeBuffer();
int GetOutRowSize() { return fOutRowSize; }
int GetOutRowSize()
{
return fOutRowSize;
}
const void *RasterizeLine(int x, int y, const ColorRGB32Little* source);
const void* RasterizeLine(int x, int y,
const ColorRGB32Little* source);
private:
void MergePlaneBuffersToCurrentLine();
void MergePlaneBuffersToCurrentLine();
int fWidthByte;
int fOutRowSize;
int fPadBytes;
uchar *fCurrentLine;
int fWidthByte;
int fOutRowSize;
int fPadBytes;
uchar* fCurrentLine;
int fPlaneBufferSize;
PlaneBuffer fPlaneBuffers[3];
int fPlaneBufferSize;
PlaneBuffer fPlaneBuffers[3];
};
#endif
#endif // _PCL6_RASTERIZER_H
src/add-ons/print/drivers/pcl6/PCL6Writer.cpp
+150 -63
View File
@@ -1,8 +1,11 @@
/*
** PCL6Writer.cpp
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net. All rights reserved.
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net.
** All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/
#include "PCL6Writer.h"
#include <ByteOrder.h>
@@ -10,53 +13,66 @@
#define BYTE_AT(lvalue, index) (((uint8*)(&lvalue))[index])
PCL6Writer::PCL6Writer(PCL6WriterStream *stream, uint32 bufferSize)
: fStream(stream),
fBuffer(new uint8[bufferSize]),
fSize(bufferSize),
fIndex(0)
PCL6Writer::PCL6Writer(PCL6WriterStream* stream, uint32 bufferSize)
:
fStream(stream),
fBuffer(new uint8[bufferSize]),
fSize(bufferSize),
fIndex(0)
{
}
PCL6Writer::~PCL6Writer() {
PCL6Writer::~PCL6Writer()
{
delete fBuffer;
fBuffer = NULL;
}
// throws TransportException
void
PCL6Writer::Append(uint8 value) {
if (fIndex == fSize) {
PCL6Writer::Append(uint8 value)
{
if (fIndex == fSize)
Flush();
}
fBuffer[fIndex] = value;
fIndex ++;
}
void
PCL6Writer::Flush() {
PCL6Writer::Flush()
{
if (fIndex > 0) {
fStream->write(fBuffer, fIndex);
fIndex = 0;
}
}
void
PCL6Writer::Append(int16 value) {
PCL6Writer::Append(int16 value)
{
int16 v = B_HOST_TO_LENDIAN_INT16(value);
Append(BYTE_AT(v, 0));
Append(BYTE_AT(v, 1));
}
void
PCL6Writer::Append(uint16 value) {
PCL6Writer::Append(uint16 value)
{
int16 v = B_HOST_TO_LENDIAN_INT16(value);
Append(BYTE_AT(v, 0));
Append(BYTE_AT(v, 1));
}
void
PCL6Writer::Append(int32 value) {
PCL6Writer::Append(int32 value)
{
int32 v = B_HOST_TO_LENDIAN_INT32(value);
Append(BYTE_AT(v, 0));
Append(BYTE_AT(v, 1));
@@ -64,8 +80,10 @@ PCL6Writer::Append(int32 value) {
Append(BYTE_AT(v, 3));
}
void
PCL6Writer::Append(uint32 value) {
PCL6Writer::Append(uint32 value)
{
int32 v = B_HOST_TO_LENDIAN_INT32(value);
Append(BYTE_AT(v, 0));
Append(BYTE_AT(v, 1));
@@ -73,8 +91,10 @@ PCL6Writer::Append(uint32 value) {
Append(BYTE_AT(v, 3));
}
void
PCL6Writer::Append(float value) {
PCL6Writer::Append(float value)
{
float v = B_HOST_TO_LENDIAN_FLOAT(value);
Append(BYTE_AT(v, 0));
Append(BYTE_AT(v, 1));
@@ -82,8 +102,10 @@ PCL6Writer::Append(float value) {
Append(BYTE_AT(v, 3));
}
void
PCL6Writer::Append(const uint8* data, uint32 size) {
PCL6Writer::Append(const uint8* data, uint32 size)
{
for (uint32 i = 0; i < size; i++) {
Append(data[i]);
}
@@ -91,7 +113,8 @@ PCL6Writer::Append(const uint8* data, uint32 size) {
void
PCL6Writer::AppendString(const char *string) {
PCL6Writer::AppendString(const char* string)
{
uint8 ch = *string;
while (ch != 0) {
Append(ch);
@@ -100,60 +123,80 @@ PCL6Writer::AppendString(const char *string) {
}
}
void
PCL6Writer::AppendOperator(Operator op) {
PCL6Writer::AppendOperator(Operator op)
{
Append((uint8)op);
}
void
PCL6Writer::AppendAttribute(Attribute attr) {
PCL6Writer::AppendAttribute(Attribute attr)
{
AppendDataTag(k8BitAttrId);
Append((uint8)attr);
}
void
PCL6Writer::AppendDataTag(DataTag tag) {
PCL6Writer::AppendDataTag(DataTag tag)
{
Append((uint8)tag);
}
void
PCL6Writer::AppendData(uint8 value) {
PCL6Writer::AppendData(uint8 value)
{
AppendDataTag(kUByteData);
Append(value);
}
void
PCL6Writer::AppendData(int16 value) {
PCL6Writer::AppendData(int16 value)
{
AppendDataTag(kSInt16Data);
Append(value);
}
void
PCL6Writer::AppendData(uint16 value) {
PCL6Writer::AppendData(uint16 value)
{
AppendDataTag(kUInt16Data);
Append(value);
}
void
PCL6Writer::AppendData(int32 value) {
PCL6Writer::AppendData(int32 value)
{
AppendDataTag(kSInt32Data);
Append(value);
}
void
PCL6Writer::AppendData(uint32 value) {
PCL6Writer::AppendData(uint32 value)
{
AppendDataTag(kUInt32Data);
Append(value);
}
void
PCL6Writer::AppendData(float value) {
PCL6Writer::AppendData(float value)
{
AppendDataTag(kReal32Data);
Append(value);
}
void
PCL6Writer::EmbeddedDataPrefix(uint32 size) {
PCL6Writer::EmbeddedDataPrefix(uint32 size)
{
if (size < 256) {
AppendDataTag(kEmbeddedDataByte);
Append((uint8)size);
@@ -163,60 +206,72 @@ PCL6Writer::EmbeddedDataPrefix(uint32 size) {
}
}
void
PCL6Writer::EmbeddedDataPrefix32(uint32 size) {
PCL6Writer::EmbeddedDataPrefix32(uint32 size)
{
AppendDataTag(kEmbeddedData);
Append(size);
}
void
PCL6Writer::AppendDataXY(uint8 x, uint8 y) {
PCL6Writer::AppendDataXY(uint8 x, uint8 y)
{
AppendDataTag(kUByteXY);
Append(x); Append(y);
}
void
PCL6Writer::AppendDataXY(int16 x, int16 y) {
PCL6Writer::AppendDataXY(int16 x, int16 y)
{
AppendDataTag(kSInt16XY);
Append(x); Append(y);
}
void
PCL6Writer::AppendDataXY(uint16 x, uint16 y) {
PCL6Writer::AppendDataXY(uint16 x, uint16 y)
{
AppendDataTag(kUInt16XY);
Append(x); Append(y);
}
void
PCL6Writer::AppendDataXY(int32 x, int32 y) {
PCL6Writer::AppendDataXY(int32 x, int32 y)
{
AppendDataTag(kSInt32XY);
Append(x); Append(y);
}
void
PCL6Writer::AppendDataXY(uint32 x, uint32 y) {
PCL6Writer::AppendDataXY(uint32 x, uint32 y)
{
AppendDataTag(kUInt32XY);
Append(x); Append(y);
}
void
PCL6Writer::AppendDataXY(float x, float y) {
PCL6Writer::AppendDataXY(float x, float y)
{
AppendDataTag(kReal32XY);
Append(x); Append(y);
}
void
PCL6Writer::PJLHeader(ProtocolClass protocolClass, int dpi, const char *comment)
PCL6Writer::PJLHeader(ProtocolClass protocolClass, int dpi, const char* comment)
{
BString string;
AppendString("\033%-12345X@PJL JOB\n"
"@PJL SET RESOLUTION=");
AppendString("\033%-12345X@PJL JOB\n@PJL SET RESOLUTION=");
string << dpi;
AppendString(string.String());
AppendString("\n"
"@PJL ENTER LANGUAGE=PCLXL\n"
") HP-PCL XL;");
AppendString("\n@PJL ENTER LANGUAGE=PCLXL\n) HP-PCL XL;");
const char* pc = "";
switch (protocolClass) {
case kProtocolClass1_1:
@@ -242,16 +297,18 @@ PCL6Writer::PJLHeader(ProtocolClass protocolClass, int dpi, const char *comment)
AppendString("\n");
}
void
PCL6Writer::PJLFooter()
{
AppendString("\033%-12345X@PJL EOJ\n"
"\033%-12345X");
AppendString("\033%-12345X@PJL EOJ\n\033%-12345X");
}
void
PCL6Writer::BeginSession(uint16 xres, uint16 yres, UnitOfMeasure unitOfMeasure, ErrorReporting errorReporting) {
PCL6Writer::BeginSession(uint16 xres, uint16 yres, UnitOfMeasure unitOfMeasure,
ErrorReporting errorReporting)
{
AppendDataXY(xres, yres);
AppendAttribute(kUnitsPerMeasure);
@@ -264,13 +321,17 @@ PCL6Writer::BeginSession(uint16 xres, uint16 yres, UnitOfMeasure unitOfMeasure,
AppendOperator(kBeginSession);
}
void
PCL6Writer::EndSession() {
PCL6Writer::EndSession()
{
AppendOperator(kEndSession);
}
void
PCL6Writer::OpenDataSource() {
PCL6Writer::OpenDataSource()
{
AppendData((uint8)kDefaultDataSource);
AppendAttribute(kSourceType);
@@ -280,14 +341,18 @@ PCL6Writer::OpenDataSource() {
AppendOperator(kOpenDataSource);
}
void
PCL6Writer::CloseDataSource() {
PCL6Writer::CloseDataSource()
{
AppendOperator(kCloseDataSource);
}
void
PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource) {
PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize,
MediaSource mediaSource)
{
AppendData((uint8)orientation);
AppendAttribute(kOrientation);
@@ -300,8 +365,11 @@ PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource
AppendOperator(kBeginPage);
}
void
PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource, DuplexPageMode duplexPageMode, MediaSide mediaSide) {
PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize,
MediaSource mediaSource, DuplexPageMode duplexPageMode, MediaSide mediaSide)
{
AppendData((uint8)orientation);
AppendAttribute(kOrientation);
@@ -320,8 +388,10 @@ PCL6Writer::BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource
AppendOperator(kBeginPage);
}
void
PCL6Writer::EndPage(uint16 copies) {
PCL6Writer::EndPage(uint16 copies)
{
// if (copies != 1) {
AppendData(copies);
AppendAttribute(kPageCopies);
@@ -332,47 +402,58 @@ PCL6Writer::EndPage(uint16 copies) {
void
PCL6Writer::SetPageOrigin(int16 x, int16 y) {
PCL6Writer::SetPageOrigin(int16 x, int16 y)
{
AppendDataXY(x, y);
AppendAttribute(kPageOrigin);
AppendOperator(kSetPageOrigin);
}
void
PCL6Writer::SetColorSpace(ColorSpace colorSpace) {
PCL6Writer::SetColorSpace(ColorSpace colorSpace)
{
AppendData((uint8)colorSpace);
AppendAttribute(kColorSpace);
AppendOperator(kSetColorSpace);
}
void
PCL6Writer::SetPaintTxMode(Transparency transparency) {
PCL6Writer::SetPaintTxMode(Transparency transparency)
{
AppendData((uint8)transparency);
AppendAttribute(kTxMode);
AppendOperator(kSetPaintTxMode);
}
void
PCL6Writer::SetSourceTxMode(Transparency transparency) {
PCL6Writer::SetSourceTxMode(Transparency transparency)
{
AppendData((uint8)transparency);
AppendAttribute(kTxMode);
AppendOperator(kSetSourceTxMode);
}
void
PCL6Writer::SetROP(uint8 rop) {
PCL6Writer::SetROP(uint8 rop)
{
AppendData((uint8)rop);
AppendAttribute(kROP3);
AppendOperator(kSetROP);
}
void
PCL6Writer::SetCursor(int16 x, int16 y) {
PCL6Writer::SetCursor(int16 x, int16 y)
{
AppendDataXY(x, y);
AppendAttribute(kPoint);
@@ -380,8 +461,11 @@ PCL6Writer::SetCursor(int16 x, int16 y) {
}
void
PCL6Writer::BeginImage(ColorMapping colorMapping, ColorDepth colorDepth, uint16 sourceWidth, uint16 sourceHeight, uint16 destWidth, uint16 destHeight) {
void
PCL6Writer::BeginImage(ColorMapping colorMapping, ColorDepth colorDepth,
uint16 sourceWidth, uint16 sourceHeight, uint16 destWidth,
uint16 destHeight)
{
AppendData((uint8)colorMapping);
AppendAttribute(kColorMapping);
@@ -400,8 +484,11 @@ PCL6Writer::BeginImage(ColorMapping colorMapping, ColorDepth colorDepth, uint16
AppendOperator(kBeginImage);
}
void
PCL6Writer::ReadImage(Compression compression, uint16 startLine, uint16 blockHeight, uint8 padBytes) {
PCL6Writer::ReadImage(Compression compression, uint16 startLine,
uint16 blockHeight, uint8 padBytes)
{
AppendData(startLine);
AppendAttribute(kStartLine);
@@ -423,9 +510,9 @@ PCL6Writer::ReadImage(Compression compression, uint16 startLine, uint16 blockHei
AppendOperator(kReadImage);
}
void
PCL6Writer::EndImage() {
PCL6Writer::EndImage()
{
AppendOperator(kEndImage);
}
src/add-ons/print/drivers/pcl6/PCL6Writer.h
+301 -287
View File
@@ -1,362 +1,376 @@
/*
** PCL6Writer.h
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net. All rights reserved.
** Copyright 2005, Michael Pfeiffer, laplace@users.sourceforge.net.
** All rights reserved.
** Distributed under the terms of the OpenBeOS License.
*/
#ifndef _PCL6_WRITER_H
#define _PCL6_WRITER_H
#include <SupportDefs.h>
class PCL6Driver;
class PCL6WriterStream {
public:
virtual ~PCL6WriterStream() {}
virtual void write(const uint8 *data, uint32 size) = 0;
virtual ~PCL6WriterStream() {}
virtual void write(const uint8* data, uint32 size) = 0;
};
class PCL6Writer {
public:
// DO NOT change this enumerations the order is important!!!
enum Orientation {
kPortrait,
kLandscape,
kReversePortrait,
kReverseLandscape
};
enum Orientation {
kPortrait,
kLandscape,
kReversePortrait,
kReverseLandscape
};
enum MediaSize {
kLetterPaper,
kLegalPaper,
kA4Paper,
kExecPaper,
kLedgerPaper,
kA3Paper,
kCOM10Envelope,
kMonarchEnvelope,
kC5Envelope,
kDLEnvelope,
kJB4Paper,
kJB5Paper,
kB5Envelope,
kB5Paper,
kJPostcard,
kJDoublePostcard,
kA5Paper,
kA6Paper,
kJB6Paper,
kJIS8KPaper,
kJIS16KPaper,
kJISExecPaper
};
enum MediaSize {
kLetterPaper,
kLegalPaper,
kA4Paper,
kExecPaper,
kLedgerPaper,
kA3Paper,
kCOM10Envelope,
kMonarchEnvelope,
kC5Envelope,
kDLEnvelope,
kJB4Paper,
kJB5Paper,
kB5Envelope,
kB5Paper,
kJPostcard,
kJDoublePostcard,
kA5Paper,
kA6Paper,
kJB6Paper,
kJIS8KPaper,
kJIS16KPaper,
kJISExecPaper
};
enum MediaSource {
kDefaultSource,
kAutoSelect,
kManualFeed,
kMultiPurposeTray,
kUpperCassette,
kLowerCassette,
kEnvelopeTray,
kThirdCassette
};
enum MediaSource {
kDefaultSource,
kAutoSelect,
kManualFeed,
kMultiPurposeTray,
kUpperCassette,
kLowerCassette,
kEnvelopeTray,
kThirdCassette
};
enum Compression {
kNoCompression,
kRLECompression,
kJPEGCompression,
kDeltaRowCompression
};
enum Compression {
kNoCompression,
kRLECompression,
kJPEGCompression,
kDeltaRowCompression
};
enum ColorSpace {
kBiLevel,
kGray,
kRGB,
kCMY,
kCIELab,
kCRGB,
kSRGB
};
enum ColorSpace {
kBiLevel,
kGray,
kRGB,
kCMY,
kCIELab,
kCRGB,
kSRGB
};
enum ColorDepth {
k1Bit,
k4Bit,
k8Bit
};
enum ColorDepth {
k1Bit,
k4Bit,
k8Bit
};
enum ColorMapping {
kDirectPixel,
kIndexedPixel,
kDirectPlane
};
enum ColorMapping {
kDirectPixel,
kIndexedPixel,
kDirectPlane
};
enum Transparency {
kOpaque,
kTransparent
};
enum Transparency {
kOpaque,
kTransparent
};
enum DuplexPageMode {
kDuplexHorizontalBinding,
kDuplexVerticalBinding
};
enum DuplexPageMode {
kDuplexHorizontalBinding,
kDuplexVerticalBinding
};
enum MediaSide {
kFrontMediaSide,
kBackMediaSide
};
enum MediaSide {
kFrontMediaSide,
kBackMediaSide
};
enum SimplexPageMode {
kSimplexFrontSide
};
enum SimplexPageMode {
kSimplexFrontSide
};
enum UnitOfMeasure {
kInch,
kMillimeter,
kTenthsOfAMillimeter
};
enum UnitOfMeasure {
kInch,
kMillimeter,
kTenthsOfAMillimeter
};
enum ErrorReporting {
kNoReporting,
kBackChannel,
kErrorPage,
kBackChAndErrPage,
kNWBackChannel,
kNWErrorPage,
kNWBackChAndErrPage
};
enum ErrorReporting {
kNoReporting,
kBackChannel,
kErrorPage,
kBackChAndErrPage,
kNWBackChannel,
kNWErrorPage,
kNWBackChAndErrPage
};
enum Enable {
kOn,
kOff
};
enum Enable {
kOn,
kOff
};
enum Boolean {
kFalse,
kTrue
};
enum Boolean {
kFalse,
kTrue
};
enum ProtocolClass {
kProtocolClass1_1,
kProtocolClass2_0,
kProtocolClass2_1,
kProtocolClass3_0,
};
enum ProtocolClass {
kProtocolClass1_1,
kProtocolClass2_0,
kProtocolClass2_1,
kProtocolClass3_0,
};
PCL6Writer(PCL6WriterStream* stream, uint32 bufferSize = 16 * 1024);
virtual ~PCL6Writer();
PCL6Writer(PCL6WriterStream* stream,
uint32 bufferSize = 16 * 1024);
virtual ~PCL6Writer();
// these methods throw TransportException if data could not
// be written
void Flush();
void Flush();
void PJLHeader(ProtocolClass protocolClass, int dpi, const char *comment = NULL);
void PJLFooter();
void PJLHeader(ProtocolClass protocolClass, int dpi,
const char* comment = NULL);
void PJLFooter();
void BeginSession(uint16 xres, uint16 yres, UnitOfMeasure unitOfMeasure, ErrorReporting errorReporting);
void EndSession();
void BeginSession(uint16 xres, uint16 yres,
UnitOfMeasure unitOfMeasure,
ErrorReporting errorReporting);
void EndSession();
void OpenDataSource();
void CloseDataSource();
void OpenDataSource();
void CloseDataSource();
void BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource);
void BeginPage(Orientation orientation, MediaSize mediaSize, MediaSource mediaSource, DuplexPageMode duplexPageMode, MediaSide mediaSide);
void EndPage(uint16 copies);
void BeginPage(Orientation orientation, MediaSize mediaSize,
MediaSource mediaSource);
void BeginPage(Orientation orientation, MediaSize mediaSize,
MediaSource mediaSource, DuplexPageMode duplexPageMode,
MediaSide mediaSide);
void EndPage(uint16 copies);
void SetPageOrigin(int16 x, int16 y);
void SetColorSpace(ColorSpace colorSpace);
void SetPaintTxMode(Transparency transparency);
void SetSourceTxMode(Transparency transparency);
void SetROP(uint8 rop);
void SetCursor(int16 x, int16 y);
void SetPageOrigin(int16 x, int16 y);
void SetColorSpace(ColorSpace colorSpace);
void SetPaintTxMode(Transparency transparency);
void SetSourceTxMode(Transparency transparency);
void SetROP(uint8 rop);
void SetCursor(int16 x, int16 y);
void BeginImage(ColorMapping colorMapping, ColorDepth colorDepth, uint16 sourceWidth, uint16 sourceHeight, uint16 destWidth, uint16 destHeight);
void ReadImage(Compression compression, uint16 startLine, uint16 blockHeight, uint8 padBytes = 4);
void EndImage();
void EmbeddedDataPrefix(uint32 size);
void EmbeddedDataPrefix32(uint32 size);
void BeginImage(ColorMapping colorMapping, ColorDepth colorDepth,
uint16 sourceWidth, uint16 sourceHeight,
uint16 destWidth, uint16 destHeight);
void ReadImage(Compression compression, uint16 startLine,
uint16 blockHeight, uint8 padBytes = 4);
void EndImage();
void EmbeddedDataPrefix(uint32 size);
void EmbeddedDataPrefix32(uint32 size);
void Append(uint8 value);
void Append(int16 value);
void Append(uint16 value);
void Append(int32 value);
void Append(uint32 value);
void Append(float value);
void Append(const uint8* data, uint32 size);
void Append(uint8 value);
void Append(int16 value);
void Append(uint16 value);
void Append(int32 value);
void Append(uint32 value);
void Append(float value);
void Append(const uint8* data, uint32 size);
void AppendData(uint8 value);
void AppendData(int16 value);
void AppendData(uint16 value);
void AppendData(int32 value);
void AppendData(uint32 value);
void AppendData(float value);
void AppendData(uint8 value);
void AppendData(int16 value);
void AppendData(uint16 value);
void AppendData(int32 value);
void AppendData(uint32 value);
void AppendData(float value);
void AppendDataXY(uint8 x, uint8 y);
void AppendDataXY(int16 x, int16 y);
void AppendDataXY(uint16 x, uint16 y);
void AppendDataXY(int32 x, int32 y);
void AppendDataXY(uint32 x, uint32 y);
void AppendDataXY(float x, float y);
void AppendDataXY(uint8 x, uint8 y);
void AppendDataXY(int16 x, int16 y);
void AppendDataXY(uint16 x, uint16 y);
void AppendDataXY(int32 x, int32 y);
void AppendDataXY(uint32 x, uint32 y);
void AppendDataXY(float x, float y);
private:
enum Operator {
kBeginSession = 0x41,
kEndSession,
kBeginPage,
kEndPage,
kVendorUnique = 0x46,
kComment,
kOpenDataSource,
kCloseDataSource,
kEchoComment,
kQuery,
kDiagnostic3,
kBeginStream = 0x5b,
kReadStream,
kEndStream,
kSetColorSpace = 0x6a,
kSetCursor,
kSetPageOrigin = 0x75,
kSetPageRotation,
kSetPageScale,
kSetPaintTxMode,
kSetPenSource,
kSetPenWidth,
kSetROP,
kSetSourceTxMode,
enum Operator {
kBeginSession = 0x41,
kEndSession,
kBeginPage,
kEndPage,
kBeginImage = 0xb0,
kReadImage,
kEndImage,
};
kVendorUnique = 0x46,
kComment,
kOpenDataSource,
kCloseDataSource,
kEchoComment,
kQuery,
kDiagnostic3,
kBeginStream = 0x5b,
kReadStream,
kEndStream,
kSetColorSpace = 0x6a,
kSetCursor,
kSetPageOrigin = 0x75,
kSetPageRotation,
kSetPageScale,
kSetPaintTxMode,
kSetPenSource,
kSetPenWidth,
kSetROP,
kSetSourceTxMode,
kBeginImage = 0xb0,
kReadImage,
kEndImage,
};
enum DataTag {
kUByteData = 0xc0,
kUInt16Data,
kUInt32Data,
kSInt16Data,
kSInt32Data,
kReal32Data,
enum DataTag {
kUByteData = 0xc0,
kUInt16Data,
kUInt32Data,
kSInt16Data,
kSInt32Data,
kReal32Data,
kString = 0xc7,
kUByteArray,
kUInt16Array,
kUInt32Array,
kSInt16Array,
kSInt32Array,
kReal32Array,
kString = 0xc7,
kUByteArray,
kUInt16Array,
kUInt32Array,
kSInt16Array,
kSInt32Array,
kReal32Array,
kUByteXY = 0xd0,
kUInt16XY,
kUInt32XY,
kSInt16XY,
kSInt32XY,
kReal32XY,
kUByteXY = 0xd0,
kUInt16XY,
kUInt32XY,
kSInt16XY,
kSInt32XY,
kReal32XY,
kUByteBox = 0xe0,
kUInt16Box,
kUInt32Box,
kSInt16Box,
kSInt32Box,
kReal32Box,
kUByteBox = 0xe0,
kUInt16Box,
kUInt32Box,
kSInt16Box,
kSInt32Box,
kReal32Box,
k8BitAttrId = 0xf8,
k8BitAttrId = 0xf8,
kEmbeddedData = 0xfa,
kEmbeddedDataByte,
};
kEmbeddedData = 0xfa,
kEmbeddedDataByte,
};
enum DataType {
kUByte,
kSByte,
kUInt16,
kSInt16,
kReal32
};
enum DataType {
kUByte,
kSByte,
kUInt16,
kSInt16,
kReal32
};
enum Attribute {
kCMYColor = 1,
kPaletteDepth,
kColorSpace,
enum Attribute {
kCMYColor = 1,
kPaletteDepth,
kColorSpace,
kRGBColor = 11,
kRGBColor = 11,
kMediaDest = 36,
kMediaSize,
kMediaSource,
kMediaType,
kOrientation,
kPageAngle,
kPageOrigin,
kPageScale,
kROP3,
kTxMode,
kMediaDest = 36,
kMediaSize,
kMediaSource,
kMediaType,
kOrientation,
kPageAngle,
kPageOrigin,
kPageScale,
kROP3,
kTxMode,
kCustomMediaSize = 47,
kCustomMediaSizeUnits,
kPageCopies,
kDitherMatrixSize,
kDitherMatrixDepth,
kSimplexPageMode,
kDuplexPageMode,
kDuplexPageSide,
kCustomMediaSize = 47,
kCustomMediaSizeUnits,
kPageCopies,
kDitherMatrixSize,
kDitherMatrixDepth,
kSimplexPageMode,
kDuplexPageMode,
kDuplexPageSide,
kPoint = 76,
kPoint = 76,
kColorDepth = 98,
kBlockHeight,
kColorMapping,
kCompressMode,
kDestinationBox,
kDestinationSize,
kColorDepth = 98,
kBlockHeight,
kColorMapping,
kCompressMode,
kDestinationBox,
kDestinationSize,
kSourceHeight = 107,
kSourceWidth,
kStartLine,
kPadBytesMultiple,
kBlockByteLength,
kSourceHeight = 107,
kSourceWidth,
kStartLine,
kPadBytesMultiple,
kBlockByteLength,
kNumberOfScanLines = 115,
kNumberOfScanLines = 115,
kDataOrg = 130,
kMeasure = 134,
kDataOrg = 130,
kMeasure = 134,
kSourceType = 136,
kUnitsPerMeasure,
kQueryKey,
kStreamName,
kStreamDataLength,
kSourceType = 136,
kUnitsPerMeasure,
kQueryKey,
kStreamName,
kStreamDataLength,
kErrorReport = 143,
kIOReadTimeOut,
kErrorReport = 143,
kIOReadTimeOut,
kWritingMode = 173
};
kWritingMode = 173
};
enum DataSource {
kDefaultDataSource
};
enum DataSource {
kDefaultDataSource
};
enum DataOrganization {
kBinaryHighByteFirst,
kBinaryLowByteFirst
};
enum DataOrganization {
kBinaryHighByteFirst,
kBinaryLowByteFirst
};
void AppendString(const char* string);
void AppendOperator(Operator op);
void AppendAttribute(Attribute attr);
void AppendDataTag(DataTag tag);
void AppendString(const char* string);
void AppendOperator(Operator op);
void AppendAttribute(Attribute attr);
void AppendDataTag(DataTag tag);
PCL6WriterStream *fStream; // the stream used for writing the generated PCL6 data
uint8 *fBuffer; // the buffer
uint32 fSize; // the size of the buffer
uint32 fIndex; // the index of the next byte to be written
PCL6WriterStream* fStream;
// the stream used for writing the generated PCL6 data
uint8* fBuffer; // the buffer
uint32 fSize; // the size of the buffer
uint32 fIndex; // the index of the next byte to be written
};
#endif
#endif // _PCL6_WRITER_H
src/add-ons/print/drivers/pcl6/Rasterizer.cpp
+17 -13
View File
@@ -2,28 +2,32 @@
#include <stdio.h>
Rasterizer::Rasterizer(Halftone* halftone)
: fHalftone(halftone)
, fIndex(-1)
:
fHalftone(halftone),
fIndex(-1)
{
fBounds.bottom = -2;
}
Rasterizer::~Rasterizer()
{
}
bool
Rasterizer::SetBitmap(int x, int y, BBitmap *bitmap, int pageHeight)
Rasterizer::SetBitmap(int x, int y, BBitmap* bitmap, int pageHeight)
{
fX = x;
fY = y;
BRect bounds = bitmap->Bounds();
fBounds.left = (int)bounds.left;
fBounds.top = (int)bounds.top;
fBounds.right = (int)bounds.right;
fBounds.left = (int)bounds.left;
fBounds.top = (int)bounds.top;
fBounds.right = (int)bounds.right;
fBounds.bottom = (int)bounds.bottom;
int height = fBounds.bottom - fBounds.top + 1;
@@ -33,9 +37,8 @@ Rasterizer::SetBitmap(int x, int y, BBitmap *bitmap, int pageHeight)
fBounds.bottom = fBounds.top + height - 1;
}
if (!get_valid_rect(bitmap, &fBounds)) {
if (!get_valid_rect(bitmap, &fBounds))
return false;
}
fWidth = fBounds.right - fBounds.left + 1;
fHeight = fBounds.bottom - fBounds.top + 1;
@@ -52,20 +55,21 @@ Rasterizer::SetBitmap(int x, int y, BBitmap *bitmap, int pageHeight)
return true;
}
bool
Rasterizer::HasNextLine()
{
return fIndex <= fBounds.bottom;
}
const void*
Rasterizer::RasterizeNextLine()
{
if (!HasNextLine()) {
if (!HasNextLine())
return NULL;
}
const void *result;
const void* result;
result = RasterizeLine(fX, fY, (const ColorRGB32Little*)fBits);
fBits += fBPR;
fY ++;
@@ -73,10 +77,10 @@ Rasterizer::RasterizeNextLine()
return result;
}
void
Rasterizer::RasterizeBitmap()
{
while (HasNextLine()) {
while (HasNextLine())
RasterizeNextLine();
}
}
src/add-ons/print/drivers/pcl6/Rasterizer.h
+61 -35
View File
@@ -1,74 +1,100 @@
#ifndef _RASTERIZER_H
#define _RASTERIZER_H
#include <Bitmap.h>
#include "Halftone.h"
#include "ValidRect.h"
#include <Bitmap.h>
//
class Rasterizer {
public:
Rasterizer(Halftone *halftone);
virtual ~Rasterizer();
Rasterizer(Halftone* halftone);
virtual ~Rasterizer();
/**
* Sets the bitmap to be rasterized
* Either the iterator methods HasNextLine() and RasterizeNextLine()
* can be used to rasterize the bitmap line per line or the method RasterizeBitamp()
* can be used to rasterize the bitmap line per line or the method
* RasterizeBitamp()
* can be used to rasterize the entire bitmap at once.
* @param x the x position of the image on the page.
* @param y the y position of the image on the page.
* @param bitmap the bitamp to be rasterized.
* @param height the page height.
* @return true if the bitmap is not empty and false if the bitmap is empty.
* @return true if the bitmap is not empty and false if the bitmap is
* empty.
*/
bool SetBitmap(int x, int y, BBitmap *bitmap, int pageHeight);
bool SetBitmap(int x, int y, BBitmap* bitmap,
int pageHeight);
// Is there a next line?
bool HasNextLine();
bool HasNextLine();
// Rasterizes the next line and returns the line.
const void *RasterizeNextLine();
const void* RasterizeNextLine();
// Iterates over all lines.
void RasterizeBitmap();
void RasterizeBitmap();
// Returns the Halftone object specified in the constructor
Halftone *GetHalftone() { return fHalftone; }
Halftone* GetHalftone()
{
return fHalftone;
}
// The bounds of the bitmap to be rasterized
RECT GetBounds() { return fBounds; }
RECT GetBounds()
{
return fBounds;
}
// The width (in pixels) of the bounds passed to Rasterized()
int GetWidth() { return fWidth; }
int GetWidth()
{
return fWidth;
}
// The height (in pixels) of the bounds passed to Rasterize()
int GetHeight() { return fHeight; }
int GetHeight()
{
return fHeight;
}
// Returns the current x position
int GetX() { return fX; }
int GetX()
{
return fX;
}
// Returns the current y position
int GetY() { return fY; }
int GetY()
{
return fY;
}
// The method is called for each line in the bitmap.
virtual const void *RasterizeLine(int x, int y, const ColorRGB32Little* source) = 0;
virtual const void* RasterizeLine(int x, int y,
const ColorRGB32Little* source) = 0;
// Returns the number of bytes to store widthInPixels pixels with BPP = bitsPerPixel
// and padBytes number of pad bytes.
static int RowBufferSize(int widthInPixels, int bitsPerPixel, int padBytes = 1) {
int sizeInBytes = (widthInPixels * bitsPerPixel + 7) / 8;
return padBytes * ((sizeInBytes + padBytes - 1) / padBytes);
}
// Returns the number of bytes to store widthInPixels pixels with
// BPP = bitsPerPixel and padBytes number of pad bytes.
static int RowBufferSize(int widthInPixels, int bitsPerPixel,
int padBytes = 1)
{
int sizeInBytes = (widthInPixels * bitsPerPixel + 7)
/ 8;
return padBytes * ((sizeInBytes + padBytes - 1)
/ padBytes);
}
private:
Halftone *fHalftone;
Halftone* fHalftone;
RECT fBounds;
int fWidth;
int fHeight;
int fX;
int fY;
const uchar *fBits;
int fBPR;
int fIndex;
RECT fBounds;
int fWidth;
int fHeight;
int fX;
int fY;
const uchar* fBits;
int fBPR;
int fIndex;
};
#endif
#endif // _RASTERIZER_H