Tag Archives: photocd

Wasting time with Kodak Cineon Calibration frames

One thing with copious amounts of data is that one never knows what there is to find in it.

Having constructed a piscsi from used pipe organ relay parts I decided to take another look at some of the disk images I have aquired over the years. When I got the scanner in 2020 one reader of this blog was able to make available some salvaged backups of PCD 4050 data.

While the Cinion shared hardware with PCD the color model was completly different. Cineon favoring the recording of Dye densities. The focus on archiving cine camera negatives for transfer to laser based printing machines. The PCD was aimed at making things look good with the NTSC phosphors or CMYK prepress. Most writing on these subjects note that these models are mutually exclusive. One book even went as far as noting that this would be part of the solution of unified field theory in physics. Basically my take on this is relating color time and gravity. Colors are frequencies after all.

The data was salvaged by Maurice Schechter, who did not have much of an online presence. The main archive was called 4050_mac_os9.zip Also found was a file 4050.ZIP and something called 4050_1. 4050.Zip decompresses to about 450MB and 4051_1 is around 100MB. This is a fair amount of data. Maurice indicated he did not have anything else.

The service diagnostic programs had no resource forks. (they can be coaxed to run with stub resource forks, which is another area of study.)

The two zip files turned out to be bit identical. This appears to have been created with a unix zip tool as the creator file system is specified to be UNIX. There are no hidden resource files on either.

The file 4050_1 file appears to be compressed. It may have had a .sea suffix. The Stuffit command indicates it is not a sit file.

Apple dropped support for HFS disk images, which lead me to write an extractor for Diskcopy images what lost their resource forks. I had ported gzip and more importantly gunzip to mac OS7 in the 1990s to support building ghostscript on that system. Using MPW and A cobbled together X11 library that used quickdraw. A variation of this remains hidden here on some forgotten pages here https:www.delectra.com/tina MATLAB and openCV pretty much replaced this tool in computer vision research.

Apple diskcopy used a compression called ADC. It is evident that 4050_1 is not ADC as this compression uses LZ windowing to remove long runs (mostly empty disks sectors.) Text files retain large sections of readable chunks.

Sit files also contain a bit of text in the header and footer of the archive. Typically examples of these have file headers which contain the file name in plaintext.

Postscript has built in LZW and Flate (zlib) decoders. The 4050 data is not formatted for this either.


The first block of the 4050 file looks like this as a hex string represented in postscript:

/dBlock <
8F1A000627D3BAFD2B24726F5023F2F7
1F285005080FD3C00418D5E0047E0023
60A00D5FA7BE20B2E4D15E97F7827E8D
7D2BC990B057B3AF8C099BBE5E5C921C
FCFBDACE3DCD1B701385794E7BD9C434
718B536892457CFD0E2DBACA1AC25844
0804BF22AD423057C7532686B17FB98C
3491FF46C17E8DCFD971EC1D76ECF102
B5C2D9437ED0E65E8B73795DE84F3149
89B0DC418A07404A3D8159522DC64C03
5827731FAB5338C1CCA75A250EAA588D
ACC244C46DD4C422F95BCC64F45785D2
968CCC23C0C2C3B156D3243E674915DB
C5F0079FD966DE5F8A98595FDF7A11B5
83747836C1CFFCF9513C76336D8918BD
BBD9E2167480E2A61594409301E3FE35
D2F0C658C235C58934CB827684644242
06E6D4FCC540F54FF23BA66893F1301A
1E2AE5B9C8A244EA9F321C6E5E7284A3
1C16CB88E97F16FC8033A262ADBB64E1
FCE00337C0E38B062A30A01B80E6AC94
57937992A3D69D5605188488489E06DC
31026C00EEC7F98DFB921AD03B822C3D
EBFDE54453F960A59CF04A4900A6EB4F
C395EB2F51AB3B88604F68008F9C3132
004C9796B0A9575D70201D164F4F6F01
715A02E92D8037EAD9787BE38BD865C0
5A62FF8CF0AA10E7B99B536CE15C3613
1AFE27624F6994D0E7FAC4102040B041
24EA59201BFB86941F60D83701769092
023F6D94A960D7CDE7113E8034574498
22FB9203A2F074576D44BE05A1546602
> def


0x8F51 or 0x1A8F are no known magic cookies.


With the PISCSI I can mount the old versions of Stuffit and CompactPro (Compactor) Both wrote .sea archives. Many of the Kodak data fragments are in these formats. CompactPro also used the suffix .cpt These are Huffman coded compressions. Again there are no directories or magic cookies in this 100 megabytes of data.

As expected the mac port of zip (which supported resource forks) does not find any forks in the 4050.ZIP data.

There is a possibility this was compresses with a unix tool. pack and compress being likely candidates. Bzip2 is a bit modern for these archives, which were made before 2008. The archived data being from 1991 through 2003 or so.


So begins the waste of time doing another deep dive into LZ and Huffman using postscript.


One way of looking at a disk sector image dump is to look at it as a bitmap of graphics. (File Allocation tables are often bitmaps.) Image data also can be disconcerted this way.

The easiest way is to dump one sector as a line of bits. Postscript makes this easy.

It can be seen that the data is pretty random.



Since we now have the piSCSI and the lombard laptop, we can compress the interesting files with the popular sit and cpq compressors of the late 1990s, which return similar looking results.

Paging through megabytes of data patterns start to emerge. Each page is about 50K of data.


About a quarter of the way through the data changes patterns abrupbly. A huge runs of mark data. Looking at this data there is a pathname. ‘/kodaklutcineon2/5242/0019.cin’ This is followed by highly structured data what looks like ‘The Matrix.’ Almost like hieroglyphics or one of the asian character sets.



Looking at the first few bytes of the sector we have a magic number hit! This is an uncompressed cineon file!

By chance I also have a folder of these lut files. Not sure where they came from. The dates says I got them in 2020. The folder clocks in at over a gigabyte. Each lut is 13MB in size. A search also finds a draft PDF on this file format.

A quick write of a postscript program and we can dump the header. (see the teaser at the top of this blog.)

/Users/arethusa/Documents/PCDDocs&Tools/Maurice/4050_1 data fork:
[223472 114414345 1608070944 1729310805]
modified timestamp: [2020 12 15 22 22 24]
created timestamp: [2020 12 15 22 22 24]
/Users/arethusa/Documents/PCDDocs&Tools/Maurice/4050_1/..namedfork/rsrc no file resource.

0: Magic number: 16#802A5FD7 Cineon ‘draft’ image file.
4: Offset: 16#00007E00 Offset to image data in bytes: 32256
8: Generic: 16#00000400 Generic (fixed format) section header length in bytes: 1024
12: Industry: 16#00000400 Industry Specific (fixed format) section header length: 1024
16: VarLen: 16#00007600 Length in bytes of variable length section: 30208
20: Total: 16#00C2FE00 Total image file size in bytes:12779008
24: Version: “V4.5” Version number of header format.
32: ImageName: “/kodaklutcineon2/5274/0022.cin” Image filename
132: CreationDate: “2008:04:03” Creation date – eg. “yyyy:mm:dd”
144: CreationTime: “06:36:0Z” Creation time – eg. “hh:mm:ssxxx” (xxx – time zone, eg. EST)
156: RFU: Reserved for future use.
192: orientation: Line scan direction Page scan direction
0 = left to righttop to bottom
193: channels: 3
194: UNUSED1: 16#FFFF UNUSED (2 byte space for word allignment)

