xref: /haiku/src/add-ons/print/drivers/pcl6/PCL6.cpp (revision 9c8f4ac5d6ca3899b09fc889cb5fa5c7f21d82e2)

/*
 * PCL6.cpp
 * Copyright 1999-2000 Y.Takagi. All Rights Reserved.
 * Copyright 2003 Michael Pfeiffer.
 */


#include "PCL6.h"

#include <memory.h>

#include <Alert.h>
#include <Bitmap.h>
#include <File.h>

#include "DbgMsg.h"
#include "DeltaRowCompression.h"
#include "Halftone.h"
#include "JobData.h"
#include "PackBits.h"
#include "PCL6Cap.h"
#include "PCL6Config.h"
#include "PCL6Rasterizer.h"
#include "PrinterData.h"
#include "UIDriver.h"
#include "ValidRect.h"


// 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)
				{}

protected:
	void		AppendByteToDeltaRow(uchar byte)
				{
					fWriter->Append(byte);
				}

private:
	PCL6Writer*	fWriter;
};


PCL6Driver::PCL6Driver(BMessage* message, PrinterData* printerData,
	const PrinterCap* printerCap)
	:
	GraphicsDriver(message, printerData, printerCap),
	fWriter(NULL),
	fMediaSide(PCL6Writer::kFrontMediaSide),
	fHalftone(NULL)
{
}


void
PCL6Driver::Write(const uint8* data, uint32 size)
{
	WriteSpoolData(data, size);
}


bool
PCL6Driver::StartDocument()
{
	try {
		_JobStart();
		fHalftone = new Halftone(GetJobData()->GetSurfaceType(),
			GetJobData()->GetGamma(), GetJobData()->GetInkDensity(),
			GetJobData()->GetDitherType());
		return true;
	}
	catch (TransportException& err) {
		return false;
	}
}


bool
PCL6Driver::EndDocument(bool)
{
	try {
		if (fHalftone)
			delete fHalftone;
		_JobEnd();
		return true;
	}
	catch (TransportException& err) {
		return false;
	}
}


bool
PCL6Driver::NextBand(BBitmap* bitmap, BPoint* offset)
{
	DBGMSG(("> nextBand\n"));

#if __GNUC__ <= 2
	typedef auto_ptr<Rasterizer> RasterizerPointer;
	typedef auto_ptr<DeltaRowCompressor> DeltaRowCompressorPointer;
#else
	typedef shared_ptr<Rasterizer> RasterizerPointer;
	typedef shared_ptr<DeltaRowCompressor> DeltaRowCompressorPointer;
#endif

	try {
		int y = (int)offset->y;

		PCL6Rasterizer* rasterizer;
		if (_UseColorMode()) {
			#if COLOR_DEPTH == 8
				rasterizer = new ColorRGBRasterizer(fHalftone);
			#elif COLOR_DEPTH == 1
				rasterizer = new ColorRasterizer(fHalftone);
			#else
				#error COLOR_DEPTH must be either 1 or 8!
			#endif
		} else
			rasterizer = new MonochromeRasterizer(fHalftone);

		RasterizerPointer _rasterizer(rasterizer);
		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;
			if (_SupportsDeltaRowCompression()) {
				deltaRowCompressor =
					new DeltaRowCompressor(rasterizer->GetOutRowSize(), 0);
				if (deltaRowCompressor->InitCheck() != B_OK) {
					delete deltaRowCompressor;
					return false;
				}
			}
			DeltaRowCompressorPointer _deltaRowCompressor(deltaRowCompressor);
			int deltaRowSize = 0;

			// remember position
			int xPage = rasterizer->GetX();
			int yPage = rasterizer->GetY();

			while (rasterizer->HasNextLine()) {
				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
				}
			}

			y = rasterizer->GetY();

			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);
		}

		if (y >= GetPageHeight()) {
			offset->x = -1.0;
			offset->y = -1.0;
		} else {
			offset->y += bitmap->Bounds().IntegerHeight()+1;
		}

		return true;
	}
	catch (TransportException& err) {
		BAlert* alert = new BAlert("", err.What(), "OK");
		alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
		alert->Go();
		return false;
	}
}


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;
	int dataSize = outSize;

#if ENABLE_DELTA_ROW_COMPRESSION
	if (_SupportsDeltaRowCompression() && deltaRowSize < dataSize) {
		compressionMethod = PCL6Writer::kDeltaRowCompression;
		dataSize = deltaRowSize;
	}
#endif

#if ENABLE_RLE_COMPRESSION
	if (_SupportsRLECompression()) {
		int rleSize = pack_bits_size(buffer, outSize);
		if (rleSize < dataSize) {
			compressionMethod = PCL6Writer::kRLECompression;
			dataSize = rleSize;
		}
	}
#endif

	// write bitmap
	_Move(x, y);

	_StartRasterGraphics(x, y, width, 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);
#endif
#if ENABLE_DELTA_ROW_COMPRESSION
	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);
#endif
}


