DIRECTORY
Basics, PrincOpsUtils, MessageWindow, TapeOps, PDFileFormat,  PDInterpSysCalls, PDInterpBitmap, PDInterpOutput, PDQueue, Rope
;

PDInterpOutputTapeImpl: CEDAR PROGRAM
IMPORTS PrincOpsUtils, MessageWindow, PDInterpBitmap, PDInterpSysCalls, TapeOps
EXPORTS PDInterpOutput = BEGIN

bpi: CARDINAL _ 200;
pageWidthInches: CARDINAL _ 40;
white: CARDINAL = 0;
bitsPerWord: NAT = Basics.bitsPerWord;
bytesPerWord: NAT = Basics.bytesPerWord;
wordsPerScan: CARDINAL = ((bpi * pageWidthInches) + bitsPerWord - 1) / bitsPerWord;
scansPerBand: CARDINAL _ 64;
wordsPerBand: LONG CARDINAL = LONG[wordsPerScan] * LONG[scansPerBand];
currentHerald: PDFileFormat.Herald;
currentStartImage: PDFileFormat.StartImage;
currentBandNumber: NAT _ 0;
bandWords: NAT _ 0;
band: PDInterpBitmap.BitmapDesc _ [sOrigin: 0, fOrigin: 0, sMin: 0, fMin: 0, sSize: 0, fSize: 0, pointer: NIL, rast: 0, lines: 0];
bandWordsAllocated: INT _ 0;
tapeHandle: TapeOps.TapeHandle _ NIL;

preamble: REF ColorPreamble;
ColorPreamble: TYPE = MACHINE DEPENDENT RECORD [
	escape: [0..256) _ 9BH, -- escape
	header: CHARACTER,
	byteCountHigh: [0..256) _ 0,
	byteCountLow: [0..256) _ 4,
	lengthHigh: [0..256) _ 0,
	lengthLow: [0..256) _ 0,
	modeAndColor:  ModeAndColor,
	reserved: [0..256) _ 0,
	padding: Bytepad  --tape wants first record padded to 32 bytes
	];
Bytepad: TYPE = ARRAY [0..12) OF CARDINAL;
pad: Bytepad = ALL[0];

Color: TYPE = MACHINE DEPENDENT {Black(0), Cyan(1), Magenta(2), Yellow(3)};

ColorMode: TYPE = MACHINE DEPENDENT {
 SinglePassOfColor(0), FirstPassOfColor(1), IntermediatePassOfColor(2), (3)};

ModeAndColor: TYPE = MACHINE DEPENDENT RECORD [
  padding: [0..16) _ 0, --4 bits of padding
  mode: ColorMode,  --2 bit field
  color: Color _ Black ];  --2 bit field

CurrentBandDesc: PROC RETURNS [PDInterpBitmap.BitmapDesc] = TRUSTED {
band.sOrigin _ currentHerald.bandSSize*(currentBandNumber+currentStartImage.passBands);
PDInterpBitmap.Clear[band];
RETURN [band]
};