Channel 1
196: Channel1B0: 0 Channel 1 designator – Byte 0 (See Table 1)
0 – Universal metric
197: Channel1B1: 1 Channel 1 designator – Byte 1 (See Table 1)
1 – red (r,g,b printing density)
198: bpp: 10 Bits per pixel – channel 1
199: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
200: PixPl: 16#00000800 Pixels per line – channel 1: 2048
204: LPI: 16#00000614 Lines per image – channel 1: 1556
208: MinDataVal: 0.0 Minimum data value – channel 1: 0.0
212: MinQuantity: 0.0 Minimum quantity represented – channel 1: 0.0
216: MaxDataVal: 1023.0 Maximum data value – channel 1: 1023.0
220: MaxQuantity: 2.047 Maximum quantity represented – channel 1: 2.047

Channel 2
224: Channel1B0: 0 Channel 2 designator – Byte 0 (See Table 1)
0 – Universal metric
225: Channel1B1: 2 Channel 2 designator – Byte 1 (See Table 1)
2 – green (r,g,b printing density)
226: bpp: 10 Bits per pixel – channel 2
227: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
228: PixPl: 16#00000800 Pixels per line – channel 2: 2048
232: LPI: 16#00000614 Lines per image – channel 2: 1556
236: MinDataVal: 0.0 Minimum data value – channel 2: 0.0
240: MinQuantity: 0.0 Minimum quantity represented – channel 2: 0.0
244: MaxDataVal: 1023.0 Maximum data value – channel 2: 1023.0
248: MaxQuantity: 2.047 Maximum quantity represented – channel 2: 2.047

Channel 3
252: Channel1B0: 0 Channel 3 designator – Byte 0 (See Table 1)
0 – Universal metric
253: Channel1B1: 3 Channel 3 designator – Byte 1 (See Table 1)
3 – blue (r,g,b printing density)
254: bpp: 10 Bits per pixel – channel 3
255: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
256: PixPl: 16#00000800 Pixels per line – channel 3: 2048
260: LPI: 16#00000614 Lines per image – channel 3: 1556
264: MinDataVal: 0.0 Minimum data value – channel 3: 0.0
268: MinQuantity: 0.0 Minimum quantity represented – channel 3: 0.0
272: MaxDataVal: 1023.0 Maximum data value – channel 3: 1023.0
276: MaxQuantity: 2.047 Maximum quantity represented – channel 3: 2.047

Channel 4
280: Channel1B0: 255 Channel 4 designator – Byte 0 (See Table 1)
255vendor specific
Vendor defined
281: Channel1B1: 255 Channel 4 designator – Byte 1 (See Table 1)
255 – Vendor defined
282: bpp: 255 Bits per pixel – channel 4
283: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
284: PixPl: 16#FFFFFFFF Pixels per line – channel 4: 4294967295
288: LPI: 16#FFFFFFFF Lines per image – channel 4: 4294967295
292: MinDataVal: 0.0 Minimum data value – channel 4: 0.0
296: MinQuantity: 0.0 Minimum quantity represented – channel 4: 0.0
300: MaxDataVal: 0.0 Maximum data value – channel 4: 0.0
304: MaxQuantity: 0.0 Maximum quantity represented – channel 4: 0.0

Channel 5
308: Channel1B0: 255 Channel 5 designator – Byte 0 (See Table 1)
255vendor specific
Vendor defined
309: Channel1B1: 255 Channel 5 designator – Byte 1 (See Table 1)
255 – Vendor defined
310: bpp: 255 Bits per pixel – channel 5
311: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
312: PixPl: 16#FFFFFFFF Pixels per line – channel 5: 4294967295
316: LPI: 16#FFFFFFFF Lines per image – channel 5: 4294967295
320: MinDataVal: 0.0 Minimum data value – channel 5: 0.0
324: MinQuantity: 0.0 Minimum quantity represented – channel 5: 0.0
328: MaxDataVal: 0.0 Maximum data value – channel 5: 0.0
332: MaxQuantity: 0.0 Maximum quantity represented – channel 5: 0.0

Channel 6
336: Channel1B0: 255 Channel 6 designator – Byte 0 (See Table 1)
255vendor specific
Vendor defined
337: Channel1B1: 255 Channel 6 designator – Byte 1 (See Table 1)
255 – Vendor defined
338: bpp: 255 Bits per pixel – channel 6
339: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
340: PixPl: 16#FFFFFFFF Pixels per line – channel 6: 4294967295
344: LPI: 16#FFFFFFFF Lines per image – channel 6: 4294967295
348: MinDataVal: 0.0 Minimum data value – channel 6: 0.0
352: MinQuantity: 0.0 Minimum quantity represented – channel 6: 0.0
356: MaxDataVal: 0.0 Maximum data value – channel 6: 0.0
360: MaxQuantity: 0.0 Maximum quantity represented – channel 6: 0.0

Channel 7
364: Channel1B0: 255 Channel 7 designator – Byte 0 (See Table 1)
255vendor specific
Vendor defined
365: Channel1B1: 255 Channel 7 designator – Byte 1 (See Table 1)
255 – Vendor defined
366: bpp: 255 Bits per pixel – channel 7
367: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
368: PixPl: 16#FFFFFFFF Pixels per line – channel 7: 4294967295
372: LPI: 16#FFFFFFFF Lines per image – channel 7: 4294967295
376: MinDataVal: 0.0 Minimum data value – channel 7: 0.0
380: MinQuantity: 0.0 Minimum quantity represented – channel 7: 0.0
384: MaxDataVal: 0.0 Maximum data value – channel 7: 0.0
388: MaxQuantity: 0.0 Maximum quantity represented – channel 7: 0.0

Channel 8
392: Channel1B0: 255 Channel 8 designator – Byte 0 (See Table 1)
255vendor specific
Vendor defined
393: Channel1B1: 255 Channel 8 designator – Byte 1 (See Table 1)
255 – Vendor defined
394: bpp: 255 Bits per pixel – channel 8
395: UNUSED2: 16#FF UNUSED (1 byte space for word allignment)
396: PixPl: 16#FFFFFFFF Pixels per line – channel 8: 4294967295
400: LPI: 16#FFFFFFFF Lines per image – channel 8: 4294967295
404: MinDataVal: 0.0 Minimum data value – channel 8: 0.0
408: MinQuantity: 0.0 Minimum quantity represented – channel 8: 0.0
412: MaxDataVal: 0.0 Maximum data value – channel 8: 0.0
416: MaxQuantity: 0.0 Maximum quantity represented – channel 8: 0.0

420: WhitePoint: <3EAA30553EB1DE6A>> White point (color temperature) – x,y pair: [0.3324 0.3474]
428: RedPrimary: <7F8000007F800000>> Red primary chromaticity – x,y pair: [0.0 0.0]
436: GreenPrimary: <7F8000007F800000>> Green primary chromaticity – x,y pair: [0.0 0.0]
444: BluePrimary: <7F8000007F800000>> Blue primary chromaticity – x,y pair: [0.0 0.0]
452: LabelText: “”
652: RFU2: Reserved for future use.

Image Data Format Information :
680: DataInterleave: 0 = pixel interleave (rgbrgbrgb…)
681: Packing: 5 = longword (32 bit) boundaries – left justified
682: SignedData: 0 = unsigned
683: ImageSense: 0 = positive image
684: EOLPad: 16#00000000 End of line padding – number of bytes.
688: EOC: 16#00000000 End of channel padding – number of bytes.
692: RFU3: Reserved for future use.