void
PCL6Driver::_JobStart()
{
	// PCL6 begin
	fWriter = new PCL6Writer(this);
	PCL6Writer::ProtocolClass pc =
		(PCL6Writer::ProtocolClass)GetProtocolClass();
	fWriter->PJLHeader(pc, GetJobData()->GetXres(),
		"Copyright (c) 2003 - 2010 Haiku");
	fWriter->BeginSession(GetJobData()->GetXres(), GetJobData()->GetYres(),
		PCL6Writer::kInch, PCL6Writer::kBackChAndErrPage);
	fWriter->OpenDataSource();
	fMediaSide = PCL6Writer::kFrontMediaSide;
}


bool
PCL6Driver::StartPage(int)
{
	PCL6Writer::Orientation orientation = PCL6Writer::kPortrait;
	if (GetJobData()->GetOrientation() == JobData::kLandscape) {
		orientation = PCL6Writer::kLandscape;
	}

	PCL6Writer::MediaSize mediaSize =
		_MediaSize(GetJobData()->GetPaper());
	PCL6Writer::MediaSource mediaSource =
		_MediaSource(GetJobData()->GetPaperSource());
	if (GetJobData()->GetPrintStyle() == JobData::kSimplex) {
		fWriter->BeginPage(orientation, mediaSize, mediaSource);
	} else if (GetJobData()->GetPrintStyle() == JobData::kDuplex) {
		// TODO move duplex binding option to UI
		fWriter->BeginPage(orientation, mediaSize, mediaSource,
			PCL6Writer::kDuplexVerticalBinding, fMediaSide);

		if (fMediaSide == PCL6Writer::kFrontMediaSide)
			fMediaSide = PCL6Writer::kBackMediaSide;
		else
			fMediaSide = PCL6Writer::kFrontMediaSide;
	} 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->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)
{
	PCL6Writer::ColorDepth colorDepth;
	if (_UseColorMode()) {
		#if COLOR_DEPTH == 8
			colorDepth = PCL6Writer::k8Bit;
		#elif COLOR_DEPTH == 1
			colorDepth = PCL6Writer::k1Bit;
		#else
			#error COLOR_DEPTH must be either 1 or 8!
		#endif
	} else
		colorDepth = PCL6Writer::k1Bit;

	fWriter->BeginImage(PCL6Writer::kDirectPixel, colorDepth, width, height,
		width, height);
	fWriter->ReadImage(compressionMethod, 0, height);
}


void
PCL6Driver::_EndRasterGraphics()
{
	fWriter->EndImage();
}


void
PCL6Driver::_RasterGraphics(const uchar* buffer, int bufferSize, int dataSize,
	int rowSize, int height, int compressionMethod)
{
	// write bitmap byte size
	fWriter->EmbeddedDataPrefix32(dataSize);

	// write data
	if (compressionMethod == PCL6Writer::kRLECompression) {
		// use RLE compression
		uchar* outBuffer = new uchar[dataSize];
		pack_bits(outBuffer, buffer, bufferSize);
		fWriter->Append(outBuffer, dataSize);
		delete[] outBuffer;
		return;
	} else if (compressionMethod == PCL6Writer::kDeltaRowCompression) {
		// use delta row compression
		DeltaRowStreamCompressor compressor(rowSize, 0, fWriter);
		if (compressor.InitCheck() != B_OK) {
			return;
		}

		const uint8* row = buffer;
		for (int i = 0; i < height; i ++) {
			// write row byte count
			int32 size = compressor.CalculateSize(row);
			fWriter->Append((uint16)size);

			if (size > 0) {
				// write delta row
				compressor.Compress(row);
			}

			row += rowSize;
		}
	} else {
		// write raw data
		fWriter->Append(buffer, bufferSize);
	}
}


bool
PCL6Driver::EndPage(int)
{
	try {
		fWriter->EndPage(GetJobData()->GetCopies());
		return true;
	}
	catch (TransportException& err) {
		return false;
	}
}


void
PCL6Driver::_JobEnd()
{
	fWriter->CloseDataSource();
	fWriter->EndSession();
	fWriter->PJLFooter();
	fWriter->Flush();
	delete fWriter;
	fWriter = NULL;
}


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;
}


bool
PCL6Driver::_UseColorMode()
{
	return GetJobData()->GetColor() != JobData::kMonochrome;
}


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 : return PCL6Writer::kCOM10Envelope;
		case : return PCL6Writer::kMonarchEnvelope;
		case : return PCL6Writer::kC5Envelope;
		case : return PCL6Writer::kDLEnvelope;
		case : return PCL6Writer::kJB4Paper;
		case : return PCL6Writer::kJB5Paper;
		case : return PCL6Writer::kB5Envelope;
		case : return PCL6Writer::kJPostcard;
		case : return PCL6Writer::kJDoublePostcard;
		case : return PCL6Writer::kA5Paper;
		case : return PCL6Writer::kA6Paper;
		case : return PCL6Writer::kJB6Paper;
		case : return PCL6Writer::kJIS8KPaper;
		case : return PCL6Writer::kJIS16KPaper;
		case : return PCL6Writer::kJISExecPaper;
*/
		default:
			return PCL6Writer::kLegalPaper;
	}
}


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;
		default:
			return PCL6Writer::kAutoSelect;
	}
}