StartImage: PUBLIC PROC [herald: PDFileFormat.Herald, startImage: PDFileFormat.StartImage, request: PDQueue.Request] RETURNS [PDInterpBitmap.BitmapDesc] = {
IF taping THEN {
rast: NAT = (--startImage.fSizePage-- (bpi*pageWidthInches)+bitsPerWord-1)/bitsPerWord;
lines: INT = herald.bandSSize;
words: INT = rast*lines;
mode: ColorMode _ IF NOT startImage.feed THEN IntermediatePassOfColor ELSE IF startImage.strip THEN SinglePassOfColor ELSE FirstPassOfColor;
color: Color _ SELECT startImage.toner FROM
black => Black,
cyan => Cyan,
magenta => Magenta,
yellow => Yellow,
ENDCASE => ERROR;
currentHerald _ herald;
currentStartImage _ startImage;
currentBandNumber _ 0;
IF words > bandWordsAllocated THEN TRUSTED {
IF band.pointer # NIL THEN PDInterpSysCalls.FreeSpace[band.pointer];
band.pointer _ PDInterpSysCalls.AllocateSpace[words];
bandWordsAllocated _ words;
};
band.sOrigin _ 0;
band.fOrigin _ 0; -- startImage.fMinPage;
band.sMin _ 0;
band.fMin _ 0;
band.sSize _ herald.bandSSize;
band.fSize _ rast*bitsPerWord;
band.rast _ rast;
band.lines _ herald.bandSSize;
bandWords _ words;
IF bandWords MOD bufferWords # 0 THEN ERROR;
IF currentStartImage.feed THEN { --start of new page
tapeHandle _ InitializeTape[];
};
preamble _ MakeColorPreamble[inches: IF color=Black THEN LongestColor[]+2 ELSE 0, mode: mode, color: color];
TRUSTED {PutBlock[source: LOOPHOLE[preamble], words: SIZE[ColorPreamble]];};
IF passBands[color]#0 THEN SendWhiteSpace[bands: passBands[color]]
}
ELSE { --first pass to find images sizes and white space
rast: NAT = (--startImage.fSizePage-- (bpi*pageWidthInches)+bitsPerWord-1)/bitsPerWord;
lines: INT = herald.bandSSize;
words: INT = rast*lines;
color: Color _ SELECT startImage.toner FROM
black => Black,
cyan => Cyan,
magenta => Magenta,
yellow => Yellow,
ENDCASE => ERROR;
currentHerald _ herald;
currentStartImage _ startImage;
currentBandNumber _ 0;
IF words > bandWordsAllocated THEN TRUSTED {
IF band.pointer # NIL THEN PDInterpSysCalls.FreeSpace[band.pointer];
band.pointer _ PDInterpSysCalls.AllocateSpace[words];
bandWordsAllocated _ words;
};
band.sOrigin _ 0;
band.fOrigin _ 0; -- startImage.fMinPage;
band.sMin _ 0;
band.fMin _ 0;
band.sSize _ herald.bandSSize;
band.fSize _ rast*bitsPerWord;
band.rast _ rast;
band.lines _ herald.bandSSize;
bandWords _ words;
IF bandWords MOD bufferWords # 0 THEN ERROR;
buffersPerBand _ bandWords/bufferWords;  --THIS MUST HAVE ZERO REMAINDER
IF currentStartImage.feed THEN { --start of new page, so initialize separation arrays
passBands _ ALL[LAST[NAT]];
nBands _ ALL[0];
};
passBands[color] _ currentStartImage.passBands;
nBands[color] _ currentStartImage.nBands;
};
RETURN [CurrentBandDesc[]];
};


MakeColorPreamble: PROC [inches: CARDINAL, mode: ColorMode, color: Color _ Black] RETURNS [preamble: REF ColorPreamble] = {
preamble  _ NEW[ColorPreamble _ [
header: 'P,		-- color header preamble
lengthLow: inches,	-- length in inches
modeAndColor: [mode: mode, color: color],
padding: pad
]];
};

PutBlock: PROC [source: LONG POINTER, words: NAT]  = TRUSTED {
tapeStatus: TapeOps.TapeStatus;
loopCount: NAT _ words/bufferWords; --whole number of full buffers
lastBuffer: NAT _ words MOD bufferWords; --words in final, unfilled buffer
IF words > bandWordsAllocated THEN ERROR;
FOR count: NAT IN [0..loopCount) DO
MoveWordsToBuffer[from: source+LONG[bufferWords]*LONG[count], words: bufferWords];
tapeStatus _ TapeOps.WriteRecord[tapeHandle: tapeHandle, writeData: textBuffer];
IF tapeStatus[EOT] THEN ERROR;
ENDLOOP;
IF lastBuffer#0 THEN {
MoveWordsToBuffer[from: source+LONG[bufferWords]*LONG[loopCount], words: lastBuffer];
tapeStatus _ TapeOps.WriteRecord[tapeHandle: tapeHandle, writeData: textBuffer];
IF tapeStatus[EOT] THEN ERROR;
};
};