Image Origination Information :
712: XOffset: 16#00000000 correlate digital data to source media.
716: YOffset: 16#00000000 correlate digital data to source media.
720: ImageName2: /kodaklutcineon2/5274/0022.cin
820: CreationDate2: 2008:04:03 Creation date – eg. “yyyy:mm:dd”
832: CreationTime2: 06:36:0Z Creation time – eg. “hh:mm:ssxxx” (xxx – time zone, eg. EST)
844: InputDevice: “GenesisPlus:MP35mm”
908: ModelNumber: “35mm”
940: SerialNumber: “361”
972: XdevicePitch: 166.667 X input device pitch (samples/mm.)
976: YdevicePitch: 166.667 Y input device pitch (samples/mm.)
980: CDGamma: 0.0 Image gamma of capture device.
984: RFU4: Reserved for future use.


Section 2 – Motion Picture Industry Specific (Fixed Format) :
1024: MFGIDcode: 255 Film mfg. ID code – 2 digit code from KEYKODE
1025: FilmType: 255 Film type – 2 digit code from KEYKODE
1026: PerfOffset: 255 Offset in perfs – 2 digit code from KEYKODE
1027: UNUSED3: 16#FF 1 byte space for word allignment
1028: Prefix: 16#FFFFFFFF – 6 digit code from KEYKODE: 4294967295
1032: FlCount: 16#FFFFFFFF Count – 4 digit code from KEYKODE: 4294967295
1036: Format: “” Format – eg. “ACADEMY, ”VISTAVISION“, etc.
1068: FramePosition: 16#00000016 Frame position in sequence 22
1072: FrameRate: 0.0 Frame rate of original (frames per second)
1076: FrAttribute: “” Frame attribute – eg. “KEYFRAME”
1108: Slate: “” Slate information
1308: RFU5: Reserved for future use.


Section 3 – User Defined (Variable Length) :
2048: VarLen: 30208
05D66580: 97936768
>>showpage, press to continue<<


A search of the 4050_1 archive finds 7 of these files. Which take up nearly 3 quarters of the archive.

Yet an issue remains. One of the files is fragmented. The next header is 10MB in the middle of it.

So this could still be a disk image archive. 12MB files were ginormous in the 1990s. They ate disk space. Compressors would choke on them

There is a strong possibility 4050_1 archive is part of a multi volume archive. Typically though these have headers so they can be stitched together.

The first 22MB still contains high entropy data. Which triggered more time wasting to go yet again through a deep dive of huffman lz coding to see if any patterns can be found.

The notes are not too encouraging. Where are the magic cookies? What arcane program was left to compress this archive.

At least I have a bunch of postscript tools for reading disk images which I can upload to github. Not sure though that can take gigabytes of archive data. Not really shure what can. Most people are more interested in mining it. (which in a way is what I am doing.)

Since these tools may be of interest I uploaded this to github under the name sheepdoll.

https://github.com/sheepdoll/PSDiskImageArchiveTools

This blog forms an early dratf of the readme as I had to upload there first before having a place to link to.

Postscript makes it easy to dump and format hex data, even binary. Here are some results from the command line. Looking at this seems much a waste of time, even if there is data there, is it worth the time searching for it.



% 8F 1A 00 06 27 D3 BA FD 2B 24 72 6F 50 23 F2 F7 1F 28 50 05 08 0F D3 C0 04 18 D5 E0 04 7E 00 23

% 1000 1111 0001 1010 0000 0110 0010 0111 1101 0011 1011 1010 1111 1101 0010 1011 0010 0100 0111 0010

% 100011110 001101000 000110001 001111101 001110111 010111111 010010101 100100100 01110010
% 286 104 49 125
% 11E 064 031 07D 077 0BF 095 124


% 10001111 000110100 000011000 100111110 100111011 101011111 101001010 110010010 001110010
% 8F 034 018 13E 13B 15F 14A 192 072

% 1A8F 0600 D327 FDBA 242B 6F72 2350 F7F2 281F

% 0001 1010 1000 111 0110 0000 1101 0011 0010 1110 1111 1101

% 000110101 000111011 000001101 001100101 11011111 101
% 035 03B 00D 065 1BF

% 876543210 876543210 876543210 876543210 876543210 876543210 876543210 876543210 876543210
% 765432107 654321076 543210765 432107654 321076543 210765432 107654321 076543210 765432107
% <<1 <<2 <<3 <<4 <<5 <<6 <<7
% mmmmmmmm mmmmmmm mmmmmm mmmmm mmmm mmm mm m
% M MM MMM MMMM MMMMM MMMMMM MMMMMMM MMMMMMMM


% mac cpt packit/compactor in dcpt base values out of range -- and this looked so promising


%banana.z
%/of (banana.z) (w) file def
%of <1f1e0000000603010100616e6216c8> writestring
%of closefile


% pack -- not promising
% /*
% * check two-byte header --------> !fails here obviously 1F1E 1F9D is compress
% * get size of original file, -------> 6 or 1536 if long could be 403411
%orig size long 27d3ba 2610106 invalid
% * get number of levels in maxlev, -----> short invalid 6, 27
% * get number of leaves on level i in intnodes[i], 211 -- nodes are short -- looks invalid
% * set tree[i] to point to leaves for level i
% */


% packbits

% 8F 1A 00 06 27 D3 BA FD 2B 24 72 6F 50 23 F2 F7 1F 28 50 05 08 0F D3 C0 04 18 D5 E0 04 7E 00 23
% ^ ^ ^ ^ ^
% | | | | |
% | | | | |
% | | | | +--- 72 bytes of litteral dat -- probably not packbits
% | | | +--- 6 bytes of litteral data <27 D3 BA FD 2B 24>
% | | +----- zero
% | +----- data to repeat
% +-- run 16 1A


% ADC checked in ddskcpy/ddskimg and filterws.ps -- typically adc sliding window leaves bits and pecies of
% readable text

Ultimate recycling.

Twenty first century SCSI


It has been a year since I last worked much with the Kodak PCD film scanner. Having reverse engineered the bulk of the photoshop plugin and diagnostic code, It was time to start working with hardware.

The PCD 2000 scanner uses a smaller SCSI 50 contact connector. These do not turn up in e-Waste bins often. More common are the wide 68 pin connector used in server installations.

Modern systems do not have SCSI, although parts of the standard live on in USB sticks and smart memory cards. It is hard to find physical drives so project like RPSCSI forked as PISCSI make for a nice way of connecting to old devices. These tend to focus on drives, with little or no provisions for scanners. Printers seem to remain on the wishlist.

Probably the simplest thing would be to simply make an adapter cable for the scanner. Since the scanner weighs 60 or 70 pounds, it is not all that practical to move it onto the table. It also takes up a lot of space.

The Kodak software trends from several different collections. The easiest to find is the update to the photoshop plugin. This is missing a number of support install files and librarys. A backup of a complete OSX 8.1 system had been made, but was zipped which removed all the missing resource fork metadata. Investigation showed the code was written in CodeWarror. This allows the plugin to be re constituted, although the Kodak Color matching profiles remain missing.

The code was built with debug symbold (mangled C++ names) so the disassembly is fairly easy to read. The bulk of the code using Powerplant librarys, for which source code exists. Some of the other libraries were used with the SUN based workstation. This was used in situ in the macintosh port.

Thanks to readers of this blog the zipped archive, and Installer disks for the SUN based workstation were found. The Solaris PIW could probably be reverse engineered, however the same code base was used for the Macintosh plugin.

The plugin however was only written to support the 4050 scanner. Not the 2000 It does run to the point where a SCSI system inquiry is sent.