MoveWordsToBuffer: PROC [from: LONG POINTER, words: NAT]  = TRUSTED {
IF words > textBuffer.maxLength/2  THEN ERROR;
textBuffer.length _ words*2;
PrincOpsUtils.LongCopy[from: from, to: bufferData, nwords: words];
};

EndBand: PUBLIC PROC RETURNS [PDInterpBitmap.BitmapDesc] = TRUSTED {
IF taping THEN PutBlock[source: band.pointer, words: bandWords];
currentBandNumber _ currentBandNumber + 1;
RETURN [CurrentBandDesc[]]
};


EndImage: PUBLIC PROC [request: PDQueue.Request] = {
IF currentStartImage.strip THEN { -- all images completed for this page
minPass: NAT _ LAST[NAT];
FOR c: Color IN Color DO
minPass _ MIN[passBands[c], minPass];
ENDLOOP;
FOR c: Color IN Color DO
IF passBands[c] # NAT.LAST THEN passBands[c] _ passBands[c] - minPass;
ENDLOOP;
IF taping THEN FinalizeTape[tapeHandle];
taping _ NOT taping;
}
ELSE IF taping THEN {
tapeStatus: TapeOps.TapeStatus;
tapeStatus _ TapeOps.WriteFileMark[tapeHandle]; --file mark between separations
IF tapeStatus[EOT] THEN ERROR;
};
};

LongestColor: PROC [] RETURNS [inches: CARDINAL] = {
inches _ 0;
FOR c: Color IN Color DO
inches _ MAX[inches, ((passBands[c] + nBands[c]) * scansPerBand) / bpi];
ENDLOOP;
};

SendWhiteSpace: PROC [bands: CARDINAL] = TRUSTED {
PrincOpsUtils.LongZero[where: bufferData, nwords: bufferWords];
FOR i: CARDINAL IN [0..bands) DO
FOR j: CARDINAL IN [0..buffersPerBand) DO
PutBlock[source: bufferData, words: bufferWords];
ENDLOOP;
ENDLOOP;
};