More interesting on the backup Zipped drive folder were diagnostic programs. These were built from the same code base as the Photoshop plugin. Unlike that system the metadata is completely missing. This includes the methods for creating and drawing the user interface windows.


The compilers are available on many of the vintage computer websites. So It is possible to use the UI design tool and some of the method names to create a stub application and re-create the UI windows. This metadata though is created progametrically, so some menu actions are not sent to the handlers. Or it is difficult to match handler methods to missing window entities which use inherited class properties. Still it is enough to reconstruct the code to manually jump through the main dispatch loop to the code what handles the sub windows.

Like the photoshop plugin, the diagnostic program sends a SCSI inquiry, the exits.

Since I only have a Filmscanner2000, it seems for tracing it would be better to spoof the inquiry to look like the 4050. This has a number of benefits. Namely that the code can be run without modification. There are hints that the 2000 and even the 1000 scanner can be detected. At least to warn the user that the wrong scanner is selected.

A lot of the diagnostic and photoshop plugin code seems to be there to emulate a UNIX style device tree. The preferences data missing from the Photoshop pluging consists of dozens of often single line text files which outline the device tree database. This data was not stored in the resource fork, so it remained on the 8.1 zipped image.

Another reader sent scans of the PCD service documents and calibration film strips. This has been a great wealth of information. I have been using makerspace laser cutters to cut out templates and fixtures.

I also got deep into APS film format and located the main technical specs, which include dimentions, how to read the magnetic codes and the bar codes on the film an canisters. A side project which has taken a lot of time is to work out how to cut down fresh 35mm film. Too bad one can not use the laser to cut the film as that would be easy. Hopefully it will not be so long before the next blog.

Meanwhile I found more useful hardware and returned to the scanner driver.


The vintage macs with SCSI ports I have access to are G3 based, a wallstreet, and more recently a lombard. found in eWaste for 15 bucks USD. The lombard had a bad HD cable. Using a DVD drive bay adapter a hard drive could be added. Although at the cost of the seldom used DVD slot. This makes a great backup system for experimentation.

By chance I still have an Apple ColorOne Scanner, and the adapter cable. Before finding this plan was to use a laser cutter to make a direct adapter. I did locate a minature 50 pin SCSI cable when I got the PCD scanner. I promptly cut this in half to make an adapter. For some reason ringing out the 50 connectors which are not in phone cable color order lead to a lot of procrastination. The ida was to jam these wires into the back of the MAC SCSI port. These cable halfs sat in the box of scanner parts for the last thee years.

While I could simply get a PISCSI, I realized I do have most of the parts needed. Jameco sells the buffer chips in DIP packages. So I orderd a short tube of them. Ringing out the cable shows that the wires use the resistor (or ribbon) color code with 12 colors. I think the remaining colors are known as Salmon (pink), Aqua and Teal. The traces are white black and red.

Tracing the cable showed how simple SCSI really is. There are really only 18 signals used. The rest are grounds and pair returns. Which is how Apple was able to use 25 or 30 pin connectors.

Pipe organs also often use 50 pin connectors. I had a few of these left over from scrapping out a S’n’DelCo relay. I also had some copper foil tape left over from a stained glass class I took some 50 years or so back. This occasional was used for pipe organ return bus. Some of this got upgraded, but still had some sticktivity to it. I also have Kapton tape and the friction tape used to wrap the cable.

Using a guide to SCSI cables, I decided then to make a shielded cable, with the signals isolated into layers. I retained the same pattern as the laptop connector rather than the DB25. The pitch however is not the same.

This in turn is the ultimate recycling as some of the items I have had for up to 50 years.

I also learned how to connect the Pi Zero to the 10.4 tiger as a headless dongle and bridge it to the network using the Ethernet Gadget. No more messy USB hubs, monitors and keyboards. This makes the Zero feel much more like an arduino or STM32F4 Nucleo.

Getting the Ethernet Gadget to work under osz 10.4 ‘Tiger’ was a bit of a challenge as the networking bridge was not included, and had to be compiled. These old war horses do not connect gracefully to the net. Fortunately someone a decade ago did create a fork of the commonly used driver. The git pulls and configuration scripts needing to be run on a separate connected machine first.

There is still a lot to do. Most of the focus on the PISCSI is as a turnkey product. So the internal documentation is sparse. The development focus seems to be more directed to the web interface.

Scanner calibration 101

A few years ago I was able to run the k4050 plugin up to the point where it fails to detect any scanners on the SCSI bus as I have not connected the scanner to the SCSI.

Over the last few years I was given copies of the mac 8.6 software (diagnostics) the sun PIW installers, and recently the service manual. This made me take another look at the diagnostics program for mac os 8/9. The service manual was targeted to the Sun Piw. There is a lot of Piw code in the Photoshop plugin driver.

The main issue with the Mac os 8 diagnostic program was that it was zipped. This removed all the resource data effectively destroying the program. A Hex dump of the remaining part of the app shows it as PowerPC PEF built with mangled name symbols. This would imply that most of the app is still there and might be recovered by synthesizing the resource fork.

The same custom dissembler written for the photoshop plugin was used to dump the diagnostic. A search online found a copy of Metrowerks CodeWarrior that seems to match the libraries used. An example app was built and the resource skeleton was added to the resource fork. Type and creator set to application.

Of course the menus are incorrect and there are no windows. But the app runs. It even generates a debug log though the try/catch mechanism. Placing a breakpoint just before the ‘wrong scanner’ exit allows tracing. Time to read up on CodeWarrior PPob classes. The code also uses some Rouge Wave string classes. The PCD4050 plugin also uses this library (available from the Sun linux IDE.) That library has not been updated since 1996. Interesting to see that it has #ifdef definitions for MacOS and CodeWarrior.

Since these apps are compiled with debug tags with mangled names, it is almost easy to read the code. The code also used a try/catch error handler. This will sometimes even give the filename and line number of the source code. About 40 to 50 percent of the code is power-plant application framework. Given that many of the remaining classes start with Piw, this code is basically ported sun code.

The SCIS driver classes are preceded with DIS. I have been unable to find this class as a library. Most likely this was an in house library.

The diagnostic and calibration programs used special strips of film exposed with a test pattern. The manual gives the layout of these patches along with some YCC values of a set of patches that are different on a given target.

The Mac OS 8.6 zip archive contains a smi of a calibration run (and logs) these did not use resource forks. The smi will mount and is an image of the calibration floppy. The files in the system extensions folder seem flat and look to contain matrix data for a 4050 scanner.

The resulting tables give RGB values. Probably in volts. The upper ranges are over 2048. but quite a bit less than 4096. Scaling with a 4096 (2^12) results in the patches displaying really dark on the display. Inverting the RGB, and one can see washed out color patches.

It is probable that these calibration strips have all been lost or destroyed. There is no evidence any were ever online. Chances of finding them are slim to none. I suspect the handful of people who have contacted me represents most of those who may retain a slight interest in this obsolete tech.

In the meantime, here is a bit of an update as to what I have found and done.

Entering the logged result values into a simple postscript program shows this grid matches the Illustrations in the service manual. This is a way a calibration film strip could be made. If one could photograph the resulting postscript output then the results could be photographed onto film. I have not done film photography (other than with the stereo realist in years.)

With my searches for data relating to PhotoCD I know that old cameras are cheap and sold in bulk. A visit to the local electronics recycler has tubs of them. Mostly digital, but quite a few film cameras as well. Some even loaded with film. I knew I had an old can of expired film. All I would need to do would be to expose it with precisely placed color. patches. Something postscript can do. I purchased a dozen or so cameras. Some had film jammed inside.

I learned about something worse than photo CD. APS! How could I have missed APS and Advantix? Oh no, a totally new distraction. I now have half a dozen APS cameras. And a completely new distraction. I suspect there will be more on this later. These cameras are a world unto themselves. At the time of this blog writing, they can be had cheap and old film and processing remains available for others who like really failed products.

While these cameras are interesting, they do not take normal film. Sort of a film data tape hybrid. They do contain some interesting motors and gearing. This film is no longer manufactured. Some of the cameras contained partial rolls. I found that the local lab can process it.

I also found a school science project supplier online. Too bad I did not have access to this sort of thing 25 years ago. They sell simple spectrometers, filters and diffraction gratings. I got out my old copy stand and rigged it with LED lighting.

I used an old iPhone to simply photograph the filter slides. I then took the APS camera and shot the rest of the roll through each filter against my monitor background. The results are promising. The film came back and each frame has the inverse of the color. I have not attempted to scan the returned film as the Kodak scanner has a long way to go. The old USB scanner i have gives less than satisfactory results.

The next step is to modify an old Olympus film camera that I gutted. This was a point an shoot camera. A digital camera back would probably be more productive. This way is so much more interesting. An Arduino should be able to control the shutter solenoid and the film advance.

A lot of the work over the last couple of years has been dissembling and re-construction the plugin code. This sort of effort does not really lend itself into frequent blog postings. I sort of swap between dissembling camera hardware, and dissembling munged obsolete driver code. I also actively scan piano rolls with custom hardware. So these efforts do have some general use.

I have a couple of vintage macs which I use for tracing code. The plugin and the diagnostics are not small programs, with the plug in clocking in at near 2MB. The surviving diagnostic code is about half that size.

There was never a mac driver for the Film scanner 2000. I have not found any references to a DIS SCSI library. DIS is the class name of the SCSI library used. Other classes are PTS and PIW.

I would be really surprised if anyone has one of these units working anywhere. I check once a month for parts or more documentation. I think only three or so people ever contacted me. (but they all did have most useful stuff.)

I have also been hesitant to apply any power or signals to the SCSI port as I only have one film scanner. Research has directed to something called RaSCSI, which looks like a promising way to emulate the interface. This way I can also create a bridge to Ethernet, which would be a more practical way to communicate with the scanner.

I have yet to ring out an adapter to the MD50 connector from the HDI30 on the laptop. I did find I had a cable that goes to the flatbed Apple Color scanner which I still have. Another project for another blog.

When the pcd 2000 scanner (or the other variations) are connected the host program downloads a hex file. While there is quite a sophisticated controller unit based on the 80C196KB. The actual program is downloaded every time.

The service manuals are quite informative about this operation. There is also an online paper (which is behind a paywall) that also covers what these boards do. The heart of this system is an ASIC called a normalizer. This term is also used for programs that convert postscript to PDF. There must also be quite a bit of ram on this board as the raw images are 18megapixels. The user/operator is well protected from this raw data. It all seems to be about the density.

The mac OS 8 image does contain a hex file called 4050.hex While there are strings that refer to other scanners like the 2000, these are used in the wrong scanner dialog. Another reason I have not connected the scanner is the lack of the correct microcode file.

The PIW install disks contain more hex files. One is called scanner.hex and the other metaphor.hex. Dumping these shows the version strings. There are a lot of references to metaphor in the OS 8 code. It is almost it’s own class. Metaphor seems to be the 4045/4050 driver.

Scanner.hex is the 2000 code. I modified the postscript table driven disassembler that I have used on 8080, avr,m68k and powerpc to do 80C196. The first results were a bit off as I had used the wrong chip variant, which has different registers. When the 80C196 register table was used, the code started making sense.

The main processor board is mostly latches. There is some SRAM and a seven segment display. (this board is shown in an earlier blog.) An interesting thing is that the code regularly pushes 4 digit hex numbers onto the stack. These do not seem to be memory locations.

By chance I noticed that they were the same range as the error codes in the service manual. These codes should show on the 7 segment display. The sophistication of this is quite impressive. Too bad most consumer equipment does not do these types of boundary checks any more. I think they really did think this tech would last the next hundred years.

by adding these numbers to a table in the disassembler one can see the error handler. The timer overflow basically sets counters. So some sort of kernel is being used with the state queued.

D0 00C80B: C8E0		'..'	prepError:PUSH	.stack_frame.	looks like error handler setup
C0 00C80D: A018E0	'...'	          LD	.stack_frame.,SP	; .stack_frame. <- SP
C0 00C810: C8A6		'..'	          PUSH	R.A6
C0 00C812: A3E0041C	'....'	          LD	AX,000004H[.stack_frame.]	; AX <- Var2
C0 00C816: 8981291C	'..).'	          CMP	AX,#0x2981	; Bus device reset
C0 00C81A: D726		'.&'	          JNE	L000016	; PC <- 00C842 PC + 38 (00C81C)
D0 00C81C: C301560700	'..V..'	L000017:  ST	ZERO_REG,000756H[ZERO_REG]	;  .datamemL. MEM_WORD(000756) <- ZERO_REG
C0 00C821: 11A6		'..'	          CLRB	R.A6
C0 00C823: 2018		' .'	          SJMP	L000018	; PC <- 00C83D PC + 24 (00C825)
D0 00C825: ACA61C	'...'	L000019:  LDBZE	AX,R.A6	; AX <- R.A6
C0 00C828: 09011C	'...'	          SHL	AX, #0x1
C0 00C82B: C71D460700	'..F..'	          STB	ZERO_REG,000746H[AX]	; MEM_BYTE(AX + 1862) <- ZERO_REG
C0 00C830: ACA61C	'...'	          LDBZE	AX,R.A6	; AX <- R.A6
C0 00C833: 09011C	'...'	          SHL	AX, #0x1
C0 00C836: C71D470700	'..G..'	          STB	ZERO_REG,000747H[AX]	; MEM_BYTE(AX + 1863) <- ZERO_REG
C0 00C83B: 17A6		'..'	          INCB	R.A6
D0 00C83D: 9908A6	'...'	L000018:  CMPB	R.A6,#0x08	; R.A6 == 8
C0 00C840: D3E3		'..'	          JNC	L000019	; PC <- 00C825 PC + -29 (00C842)
D0 00C842: A30156071C	'..V..'	L000016:  LD	AX,000756H[ZERO_REG]	; AX <-  .datamemL. MEM_WORD(000756)
C0 00C847: 8907001C	'....'	          CMP	AX,#0x0007	; AX == 7
C0 00C84B: DB2F		'./'	          JC	L000020	; PC <- 00C87C PC + 47 (00C84D)
D0 00C84D: 450400E01C	'E....'	L000021:  ADD	AX,.stack_frame.,#0x0004	; AX = .stack_frame. + 4
C0 00C852: C81C		'..'	          PUSH	AX
C0 00C854: A30156071C	'..V..'	          LD	AX,000756H[ZERO_REG]	; AX <-  .datamemL. MEM_WORD(000756)
C0 00C859: 6107001C	'a...'	          AND	AX,#0x0007	; AX &= 7
C0 00C85D: 09011C	'...'	          SHL	AX, #0x1
C0 00C860: 6546071C	'eF..'	          ADD	AX,#0x0746	; AX += 1862
C0 00C864: C81C		'..'	          PUSH	AX
C0 00C866: EF6856	'.hV'	          LCALL	L000022	; (00C869 + 22120) -> 001ED1
C0 00C869: 65040018	'e...'	          ADD	SP,#0x0004	; SP += 4
C0 00C86D: A30156071C	'..V..'	          LD	AX,000756H[ZERO_REG]	; AX <-  .datamemL. MEM_WORD(000756)
C0 00C872: 4501001C1E	'E....'	          ADD	BX,AX,#0x0001	; BX = AX + 1
C0 00C877: C30156071E	'..V..'	          ST	BX,000756H[ZERO_REG]	;  .datamemL. MEM_WORD(000756) <- BX
D0 00C87C: A30156071C	'..V..'	L000020:  LD	AX,000756H[ZERO_REG]	; AX <-  .datamemL. MEM_WORD(000756)
C0 00C881: 051C		'..'	          DEC	AX
C0 00C883: 6107001C	'a...'	          AND	AX,#0x0007	; AX &= 7
C0 00C887: CCA6		'..'	          POP	R.A6
C0 00C889: CCE0		'..'	          POP	.stack_frame.
C0 00C88B: F0		'.'	          RET