InitializeTape: PROC RETURNS [tapeHandle: TapeOps.TapeHandle] = {
ENABLE TapeOps.TapeOpsError => {
IF tapeHandle#NIL THEN TapeOps.CloseDrive[tapeHandle]; ERROR};

tapeStatus: TapeOps.TapeStatus;
tapeHandle _ TapeOps.OpenDrive[serverName: serverName, driveNumber: driveNumber, density:  density];
tapeStatus _ TapeOps.GetStatus[tapeHandle];
UNTIL tapeStatus[RDY] DO 
MessageWindow.Append[message: "Tape Drive Not Ready", clearFirst: TRUE];
MessageWindow.Blink[];
tapeStatus _ TapeOps.GetStatus[tapeHandle];
ENDLOOP;
};

FinalizeTape: PROC [tapeHandle: TapeOps.TapeHandle] = {
ENABLE TapeOps.TapeOpsError => {TapeOps.CloseDrive[tapeHandle]; ERROR};
tapeStatus: TapeOps.TapeStatus;
tapeStatus _ TapeOps.WriteFileMark[tapeHandle];
IF tapeStatus[EOT] THEN ERROR;
tapeStatus _ TapeOps.WriteFileMark[tapeHandle]; --need two file marks
IF tapeStatus[EOT] THEN ERROR;
tapeStatus _ TapeOps.Rewind[tapeHandle];
IF tapeStatus[EOT] THEN ERROR;
TapeOps.CloseDrive[tapeHandle];
};

SetTapeServer: PROC [serverNameL: Rope.ROPE _ "Maggie", driveNumberL: NAT _ 0, densityL: TapeOps.Density _ PE1600] = {
serverName _ serverNameL; driveNumber _ driveNumberL; density _ densityL;
};

serverName: Rope.ROPE _ "Maggie";
driveNumber: NAT _ 0;
density: TapeOps.Density _ PE1600;

taping: BOOLEAN _ FALSE; --true if second pass and writing tapes
passBands: ARRAY Color OF NAT;
nBands: ARRAY Color OF NAT;

bufferData: LONG POINTER;
bufferBytes: NAT = 16000;  --16 scanline buffer
bufferWords: NAT = bufferBytes/bytesPerWord;
bufferPad: NAT = 10;  --just for debugging
textBuffer: REF TEXT _ NEW[TEXT[bufferBytes+bufferPad]];
buffersPerBand: NAT _ 0; --MUST BE AN INTEGRAL NUMBER OF BUFFERS PER BAND
textBuffer.length _ bufferBytes;
TRUSTED {bufferData _ LOOPHOLE[textBuffer, LONG POINTER]+SIZE[TEXT[0]];};

END.

PDInterpOutputTapeImpl.mesa
Last edited by Ken Pier, May 9, 1986 2:01:48 pm PDT
Plotter constants
PrincOpsUtils.LongZero[where: bufferData, nwords: bufferWords];
look at ColorVersatecInterpOutputImpl which deals with XDE stuff band by band
look at PDInterpOutputViewerImpl to see how to get along in the Cedar world with ImagerPixelMaps. Combine the two, and then put in the tape file streams and control
commands. Think about naming and size of files.

Write a test tape BY HAND with four solid rectangles and send to Versatec.

�Ê	 ˜Icodeš
œ™K™3K˜š
Ïk	˜	Kš
œ}˜}K˜
—K˜šÏnœ�œ
�˜%Kš�œH˜OKš�œ�˜K˜Kš
œ™Kšœ�œ˜Kšœ�œ˜Kšœ�œ˜Kšœ
�œ˜&Kšœ�œ˜(Kšœ�œ=˜SKšœ�œ˜Kš	œ�œ
�œ�œ�œ˜FK˜#K˜+Kšœ�œ˜Kšœ�œ˜Kšœj�œ˜‚
Kšœ�œ˜Kšœ!�œ
˜%K˜Kšœ
�œ˜Kšœ�œ�œ
�	œ
�œÏc
œ	�	œ¼
Ÿ-œ˜ÒKš	œ	�œ�œ	�œ
�œ
˜*Kšœ�œ˜K˜Kšœ�œ�œ
�	œ,˜KK˜Kšœ�œ�œ
�	œP˜sK˜Kšœ�œ�œ
�	œ
�œŸœŸœŸ
˜¦
K˜šžœ�œ
�œ�œ˜EK˜WK˜Kš�œ˜
K˜K˜—K˜šž
œ�œ
�œ^�œ ˜œ
š�œ�œ˜Kšœ�œŸœ2˜WKšœ�œ˜Kšœ�œ˜Kšœ�œ
�œ�œ�œ
�œ�œ�œ˜Œ
šœ�œ�˜+K˜K˜
K˜K˜Kš�œ�œ
˜—K˜K˜K˜š�œ�œ
�œ˜,Kš�œ�œ
�œ*˜DK˜5K˜K˜—K˜KšœŸ˜)K˜K˜K˜K˜K˜K˜K˜Kš�œ�œ�œ
�œ
˜,š�œ�œŸ˜4K˜K˜—Kšœ%�œ
�œ�œ˜lKš�œ�œ�œ˜LKš�œ�œ(˜BKš
œ
˜
—š�œŸ1˜8Kšœ�œŸœ2˜WKšœ�œ˜Kšœ�œ˜šœ�œ�˜+K˜K˜
K˜K˜Kš�œ�œ
˜—K˜K˜K˜š�œ�œ
�œ˜,Kš�œ�œ
�œ*˜DK˜5K˜K˜—K˜KšœŸ˜)K˜K˜K˜K˜K˜K˜K˜Kš�œ�œ�œ
�œ
˜,Kšœ)Ÿ˜Hš�œ�œŸ4˜UKšœ�œ
�œ
�œ˜Kšœ	�œ˜K˜—K˜/K˜)Kš
œ˜—Kš�œ˜K˜K˜—K˜š
žœ�œ
�œ)�œ�œ˜{Kšœ�œ ŸœŸœ:˜©
Kš
œ˜—K˜šžœ�œ
�œ
�œ	�œ�œ˜>Kš
œ˜Kšœ�œŸ˜BKšœ�œ	�œŸ!˜JKš�œ�œ
�œ
˜)š�œ�œ
�œ�˜#Kšœ�œ�œ˜RKš
œP˜PKš�œ�œ�œ
�œ
˜Kš�œ
˜—š�œ�œ˜Kš
œ?™?Kšœ�œ�œ ˜UKš
œP˜PKš�œ�œ�œ
�œ
˜K˜—K˜—K˜šžœ�œ�œ
�œ	�œ�œ˜EKš�œ!�œ
�œ
˜.Kš
œ˜Kš
œB˜BK˜—K˜š
žœ�œ
�œ
�œ�œ˜DKš�œ�œ2˜@K˜*Kš�œ˜K˜K˜—K˜šžœ�œ
�œ˜4š�œ�œŸ%˜GKšœ	�œ�œ
�œ˜š�œ
�œ�˜Kšœ
�œ˜%Kš�œ
˜—š�œ
�œ�˜Kš�œ�œ
�œ
�œ'˜FKš�œ
˜—Kš�œ�œ˜(Kšœ	�œ˜K˜
—š�œ
�œ�œ˜Kš
œ˜Kšœ0Ÿ˜OKš�œ�œ�œ
�œ
˜K˜—K˜—K˜šžœ�œ�œ
�œ˜4Kš
œ˜Kš�œ
�œ�˜Kšœ	�œ<˜HKš�œ
˜K˜—K˜šžœ�œ	�œ�œ˜2Kš
œ?˜?š�œ�œ
�œ�˜ š�œ�œ
�œ�˜)Kš
œ1˜1Kš�œ
˜—Kš�œ
˜—K˜—K˜šžœ�œ
�œ%˜Aš�œ˜ Kš�œ�œ
�œ!�œ˜>K˜—Kš
œ˜Kš
œd˜dKš
œ+˜+š�œ�œ�œ
˜KšœB�œ˜HKš
œ˜Kš
œ+˜+Kš�œ
˜—K˜—K˜šžœ�œ%˜7Kš�œ:�œ˜GKš
œ˜Kš
œ/˜/Kš�œ�œ�œ
�œ
˜Kšœ0Ÿ˜EKš�œ�œ�œ
�œ
˜Kš
œ(˜(Kš�œ�œ�œ
�œ
˜Kš
œ˜K˜—K˜šž
œ�œ�œ�œ-˜vKš
œI˜IK˜—K˜Kšœ�œ˜!Kšœ
�œ˜Kš
œ"˜"K˜Kšœ�œ�œŸ'˜@Kšœ�œ�œ
�œ
˜Kšœ�œ�œ
�œ
˜K˜Kšœ�œ
�œ
˜Kšœ
�œŸ˜/Kšœ
�œ˜,Kšœ�œŸ˜*Kš	œ�œ
�œ�œ
�œ˜8Kšœ�œŸ0˜IKš
œ ˜ Kš�œ�œ
�œ
�œ�œ
�œ˜IK˜Kš�œ
˜—K˜Kš
œM™MK™Ô
K™K™JK™—…—"Ä.|