Some of the startup code is also of interest. Most likely the various communication sections are memory mapped in the higher address space. Curiously there is not a lot of windowing. This may be a result of the compiler used as only a subset of instructions are common. 

L000003:  SUB	SP,#0x0004	; SP -= 4
C0 00965B: C8E0		'..'	          PUSH	.stack_frame.
C0 00965D: A018E0	'...'	          LD	.stack_frame.,SP	; .stack_frame. <- SP
C0 009660: C872		'.r'	          PUSH	R.72
C0 009662: C874		'.t'	          PUSH	R.74
C0 009664: A100D072	'...r'	          LD	R.72,#0xD000	; R.72 <--12288
C0 009668: BD441C	'.D.'	          LDBSE	AX,#0x44	; AX <-68
C0 00966B: C301E4001C	'.....'	          ST	AX,0000E4H[ZERO_REG]	; REG(R.E4) MEM_WORD(0000E4) <- AX
C0 009670: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 009673: A100D272	'...r'	          LD	R.72,#0xD200	; R.72 <--11776
C0 009677: A100801C	'....'	          LD	AX,#0x8000	; Scanner software not downloaded
C0 00967B: C301E6001C	'.....'	          ST	AX,0000E6H[ZERO_REG]	; REG(R.E6) MEM_WORD(0000E6) <- AX
C0 009680: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 009683: A100D472	'...r'	          LD	R.72,#0xD400	; R.72 <--11264
C0 009687: C301E80000	'.....'	          ST	ZERO_REG,0000E8H[ZERO_REG]	; REG(R.E8) MEM_WORD(0000E8) <- ZERO_REG
C0 00968C: A301E8001C	'.....'	          LD	AX,0000E8H[ZERO_REG]	; AX <- REG(R.E8) MEM_WORD(0000E8)
C0 009691: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 009694: A100D672	'...r'	          LD	R.72,#0xD600	; R.72 <--10752
C0 009698: C301EA0000	'.....'	          ST	ZERO_REG,0000EAH[ZERO_REG]	; REG(R.EA) MEM_WORD(0000EA) <- ZERO_REG
C0 00969D: A301EA001C	'.....'	          LD	AX,0000EAH[ZERO_REG]	; AX <- REG(R.EA) MEM_WORD(0000EA)
C0 0096A2: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 0096A5: A100D872	'...r'	          LD	R.72,#0xD800	; R.72 <--10240
C0 0096A9: C301EC0000	'.....'	          ST	ZERO_REG,0000ECH[ZERO_REG]	; REG(R.EC) MEM_WORD(0000EC) <- ZERO_REG
C0 0096AE: A301EC001C	'.....'	          LD	AX,0000ECH[ZERO_REG]	; AX <- REG(R.EC) MEM_WORD(0000EC)
C0 0096B3: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 0096B6: A100DA72	'...r'	          LD	R.72,#0xDA00	; R.72 <--9728
C0 0096BA: C301EE0000	'.....'	          ST	ZERO_REG,0000EEH[ZERO_REG]	; REG(R.EE) MEM_WORD(0000EE) <- ZERO_REG
C0 0096BF: A301EE001C	'.....'	          LD	AX,0000EEH[ZERO_REG]	; AX <- REG(R.EE) MEM_WORD(0000EE)
C0 0096C4: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 0096C7: A120DC1C	'. ..'	          LD	AX,#0xDC20	; AX <--9184
C0 0096CB: C3E0021C	'....'	          ST	AX,000002H[.stack_frame.]	; Var1 <- AX
C0 0096CF: B103CA	'...'	          LDB	R.CA,#0x03	; R.CA <- 3
C0 0096D2: C61CCA	'...'	          STB	[AX],R.CA	; MEM_BYTE(AX) <- R.CA
C0 0096D5: A100DE72	'...r'	          LD	R.72,#0xDE00	; R.72 <--8704
C0 0096D9: C301F20000	'.....'	          ST	ZERO_REG,0000F2H[ZERO_REG]	; REG(R.F2) MEM_WORD(0000F2) <- ZERO_REG
C0 0096DE: A301F2001C	'.....'	          LD	AX,0000F2H[ZERO_REG]	; AX <- REG(R.F2) MEM_WORD(0000F2)
C0 0096E3: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 0096E6: A301F2001C	'.....'	          LD	AX,0000F2H[ZERO_REG]	; AX <- REG(R.F2) MEM_WORD(0000F2)
C0 0096EB: 8100801C	'....'	          OR	AX,#0x8000	; Scanner software not downloaded
C0 0096EF: C301F2001C	'.....'	          ST	AX,0000F2H[ZERO_REG]	; REG(R.F2) MEM_WORD(0000F2) <- AX
C0 0096F4: C2721C	'.r.'	          ST	[R.72],AX	; MEM_WORD(R.72) <- AX
C0 0096F7: A1401F1C	'.@..'	          LD	AX,#0x1F40	; AX <-8000
C0 0096FB: C30122051C	'.."..'	          ST	AX,000522H[ZERO_REG]	;  .datamemL. MEM_WORD(000522) <- AX
C0 009700: B11003	'...'	          LDB	AD_RESULT_H,#0x10	; AD_RESULT_H <- 16
C0 009703: B11015	'...'	          LDB	IOS0,#0x10	; IOS0 <- 16
C0 009706: B12616	'.&.'	          LDB	IOS1,#0x26	; IOS1 <- 38
C0 009709: B1010B	'...'	          LDB	TiMER1.H,#0x01	; TiMER1.H <- 1
C0 00970C: B1260E	'.&.'	          LDB	IOPORT0,#0x26	; IOPORT0 <- 38
C0 00970F: B1800E	'...'	          LDB	IOPORT0,#0x80	; IOPORT0 <- 128
C0 009712: B10D11	'...'	          LDB	SP_STAT,#0x0D	; SP_STAT <- 13
C0 009715: 910508	'...'	          ORB	INT_MASK,#0x05	; INT_MASK |= 5
C0 009718: 911213	'...'	          ORB	INT_MASK1,#0x12	; INT_MASK1 |= 18
C0 00971B: 11CF		'..'	          CLRB	R.CF
C0 00971D: 11D0		'..'	          CLRB	R.D0
C0 00971F: 11CE		'..'	          CLRB	R.CE
C0 009721: B1201C	'. .'	          LDB	AX,#0x20	; AX <- 32
C0 009724: C70175061C	'..u..'	          STB	AX,000675H[ZERO_REG]	;  .datamemL. MEM_BYTE(000675) <- AX
C0 009729: B101D1	'...'	          LDB	R.D1,#0x01	; R.D1 <- 1
C0 00972C: C701A10B00	'.....'	          STB	ZERO_REG,000BA1H[ZERO_REG]	;  .datamemL. MEM_BYTE(000BA1) <- ZERO_REG
C0 009731: EF5831	'.X1'	          LCALL	L000004	; (009734 + 12632) -> 00C88C
C0 009734: EFA331	'..1'	          LCALL	L000012	; (009737 + 12707) -> 00C8DA
C0 009737: C701E30000	'.....'	          STB	ZERO_REG,0000E3H[ZERO_REG]	; REG(R.E3) MEM_BYTE(0000E3) <- ZERO_REG
C0 00973C: EFAE88	'...'	          LCALL	L000013	; (00973F + -30546) -> 001FED
C0 00973F: 9BE00800	'....'	          CMPB	ZERO_REG,000008H[.stack_frame.]	; Var4 == ZERO_REG
C0 009743: D730		'.0'	          JNE	L000014	; PC <- 009775 PC + 48 (009745)
D0 009745: C98029	'..)'	L000015:  PUSH	#0x2980	; Power on or reset occurred
C0 009748: EFC030	'..0'	          LCALL	prepError	; (00974B + 12480) -> 00C80B
C0 00974B: 65020018	'e...'	          ADD	SP,#0x0002	; SP += 2
C0 00974F: 51080F1C	'Q...'	          ANDB	AX,IOPORT1,#0x08	; AX = IOPORT1 & 8
C0 009753: 99081C	'...'	          CMPB	AX,#0x08	; AX == 8
C0 009756: D70A		'..'	          JNE	L002049	; PC <- 009762 PC + 10 (009758)
D0 009758: C90080	'...'	L002050:  PUSH	#0x8000	; Scanner software not downloaded
C0 00975B: EFAD30	'..0'	          LCALL	prepError	; (00975E + 12461) -> 00C80B .processed.
C0 00975E: 65020018	'e...'	          ADD	SP,#0x0002	; SP += 2
D0 009762: C90600	'...'	L002049:  PUSH	#0x0006	; MEM_WORD(SP -= 2) <- 6
C0 009765: EF7831	'.x1'	          LCALL	L000132	; (009768 + 12664) -> 00C8E0 .processed.
C0 009768: 65020018	'e...'	          ADD	SP,#0x0002	; SP += 2
C0 00976C: C701690600	'..i..'	          STB	ZERO_REG,000669H[ZERO_REG]	;  .datamemL. MEM_BYTE(000669) <- ZERO_REG
C0 009771: A1401FB8	'.@..'	          LD	R.B8,#0x1F40	; R.B8 <-8000
D0 009775: C800		'..'	L000014:  PUSH	ZERO_REG
C0 009777: C800		'..'	          PUSH	ZERO_REG
C0 009779: EFEC2A	'..*'	          LCALL	L000023	; (00977C + 10988) -> 00C268
C0 00977C: 65040018	'e...'	          ADD	SP,#0x0004	; SP += 4
C0 009780: C800		'..'	          PUSH	ZERO_REG
C0 009782: C800		'..'	          PUSH	ZERO_REG
C0 009784: EFE12A	'..*'	          LCALL	L000023	; (009787 + 10977) -> 00C268 .processed.
C0 009787: 65040018	'e...'	          ADD	SP,#0x0004	; SP += 4
C0 00978B: C95C7C	'.\|'	          PUSH	#0x7C5C	; MEM_WORD(SP -= 2) <- 31836
C0 00978E: C9785C	'.x\'	          PUSH	#0x5C78	; MEM_WORD(SP -= 2) <- 23672
C0 009791: EFD42A	'..*'	          LCALL	L000023	; (009794 + 10964) -> 00C268 .processed.
C0 009794: 65040018	'e...'	          ADD	SP,#0x0004	; SP += 4
C0 009798: C701680600	'..h..'	          STB	ZERO_REG,000668H[ZERO_REG]	;  .datamemL. MEM_BYTE(000668) <- ZERO_REG
C0 00979D: C90100	'...'	          PUSH	#0x0001	; MEM_WORD(SP -= 2) <- 1
C0 0097A0: EF53F5	'.S.'	          LCALL	L000034	; (0097A3 + -2733) -> 008CF6
C0 0097A3: 65020018	'e...'	          ADD	SP,#0x0002	; SP += 2
C0 0097A7: EFC2F5	'...'	          LCALL	L000040	; (0097AA + -2622) -> 008D6C
C0 0097AA: C701440600	'..D..'	          STB	ZERO_REG,000644H[ZERO_REG]	;  .datamemL. MEM_BYTE(000644) <- ZERO_REG
C0 0097AF: C701740600	'..t..'	          STB	ZERO_REG,000674H[ZERO_REG]	;  .datamemL. MEM_BYTE(000674) <- ZERO_REG
C0 0097B4: EF5A18	'.Z.'	          LCALL	L000050	; (0097B7 + 6234) -> 00B011
C0 0097B7: 881C00	'...'	          CMP	ZERO_REG,AX	; ZERO_REG == AX
C0 0097BA: DF0A		'..'	          JE	L001816	; PC <- 0097C6 PC + 10 (0097BC)
D0 0097BC: C92780	'.'.'	L001817:  PUSH	#0x8027	; EEPROM failure
C0 0097BF: EF4930	'.I0'	          LCALL	prepError	; (0097C2 + 12361) -> 00C80B .processed.
C0 0097C2: 65020018	'e...'	          ADD	SP,#0x0002	; SP += 2
D0 0097C6: C800		'..'	L001816:  PUSH	ZERO_REG
C0 0097C8: C90400	'...'	          PUSH	#0x0004	; MEM_WORD(SP -= 2) <- 4
C0 0097CB: EF467F	'.F'	          LCALL	L000107	; (0097CE + 32582) -> 001714 .processed.
C0 0097CE: 65040018	'e...'	          ADD	SP,#0x0004	; SP += 4
C0 0097D2: C96008	'.`.'	          PUSH	#0x0860	; MEM_WORD(SP -= 2) <- 2144
C0 0097D5: C800		'..'	          PUSH	ZERO_REG
C0 0097D7: EF4A79	'.Jy'	          LCALL	L000887	; (0097DA + 31050) -> 001124 .processed.
C0 0097DA: 65040018	'e...'	          ADD	SP,#0x0004	; SP += 4
C0 0097DE: C9D007	'...'	          PUSH	#0x07D0	; MEM_WORD(SP -= 2) <- 2000
C0 0097E1: C90200	'...'	          PUSH	#0x0002	; MEM_WORD(SP -= 2) <- 2
C0 0097E4: EF3D79	'.=y'	          LCALL	L000887	; (0097E7 + 31037) -> 001124 .processed.
C0 0097E7: 65040018	'e...'	          ADD	SP,#0x0004	; SP += 4


... < many lines of code skipped > ...

Changing some of the data skip tables to disassemble the metaphor.hex and 4050.hex Shows that they have the same code and error messages. The 4050.hex that is with the munged mac disk image is quite a bit larger. It looks like there were many revisions. It is also probable that this code is a bit buggy when stressed outside the normal usage patterns.

In summery it looks like the calibration system can be re constructed through postscript and sacrificing old cameras to expose film. It is also possible to access the tables inside the programs as the films and calibration values will have shifted over the decades.

I have kept the pcdscan email address open. So feedback to that email at this domain is welcome. Perhaps someone does still have a working disk image of an installed system with the resource forks intact …

Kodak pcd Film Scanner 2000 teardown

Sometimes when you look for one thing you find another. I should really be working on the pipe organ electronics. There is no Dickens fair and my Tale of two cities puppets are waiting in the wings. But there are ever so many interesting things in this world and they are not going anywhere and I have enough projects to keep me for 500 years …

And now a distraction on top of a distraction …

While looking for surplus parts for the MIT/BYU Holo monitor; I found a Kodak pcd film scanner 2000. Something I have wanted since the 1990s. I tried to get one of these back in 2014 and missed out on the auction. The unit came as-is for parts with no cables and software.

Over the decades I have collected as much information as I could on the Kodak PhotoCD system. Probably one of the most unpopular products ever. Eventually leading to the Bankruptcy of Kodak in 2013. For this reason I find the system an amusing diversion.

In the mid 1990s I worked for Apple Imaging. Part of the Postscript test group. Among my responsibilities was creating a color test suite for the apple color laser printer. Kodak was partnering with Apple at the time. I was given the PhotoCd disk to use as reference images.

I also used PhotoCD for my vacation photos, which were taken in 3D with a stereo Realist camera. Transferring the photographs to digital made viewing easier. The PhotoCD mastering system used a Sun Workstation to drive this scanner. There is no indication Kodak ever placed drivers for the Film Scanner 2000 online.

Ted Felix has a comprehensive website detailing the structure of the PhotoCD file format. Over the decades reading these files has become well documented. As a last gasp to save PhotoCD, Kodak packaged the workstation software as a program called Build-it.

Build-it was made for both mac and PC. For some reason Kodak opted to write the drivers as Photoshop plug ins rather than a stand alone driver.

Photo CD was supposed to be for deep time digital archiving with a lifespan of 100 years. It had an active life of about 12. Still there is a bit of stuff out there that was captured in those 12 or so years.

First though I need to see what in in this 60 pound box of ” parts.” To see what the hardware entailed.

Tearing down the Film scanner 2000

The first step in getting the scanner to work is to do a complete tear down. For the most part the scanner was fairly clean. Evidence it has been in storage for some time, there was a light deposit of dust in exposed places.

Removing the cover shows the air filtration system for the lamp housing and exhaust chimney. Also visible is the line scanner camera on the right. Much of the far space is taken by the power supply. Electronics are in a card cage behind the lamp assembly and in the near foreground.

When the air filter assembly is removed, It can be seen that this is pretty much a standard slide projector lamp housing. A good thing as this one is burned out.

The iTek scanner used three of these and had a 20 minute boot up calibration cycle. In the 1990s these black body radiators were considered standard illuminates. In reading the archived literature film is considered a chemical process.

With the 250 watt Xenon halogen lamp removed we can see a filter wheel. Some collimating lenses and a rather large light pipe inside the scanning frame, center.

Removing the lower electronics assemblies reveal the three ADC chips. Unlike the RFS series scanners, Which have a rotating tri color wheel, this unit has a 3 color CCD.

Removing the cover from the card cage, The micro controller contains 4 cards. It is based on an Intel 80C196 chip. The iTek interface used an i860.

Pulling the processor card we can see that this is not a consumer item, as there are segmented LEDs and some sort of 26 pin connector debug port on each card. The boards are 6 to 8 layers. The other three boards are the stepper motor drivers, more processor support chips, and the SCIS interface.

CD plugins for Kodak scanners have updatable firmware files. There are several chips that look like E proms and memory. If this hardware is retained and the SCSI command set can not be determined from existing drivers it may be possible to dump this code to see what the functions are.

A more practical solution would be to replace the processor card with a more modern equivalent, that can directly support Ethernet, such as the STMF429. The motherboard connectors are .1 pitched and keyed. This would make replacing the processor easy, and less time consuming than reverse engineering the obsolete SCSI firmware.

With the electronics out of the way we can take a better look at the filter wheel. This contains 2 dichroic filters. There is also an optical flag for home position.

The scanner was full of dust bunnies. So I will probably nick name it Rabbit. The light pipe is open to air on one end. In this photo some of the dust can be seen behind the sealed side.

The light pipe comes apart. The backlights are replaceable items. Inside the light pipe It looks like some sort of science fiction set. There is a center post that blocks the direct path from the light pipe. This is just visible in the upper left behind a back light Fresnel screen. The back lights are filament bulbs rather than LEDs. White LEDs were pretty pricy in the mid 1990s. CFLs a bit more popular with backlit lcd displays.

Removing the cover from the camera shows two more PCB boards. The camera connects to the ADCs through RF cables. Removing the CCD heat sink screws does not release the CCD PBB. The CCD seems to be sealed to the actual camera (Camera originating from the Latin word for black chamber or box.) It is not practical to remove the CCD to find any manufactures part numbers.

The Camera assembly rides on a spring loaded focusing axis. There are several optical flags. In front of a camera is a solenoid driven aperture plate. A calibration plate shows that these units are of laboratory quality.

A modern cell phone camera does have more resolution. The advantage of the line scanner is to reduce the distortion inherent in the grid.

Sadly Google is broken (It now serves advertisements for useless consumer products, which are bad for the economy, rather than technical information that can be used for deep time (or even recent time archiving.))

With the camera removed, What remains is the mechanically dampened cross slide. There are several solenoids and a FPC ribbon connecting this to different aperture plates. This unit only came with the slide mounting aperture. The film strip scanning unit being sold separately.

in Summery

Since I wanted this to scan more non standard film frames such as produced by a stereo 3D camera, I was going to make my own aperture plate anyway. Perhaps some time I will find the film scanning unit in another online surplus store. If you have one for sale or trade contat me as “PcdScan at [ delectra domain]”

When the film scanner was re-assembled, and a new lamp installed, the scanner was powered on for the first time. The scanner booted up, then ran some sort of self calibration on the scan axis, the focus axis and the filter wheel.

A hex dump of the Kodak pcd 4050 driver, photoshop plug in showed that it seems to contain the whole of the PhotoCD imaging workstation (Piw) code much like the Buil-it app. The pcd 4050 driver is also native powerpc. The RFS 3570 driver dumps as a FAT plugin. Adobe has archived the Photoshop plug in API, so it is easy to read the driver code.

The online version of the driver is dd0656.hqx. (1.1MB created 9/8/1999 11:44:55AM.) Over the decades I have downloaded this many times. The read me implies this is an update to an earlier version It may not contain all of the libraries. When loaded into Photoshop, the plug in gave an an error “file not found.”

Using a PEF viewer, it can be seen that the code was written in C++ by a popular 1990s IDE (code warrior)

The driver code was built with debug mangled C names on most of the functions. There are two shared libraries what may be missing that relate to the photo CD system. One is called PiwColorTransformLib and the other is simply called ‘sba.’ It is actually the Scene Balance Algorithm, that I am interested in.

When my stereo pairs were scanned they were scanned with a full aperture that included parts of the surrounding image. This makes correlation when doing photogrameritry on them awkward. At Apple we said of the Kodak engineers; The Kodak motto was “Don’t make it right, make it bright.”

This project has been many decades in the making (pretty much a quarter of a century.) So I expect to keep chipping away at it. If there are any others out there who are interested or may have old offline Kodak Pcd documents libraries, firmware or drivers to share. I have set up a special email address which is “PcdScan .at. [ delectra domain]” (this is encoded, but the email address should be clear where the text in brackets is the domain of this blog.