home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / library / dos / grafik / tiftool / tiffunit.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-03-08  |  31.1 KB  |  994 lines
  1.  
  2. UNIT TIFFUNIT;
  3. {
  4.   Paul Schubert, Rottweiler Str. 8, 6000 Frankfurt 1, 069 / 231145
  5.  
  6.   DIESE UNIT STELLT DIE PROZEDUREN ZUR BEARBEITUNG VON TIFF- DATEIEN ZUR
  7.   VERFÜGUNG
  8.  
  9.   14.7.90
  10.   IN DIESER VERSION SIND NOCH KEINE MÖGLICHKEITEN ZUM SCHREIBEN EINES TIFF-
  11.   FILES ENTHALTEN.
  12.   MEHR ALS 1 IFD ( BILD ) PRO FILE WIRD NOCH NICHT UNTERSTÜTZT.
  13.  
  14.  
  15.   DANK AN TORSTEN PRIEBE, VON DEM ICH DIE TIFF- SPEZIFIKATION UND
  16.   DIE LISTE DER TAG- NAMEN ERHALTEN HABE
  17.  
  18. }
  19.  
  20. INTERFACE
  21. {$F+}
  22.  
  23.  
  24. { TURBO PROFESSIONAL VERWENDEN - ANSONSTEN .$DEFINE SCHREIBEN }
  25. {$DEFINE TPROF}
  26. { UNIT BUFFILE VERWENDEN       - ANSONSTEN .$DEFINE SCHREIBEN }
  27. {.$DEFINE FILEBUFFER }
  28.  
  29. USES
  30. {$IFDEF TPROF}
  31.       TPCRT,TPSTRING
  32. {$ELSE}
  33.       CRT,TPERSATZ
  34. {$ENDIF}
  35. {$IFDEF FILEBUFFER }
  36.       ,BUFFILE
  37. {$ENDIF}
  38.       ,DOS,VIDEO;
  39.  
  40.  
  41. CONST IFDMAX     = 100;  { MAXIMALE ANZAHL EINTRÄGE IM IFD }
  42.       STRIPMAX   = 200;  { MAXIMALE ANZAHL STRIPS }
  43.       PLAINMAX   = 3;    { MAXIMALE ANZAHL PLANES }
  44.  
  45.  
  46. TYPE  TIFFHDRTYP = RECORD
  47.         O     : WORD;    { BYTEORDER 'II' = LOHI, 'MM' = HILO }
  48.         ID    : WORD;    { MUß 42 SEIN ! }
  49.         IFDP  : LONGINT; { POINTER AUF 1. IFD }
  50.         S     : LONGINT; { FILESIZE - STEHT NICHT IM FILE }
  51.       END;
  52.  
  53.       IFETYP = RECORD
  54.         TA,TY : WORD;    { TAG / TYP }
  55.         L,V   : LONGINT; { LÄNGE / VALUE ( POINTER ) }
  56.       END;
  57.  
  58.       TIFFIFDTYP = RECORD
  59.         N     : WORD;    { ANZAHL EINTRÄGE IM IFD }
  60.         NX    : LONGINT; { POINTER AUF NÄCHSTES IFD }
  61.         I     : ARRAY[1..IFDMAX] OF IFETYP;
  62.       END;
  63.  
  64.       STRIPTYP = RECORD
  65.         O,B   : LONGINT;
  66.       END;
  67.  
  68.       REALTYP = ARRAY[0..1] OF LONGINT;
  69.  
  70.  
  71. { Die Namen aller Tags }
  72. Const TagNames: Array[$FD..$140] Of String[20]= { 20 Zeichen }
  73. {I 0FD 253} ('TIFF Class          ',
  74. {? 0FE 254}  'NewSubfileType      ',
  75. {A 0FF 255}  'SubfileType         ',
  76. {! 100 256}  'ImageWidth          ',
  77. {! 101 257}  'ImageLength         ',
  78. {! 102 258}  'BitsPerSample       ',
  79. {! 103 259}  'Compression         ',
  80. {  104 260}  '?                   ',
  81. {  105 261}  '?                   ',
  82. {! 106 262}  'PhotometricInterp.  ',
  83. {A 107 263}  'Threshholding       ',
  84. {A 108 264}  'CellWidth           ',
  85. {A 109 265}  'CellLength          ',
  86. {A 10A 266}  'FillOrder           ',
  87. {  10B 267}  '?                   ',
  88. {  10C 268}  '?                   ',
  89. {I 10D 269}  'DocumentName        ',
  90. {I 10E 270}  'ImageDescription    ',
  91. {I 10F 271}  'Make                ',
  92. {I 110 272}  'Model               ',
  93. {! 111 273}  'StripOffsets        ',
  94. {A 112 274}  'Orientation         ',
  95. {  113 275}  '?                   ',
  96. {  114 276}  '?                   ',
  97. {  115 277}  'SamplesPerPixel     ',
  98. {! 116 278}  'RowsPerStrip        ',
  99. {! 117 279}  'StripByteCounts     ',
  100. {A 118 280}  'MinSampleValue      ',
  101. {A 119 281}  'MaxSampleValue      ',
  102. {I 11A 282}  'XResolution         ',
  103. {I 11B 283}  'YResolution         ',
  104. {! 11C 284}  'PlanarConfiguration ',
  105. {I 11D 285}  'PageName            ',
  106. {  11E 286}  'XPosition           ',
  107. {  11F 287}  'YPosition           ',
  108. {A 120 288}  'FreeOffsets         ',
  109. {A 121 289}  'FreeByteCounts      ',
  110. {  122 290}  'GrayResponseUnit    ',
  111. {  123 291}  'GrayResponseCurve   ',
  112. {  124 292}  'Group3Options       ',
  113. {  125 293}  'Group4Options       ',
  114. {  126 294}  '?                   ',
  115. {  127 295}  '?                   ',
  116. {I 128 296}  'ResolutionUnit      ',
  117. {I 129 297}  'PageNumber          ',
  118. {  12A 298}  '?                   ',
  119. {  12B 299}  '?                   ',
  120. {  12C 300}  '?                   ',
  121. {  12D 301}  'ColorResponseCurves ',
  122. {  12E 302}  '?                   ',
  123. {  12F 303}  '?                   ',
  124. {  130 304}  '?                   ',
  125. {I 131 305}  'SoftWare            ',
  126. {I 132 306}  'DateTime            ',
  127. {  133 307}  'ScreenFrequency     ',
  128. {  134 308}  'ScreenAngle         ',
  129. {  135 309}  'ScrennPattern       ',
  130. {  136 310}  'SpotFunction        ',
  131. {  137 311}  'InvertSpotFunction  ',
  132. {  138 312}  'TransferFunction    ',
  133. {  139 313}  'InvertTransferFunct.',
  134. {  13A 314}  'InkColor            ',
  135. {I 13B 315}  'Artist              ',
  136. {I 13C 316}  'HostComputer        ',
  137. {! 13D 317}  'Predictor           ',
  138. {  13E 318}  'WhitePoint          ', { TargetPrinter ASCII     LT. C'T 7/90 }
  139. {  13F 319}  'PrimaryChromaticitie', { StripByteCountMax SHORT LT. C'T 7/90 }
  140. {  140 320}  'ColorMap            ');
  141.  
  142.  
  143. VAR   TIFF          : FILE;
  144.       HDR           : TIFFHDRTYP;  { TIFF HEADER }
  145.       IFD           : TIFFIFDTYP;  { IMAGE FILE DIRECTORY }
  146.       BOR           : BOOLEAN;     { BYTEORDER REVERS }
  147.       TIFERR        : WORD;        { FEHLER- NUMMER FÜR OPENTIFF }
  148.       STP           : WORD;        { LAUFENDE NR. AKTUELLER STRIP }
  149.       SBC           : LONGINT;     { BYTECOUNT AKTUELLER STRIP }
  150.       BBC           : BYTE;        { BITCOUNT FÜR GETBITS }
  151.  
  152. { TIFF- VARIABLE MIT DEFAULT- WERTEN }
  153.       TIFCL         : BYTE; { TIFF- CLASS }
  154.       NSFT          : BYTE; { NEW SUBFILE TYPE }
  155.       SFT           : BYTE; { SUBFILE TYPE }
  156.       BPS           : ARRAY[0..PLAINMAX] OF LONGINT; { BITS PER SAMPLE }
  157.       COMPR         : WORD; { COMPRESSION, DEFAULT = KEINE }
  158.       PHINT         : BYTE; { PHOTOMETRIC INTERPRETATION }
  159.       SPP           : BYTE; { SAMPLES PER PIXEL }
  160.       RPS           : WORD; { ROWS PER STRIP }
  161.       XRES          : REALTYP; { X- AUFLÖSUNG }
  162.       YRES          : REALTYP; { Y- AUFLÖSUNG }
  163.       PLC           : BYTE; { PLANAR CONFIGURATION }
  164.       RESU          : BYTE; { EINHEIT FÜR AUFLÖSUNG }
  165.       CPRED         : BYTE; { PREDICTOR FÜR COMPRESSION 5 }
  166.  
  167.       STRC          : WORD; { ANZAHL STRIPS }
  168. { OFFSETS UND BYTECOUNTS PRO STRIP }
  169.       STRI          : ARRAY[1..STRIPMAX] OF STRIPTYP;
  170.       BLNEG         : BYTE; { BILEVEL NEGATIV }
  171.       FO            : BYTE; { FILLORDER }
  172.       IMGWID        : WORD; { BILD BREITE }
  173.       IMGHIG        : WORD; { BILD HÖHE }
  174.  
  175. { GRAY RESPONSE CURVE }
  176.       GRC           : ARRAY[1..256] OF LONGINT;
  177.       GRCC          : WORD; { GRAY RESPONSE CURVE COUNT }
  178.       GRU           : WORD; { GRAY RESPONSE UNIT }
  179.  
  180.  
  181. PROCEDURE GRAYCURVE256;
  182. PROCEDURE CLOSETIFF;
  183. PROCEDURE TIFFEHLERMELDUNG;
  184. FUNCTION  OPENTIFF(NAME:STRING):BOOLEAN;
  185. FUNCTION  ZEIGETIFF(VAR NAME:STRING;WARTEN:BOOLEAN):CHAR;
  186. PROCEDURE GETBITS(ANZ:BYTE);
  187. PROCEDURE LIESCCITTRUN(SCHW:BOOLEAN;VAR BITS:WORD;VAR BV:BYTE);
  188.  
  189.  
  190. IMPLEMENTATION
  191.  
  192.  
  193. VAR   BITBUF,PP  : BYTE;
  194.  
  195.  
  196. { ********************************************************* }
  197.  
  198.  
  199. PROCEDURE GRAYCURVE256;
  200. VAR   VP  : ^VGAPALETTETYPE;
  201.       I   : WORD;
  202.       R   : REAL;
  203.       GM  : LONGINT;
  204. BEGIN
  205.   IF GRCC = 0 THEN GRAYSCALE256 ELSE BEGIN
  206.  
  207.     GM := 0;
  208.     FOR I := 1 TO GRCC DO IF GRC[I] > GM THEN GM := GRC[I];
  209.     R := 63; R := R / GM;
  210.  
  211. { 256- STUFIGE GRAUSKALA EINSTELLEN }
  212.   GETMEM(VP,SIZEOF(VGAPALETTETYPE));
  213.     FOR I := 0 TO 255 DO BEGIN
  214.     VP^[I].R := 63 - ROUND(GRC[SUCC(I)] * R);
  215.     VP^[I].R := ROUND(GRC[256 - I] * R);
  216.     VP^[I].G := VP^[I].R;
  217.     VP^[I].B := VP^[I].R;
  218.   END;
  219.   VGASETALLPALETTE(VP^);
  220.   FREEMEM(VP,SIZEOF(VGAPALETTETYPE));
  221.  
  222.   END;
  223. END;
  224.  
  225.  
  226. FUNCTION SWAPLONG(L:LONGINT):LONGINT;
  227. VAR   W  : ARRAY[0..1] OF WORD ABSOLUTE L;
  228.       I  : WORD;
  229. BEGIN
  230.   I    := SWAP(W[0]);
  231.   W[0] := SWAP(W[1]);
  232.   W[1] := I;
  233. END; { SWAPLONG }
  234.  
  235.  
  236. FUNCTION MIN(A,B:WORD):WORD;
  237. BEGIN
  238.   IF A < B THEN MIN := A ELSE MIN := B;
  239. END; { MIN }
  240.  
  241.  
  242. FUNCTION FREADWORD:WORD;
  243. VAR   W  : WORD;
  244. BEGIN
  245.   BLOCKREAD(TIFF,W,2);
  246.   IF BOR THEN FREADWORD := SWAP(W) ELSE FREADWORD := W;
  247. END; { FREADWORD }
  248.  
  249.  
  250. FUNCTION FREADLONG:LONGINT;
  251. VAR   L  : LONGINT;
  252. BEGIN
  253.   BLOCKREAD(TIFF,L,4);
  254.   IF BOR THEN FREADLONG := SWAPLONG(L) ELSE FREADLONG := L;
  255. END; { FREADLONG }
  256.  
  257.  
  258. PROCEDURE FREADWERT(TYP:BYTE;VAR DATA);
  259. VAR   W  : WORD;
  260.       L  : LONGINT;
  261. BEGIN
  262.   CASE TYP OF
  263.     1 : BLOCKREAD(TIFF,DATA,1);
  264.     3 : BEGIN
  265.           W := FREADWORD;
  266.           MOVE(W,DATA,2);
  267.         END;
  268.     4 : BEGIN
  269.           L := FREADLONG;
  270.           MOVE(L,DATA,4);
  271.         END;
  272.   END;
  273. END; { FREADWERT }
  274.  
  275.  
  276. PROCEDURE ZEIGETAG(NR:WORD);
  277. VAR   I      : WORD;
  278.       L1,L2  : LONGINT;
  279.       B      : BYTE;
  280.       W      : WORD;
  281.       CH1    : CHAR;
  282. BEGIN
  283.   WITH IFD.I[NR] DO BEGIN
  284.     IF (TA >= $FD) AND (TA <= $140) THEN BEGIN
  285.       IF TAGNAMES[TA][1] = '?' THEN BEGIN
  286.         WRITE(HEXW(TA),' Tag unbekannt  ');
  287.       END ELSE BEGIN
  288.         WRITE(TAGNAMES[TA]);
  289.       END;
  290.     END ELSE BEGIN
  291.       IF TA >= $8000 THEN WRITE(HEXW(TA),' Privat         ')
  292.                      ELSE WRITE(HEXW(TA),' Tag unbekannt  ');
  293.     END; { CASE TA }
  294.     CASE TY OF
  295.       1 : BEGIN
  296.             WRITE(' B');
  297.             IF L = 1 THEN WRITE(V:8) ELSE BEGIN
  298.               SEEK(TIFF,V);
  299.               FOR I := 1 TO MIN(3,L) DO BEGIN
  300.                 BLOCKREAD(TIFF,B,1);
  301.                 WRITE(B);
  302.                 IF I < L THEN WRITE(',');
  303.               END; { NEXT I }
  304.             END;
  305.           END;
  306.       2 : BEGIN
  307.             WRITE(' "');
  308.             SEEK(TIFF,V);
  309.             REPEAT
  310.               BLOCKREAD(TIFF,CH1,1);
  311.               IF CH1 <> #0 THEN WRITE(CH1);
  312.             UNTIL CH1 = #0;
  313.             WRITE('"');
  314.           END;
  315.       3 : BEGIN
  316.             WRITE(' W');
  317.             IF L = 1 THEN WRITE(V:8) ELSE BEGIN
  318.               WRITE(' ');
  319.               SEEK(TIFF,V);
  320.               FOR I := 1 TO MIN(3,L) DO BEGIN
  321.                 BLOCKREAD(TIFF,W,2);
  322.                 IF BOR THEN W := SWAP(W);
  323.                 WRITE(W);
  324.                 IF I < L THEN WRITE(',');
  325.               END; { NEXT I }
  326.             END;
  327.           END;
  328.       4 : BEGIN
  329.             WRITE(' L');
  330.             IF L = 1 THEN WRITE(V:8) ELSE BEGIN
  331.               WRITE(' ');
  332.               SEEK(TIFF,V);
  333.               FOR I := 1 TO MIN(3,L) DO BEGIN
  334.                 BLOCKREAD(TIFF,L1,4);
  335.                 IF BOR THEN L1 := SWAPLONG(L1);
  336.                 WRITE(L1);
  337.                 IF I < L THEN WRITE(',');
  338.               END; { NEXT I }
  339.             END;
  340.           END;
  341.       5 : BEGIN
  342.             WRITE(' R ');
  343.             SEEK(TIFF,V);
  344.             FOR I := 1 TO MIN(3,L) DO BEGIN
  345.               BLOCKREAD(TIFF,L1,4);
  346.               BLOCKREAD(TIFF,L2,4);
  347.               IF BOR THEN BEGIN
  348.                 L1 := SWAPLONG(L1);
  349.                 L2 := SWAPLONG(L2);
  350.               END;
  351.               WRITE(L2,'/',L1);
  352.               IF I < L THEN WRITE(',');
  353.             END; { NEXT I }
  354.           END;
  355.     ELSE
  356.       WRITE('   ? TYP ?');
  357.     END; { CASE TY OF }
  358.   END; { WITH IFD.I[NR] }
  359. END; { ZEIGETAG }
  360.  
  361. { ********************************************************* }
  362.  
  363.  
  364. PROCEDURE CLOSETIFF; { CLOSE WENN OFFEN }
  365. BEGIN
  366. {$I-}
  367.   IF (FILEREC(TIFF).MODE = $D7B1) OR
  368.      (FILEREC(TIFF).MODE = $D7B2) OR
  369.      (FILEREC(TIFF).MODE = $D7B3)
  370.         THEN CLOSE(TIFF);
  371. {$I+}
  372. {$IFDEF FILEBUFFER}
  373.   BCLOSE(1);
  374. {$ENDIF}
  375. END;
  376.  
  377.  
  378. PROCEDURE TIFFEHLERMELDUNG;
  379. VAR   CH1  : CHAR;
  380. BEGIN
  381.   CASE TIFERR OF
  382.     0 : EXIT;
  383.     1 : WRITELN('File nicht gefunden');
  384.     2 : WRITELN('File Lesefehler');
  385.     3 : WRITELN('Byteorder falsch : ',HEXW(HDR.O));
  386.     4 : WRITELN('TIFF- Version falsch : ',HEXW(HDR.ID));
  387.     5 : WRITELN('1. IFD- Pointer falsch : ',HEXL(HDR.IFDP));
  388.     6 : WRITELN('IFD- ist zu groß : ',IFD.N,IFDMAX:5,' ist möglich');
  389.     7 : WRITELN('nicht interpretierbarer Eintrag in IFD');
  390.   ELSE
  391.     WRITELN('unbekannter Fehler');
  392.   END;
  393. END; { TIFFEHLERMELDUNG }
  394.  
  395.  
  396. FUNCTION OPENTIFF(NAME:STRING):BOOLEAN;
  397. VAR   I,J,W  : WORD;
  398.       L      : LONGINT;
  399. BEGIN
  400. { TIFF- VARIABLE MIT DEFAULT- WERTEN BELEGEN }
  401.   TIFCL   := 0; { TIFF - KLASSE }
  402.   STRC    := 1;
  403.   NSFT    := 0; { NEW SUBFILE TYPE }
  404.   SFT     := 0; { SUBFILE TYPE }
  405.   BPS[0]  := 1; { BITS PER SAMPLE }
  406.   BPS[1]  := 1; { BITS PER SAMPLE }
  407.   COMPR   := 1; { COMPRESSION, DEFAULT = KEINE }
  408.   PHINT   := 0; { PHOTOMETRIC INTERPRETATION }
  409.   SPP     := 1; { SAMPLES PER PIXEL }
  410.   RPS     := 0; { ROWS PER STRIP }
  411.   XRES[0] := 0; { X- AUFLÖSUNG }
  412.   XRES[1] := 0; { X- AUFLÖSUNG }
  413.   YRES[0] := 0; { Y- AUFLÖSUNG }
  414.   YRES[1] := 0; { X- AUFLÖSUNG }
  415.   PLC     := 1; { PLANAR CONFIGURATION }
  416.   RESU    := 2; { EINHEIT FÜR AUFLÖSUNG }
  417.   CPRED   := 1; { PREDICTOR FÜR COMPRESSION 5 }
  418.   BLNEG   := 0; { BILEVEL POSITIV }
  419.   FO      := 1; { FILLORDER MSBIT FIRST }
  420.   FILLCHAR(STRI,SIZEOF(STRI),#0);
  421.   GRCC    := 0; { GRAY RESPONSE CURVE COUNT }
  422.   FILLCHAR(GRC,SIZEOF(GRC),#0);
  423.  
  424. {$I-}
  425.   OPENTIFF := FALSE;
  426.   ASSIGN(TIFF,NAME);
  427.   TIFERR := 1;
  428.   RESET(TIFF,1);
  429.   IF IORESULT <> 0 THEN EXIT;
  430.  
  431. {$IFDEF FILEBUFFER}
  432.   IF NOT BOPEN(1,20000) THEN EXIT;
  433. {$ENDIF}
  434.  
  435. { HEADER EINLESEN }
  436.   TIFERR := 2;
  437.   BLOCKREAD(TIFF,HDR,SIZEOF(HDR));
  438.   IF IORESULT <> 0 THEN EXIT;
  439.   CASE HDR.O OF
  440.     $4949 : BEGIN
  441.               BOR := FALSE;
  442.             END;
  443.     $4D4D : BEGIN
  444.               BOR := TRUE;
  445.               HDR.ID := SWAP(HDR.ID);
  446.               HDR.IFDP := SWAPLONG(HDR.IFDP);
  447.             END;
  448.   ELSE
  449.     TIFERR := 3;
  450.     EXIT;
  451.   END;
  452.   HDR.S := FILESIZE(TIFF);
  453.   TIFERR := 4;
  454.   IF HDR.ID <> 42 THEN EXIT;
  455.   TIFERR := 5;
  456.   IF HDR.IFDP >= HDR.S THEN EXIT;
  457.  
  458. { 1. IFD EINLESEN }
  459.   SEEK(TIFF,HDR.IFDP);
  460.   TIFERR := 2;
  461.   BLOCKREAD(TIFF,IFD.N,2);
  462.   IF IORESULT <> 0 THEN EXIT;
  463.   IF BOR THEN IFD.N := SWAP(IFD.N);
  464.   IF IFD.N > IFDMAX THEN BEGIN
  465. { IFD IST ZU GROß }
  466.     TIFERR := 6;
  467.     EXIT;
  468.   END;
  469.   BLOCKREAD(TIFF,IFD.I,IFD.N * 12);
  470.   IF IORESULT <> 0 THEN EXIT;
  471. { OFFENBAR MUß NICHT UNBEDINGT EIN NEXT-IFD-POINTER VORHANDEN SEIN ? }
  472.   BLOCKREAD(TIFF,IFD.NX,4);
  473.   IF IORESULT <> 0 THEN IFD.NX := 0 {EXIT};
  474. {}
  475.   IF BOR THEN BEGIN
  476.     IFD.NX := SWAPLONG(IFD.NX);
  477.     FOR I := 1 TO IFD.N DO BEGIN
  478.       IFD.I[I].TA := SWAP(IFD.I[I].TA);
  479.       IFD.I[I].TY := SWAP(IFD.I[I].TY);
  480.       IFD.I[I].L  := SWAPLONG(IFD.I[I].L);
  481.       IFD.I[I].V  := SWAPLONG(IFD.I[I].V);
  482.     END;
  483.   END;
  484.  
  485. { WERTE AUS IFD IN VARIABLE ÜBERTRAGEN }
  486.   TIFERR := 7;
  487.   FOR I := 1 TO IFD.N DO BEGIN
  488.     WITH IFD.I[I] DO BEGIN
  489.       CASE TA OF
  490.          $FD : BEGIN { TIFF CLASS }
  491.                  IF L <> 1 THEN EXIT;
  492.                  TIFCL := V;
  493.                END;
  494.          $FE : BEGIN { NEW SUBFILE TYPE }
  495.                  IF L <> 1 THEN EXIT;
  496.                  NSFT := V;
  497.                END;
  498.          $FF : BEGIN { SUBFILE TYPE }
  499.                  IF L <> 1 THEN EXIT;
  500.                  SFT := V;
  501.                END;
  502.         $100 : BEGIN { IMAGE WIDTH }
  503.                  IF L <> 1 THEN EXIT;
  504.                  IMGWID := V;
  505.                END;
  506.         $101 : BEGIN { IMAGE HEIGHT }
  507.                  IF L <> 1 THEN EXIT;
  508.                  IMGHIG := V;
  509.                END;
  510.         $102 : BEGIN { BITS PER SAMPLE - PRO PLANE }
  511.                  BPS[0] := L;
  512.                  IF L = 1 THEN BPS[1] := V ELSE BEGIN
  513.                    SEEK(TIFF,V);
  514.                    FOR J := 1 TO MIN(PLAINMAX,L) DO BEGIN
  515.                      FREADWERT(TY,BPS[J]);
  516.                    END;
  517.                  END;
  518.                END;
  519.         $103 : BEGIN { COMPRESSION }
  520.                  IF L <> 1 THEN EXIT;
  521.                  COMPR := V;
  522.                END;
  523.         $106 : BEGIN { PHOTOMETRIC INTERPRETATION }
  524.                  IF L <> 1 THEN EXIT;
  525.                  PHINT := V;
  526.                  IF PHINT = 1 THEN BLNEG := $FF;
  527.                END;
  528.         $10A : BEGIN { FILLORDER }
  529.                  IF L <> 1 THEN EXIT;
  530.                  FO := V;
  531.                END;
  532.         $111 : BEGIN { STRIP OFFSETS }
  533.                  STRC := L;
  534.                  IF STRC > STRIPMAX THEN STRC := STRIPMAX;
  535.                  IF L = 1 THEN STRI[1].O := V ELSE BEGIN
  536.                    SEEK(TIFF,V);
  537.                    FOR J := 1 TO STRC DO BEGIN
  538.                      FREADWERT(TY,STRI[J].O);
  539.                    END;
  540.                  END;
  541.                END;
  542.         $115 : BEGIN { SAMPLES PER PIXEL }
  543.                  IF L <> 1 THEN EXIT;
  544.                  SPP := V;
  545.                END;
  546.         $116 : BEGIN { ROWS PER STRIP }
  547.                  IF L <> 1 THEN EXIT;
  548.                  RPS := V;
  549.                END;
  550.         $117 : BEGIN { STRIP BYTECOUNTS }
  551. {@@@}
  552.                  IF L <= STRIPMAX THEN BEGIN
  553.                    IF STRC <> L THEN EXIT;
  554.                  END;
  555.                  IF L = 1 THEN STRI[1].B := V ELSE BEGIN
  556.                    SEEK(TIFF,V);
  557.                    FOR J := 1 TO STRC DO BEGIN
  558.                      FREADWERT(TY,STRI[J].B);
  559.                    END;
  560.                  END;
  561.                END;
  562.         $11A : BEGIN { X- RESOLUTION }
  563.                  IF L <> 1 THEN EXIT;
  564.                  SEEK(TIFF,V);
  565.                  BLOCKREAD(TIFF,XRES,8);
  566.                  IF BOR THEN BEGIN
  567.                    XRES[0] := SWAPLONG(XRES[0]);
  568.                    XRES[1] := SWAPLONG(XRES[1]);
  569.                  END;
  570.                END;
  571.         $11B : BEGIN { Y- RESOLUTION }
  572.                  IF L <> 1 THEN EXIT;
  573.                  SEEK(TIFF,V);
  574.                  BLOCKREAD(TIFF,YRES,8);
  575.                  IF BOR THEN BEGIN
  576.                    YRES[0] := SWAPLONG(YRES[0]);
  577.                    YRES[1] := SWAPLONG(YRES[1]);
  578.                  END;
  579.                END;
  580.         $11C : BEGIN { PLANAR CONFIGURATION }
  581.                  IF L <> 1 THEN EXIT;
  582.                  PLC := V;
  583.                END;
  584.         $122 : BEGIN { GRAY RESPONSE UNIT }
  585.                  IF L <> 1 THEN EXIT;
  586.                  GRU := V;
  587.                END;
  588.         $123 : BEGIN { GRAY RESPONSE CURVE }
  589.                  IF L = 1 THEN EXIT; { GRAUKEIL MIT 1 WERT IGNORIEREN }
  590.                  GRCC := L;
  591.                  SEEK(TIFF,V);
  592.                  FOR J := 1 TO MIN(256,L) DO BEGIN
  593.                    FREADWERT(TY,GRC[J]);
  594.                  END;
  595.                END;
  596.         $128 : BEGIN { RESOLUTION UNIT }
  597.                  IF L <> 1 THEN EXIT;
  598.                  RESU := V;
  599.                END;
  600.         $12D : BEGIN { COMPRESSION PREDICTOR FÜR LZW- KOMPRESSION }
  601.                  IF L <> 1 THEN EXIT;
  602.                  CPRED := V;
  603.                END;
  604.       END; { CASE IFD.I[I].TA }
  605.     END; { WITH IFD.I[I] }
  606.   END; { NEXT I }
  607. { TIFF- KLASSE FESTLEGEN }
  608.   IF TIFCL = 0 THEN BEGIN
  609.     CASE PHINT OF
  610.       0,1 : BEGIN
  611.               IF BPS[1] = 1 THEN TIFCL := 1  { CLASS B - BILEVEL }
  612.                             ELSE TIFCL := 2; { CLASS G - GRAYSCALE }
  613.             END;
  614.         2 : BEGIN
  615.               TIFCL := 4; { CLASS R - RGB }
  616.               IF SPP <> 3 THEN TIFCL := 0;
  617.             END;
  618.         3 : BEGIN
  619.               TIFCL := 3; { CLASS P - PALETTE }
  620.               IF SPP <> 1 THEN TIFCL := 0;
  621.             END;
  622.     ELSE
  623.       TIFCL := 0;
  624.     END; { CASE PHINT OF }
  625.   END; { IF TIFCL = 0 }
  626.  
  627.  
  628.   TIFERR := 0;
  629.   OPENTIFF := TRUE;
  630. END; { OPENTIFF }
  631.  
  632.  
  633. FUNCTION ZEIGETIFF(VAR NAME:STRING;WARTEN:BOOLEAN):CHAR;
  634. VAR  I,J     : WORD;
  635.      CH1     : CHAR;
  636. BEGIN
  637.   IF NOT OPENTIFF(NAME) THEN BEGIN
  638.     WRITELN('FEHLER BEIM LESEN FILE ',NAME);
  639.     TIFFEHLERMELDUNG;
  640.     IF WARTEN THEN BEGIN
  641.       WRITELN('Taste drücken ');
  642.       CH1 := READKEY; IF CH1 = #0 THEN CH1 := READKEY;
  643.     END;
  644.   END ELSE BEGIN
  645.     WRITE(NAME:24,'  ');
  646.     WRITE('Filegröße ',HDR.S);
  647.     WRITE('   Order = ');
  648.     IF BOR THEN WRITE('Highbyte first    ')
  649.            ELSE WRITE('Lowbyte first     ');
  650.     WRITELN;
  651.  
  652.     CASE TIFCL OF
  653.       1 : WRITE('TIFF- Klasse B            ');
  654.       2 : WRITE('TIFF- Klasse G            ');
  655.       3 : WRITE('TIFF- Klasse P            ');
  656.       4 : WRITE('TIFF- Klasse R            ');
  657.     ELSE
  658.       WRITE('TIFF- Klasse unbekannt    ');
  659.     END; { CASE TIFCL }
  660.     CASE PHINT OF
  661.       0,1 : BEGIN
  662.               IF BPS[1] = 1 THEN WRITE('Bilevel ') ELSE WRITE('Grayscale ');
  663.               IF PHINT = 0 THEN WRITE('positiv') ELSE WRITE('negativ');
  664.             END;
  665.         2 : WRITE('RGB');
  666.         3 : WRITE('Palette Color');
  667.         4 : WRITE('Transparency Mask');
  668.         5 : WRITE('Separation Layer');
  669.     ELSE
  670.       WRITE('PhotometricInt. ',PHINT,' UNBEKANNT');
  671.     END; { CASE PHINT }
  672.     IF PHINT > 1 THEN BEGIN
  673.       CASE PLC OF
  674.         1 : WRITE(' single Plane');
  675.         2 : BEGIN
  676.               WRITE(SPP:3);
  677.               WRITE(' separate Planes');
  678.             END;
  679.       ELSE
  680.         WRITE('PlanarConf. ',PLC,' UNBEKANNT');
  681.       END; { CASE PLINT }
  682.     END;
  683.     IF BPS[1] > 1 THEN WRITE(' ',BPS[1],' Bit/Sample');
  684.     WRITELN;
  685.  
  686.     CASE SFT OF
  687.       0 : BEGIN
  688.             IF NSFT = 0 THEN WRITE('full Resolution           ');
  689.             IF (NSFT AND 1) <> 0 THEN WRITE('reduced Resolution        ');
  690.             IF (NSFT AND 2) <> 0 THEN WRITE('single Page of Multipage  ');
  691.             IF (NSFT AND 4) <> 0 THEN WRITE('Transparency Mask         ');
  692.             IF (NSFT AND 8) <> 0 THEN WRITE('Separation Layer          ');
  693.           END;
  694.       1 : WRITE('full Resolution           ');
  695.       2 : WRITE('reduced Resolution        ');
  696.       3 : WRITE('single Page of Multipage  ');
  697.     ELSE
  698.       WRITE('Subfile Type UNBEKANNT');
  699.     END; { CASE SFT }
  700.     WRITE('Kompression : ');
  701.     CASE COMPR OF
  702.       1 : WRITE('keine');
  703.       2 : WRITE('CCITT Group 3, 1- Dimensional');
  704.       3 : WRITE('FAX CCITT Group 3');
  705.       4 : WRITE('FAX CCITT Group 4');
  706.       5 : BEGIN
  707.             WRITE('LZW ');
  708.             IF CPRED <> 1 THEN WRITE('Predictor ',CPRED,' UNBEKANNT');
  709.           END;
  710.     ELSE
  711.       IF COMPR = $8005 THEN WRITE('PackBits')
  712.                        ELSE WRITE('UNBEKANNT');
  713.     END; { CASE COMPR }
  714.     WRITELN;
  715.  
  716.     WRITE('X- Auflösung ',XRES[1],'/',XRES[0]);
  717.     CASE RESU OF
  718.       2 : WRITE(' Zoll');
  719.       3 : WRITE(' cm  ');
  720.     ELSE
  721.       WRITE('     ');
  722.     END; { CASE RESU }
  723.     WRITE('   ');
  724.     WRITE('Y- Auflösung ',YRES[1],'/',YRES[0]);
  725.     CASE RESU OF
  726.       2 : WRITE(' Zoll');
  727.       3 : WRITE(' cm');
  728.     END; { CASE RESU }
  729.     IF STRC > 1 THEN WRITE(STRC:7,' Strips');
  730.     WRITELN;
  731.  
  732.     WRITE(IFD.N,' TAGs, IFD- Adresse = ',HDR.IFDP);
  733.     IF IFD.NX <> 0 THEN WRITE('  next IFD = ',IFD.NX);
  734.     WRITELN;
  735.  
  736.     FOR I := 1 TO IFD.N DO BEGIN
  737.       ZEIGETAG(I);
  738.       IF WHEREX > 40 THEN WRITELN ELSE GOTOXY(40,WHEREY);
  739.     END; { NEXT I }
  740.   END;
  741.  
  742.   TEXTATTR := $4E;
  743.   GOTOXY(1,25);
  744.   CLREOL;
  745.   WRITE('<Esc> = Programm Ende, '' '' = Bild ansehen, andere Taste = File auswählen');
  746.   TEXTATTR := $07;
  747.  
  748.   IF WARTEN THEN BEGIN
  749.     CH1 := READKEY; IF CH1 = #0 THEN CH1 := READKEY;
  750.   END ELSE CH1 := ' ';
  751.   GOTOXY(1,25);
  752.   CLREOL;
  753.   ZEIGETIFF := CH1;
  754. END; { ZEIGETIFF }
  755.  
  756.  
  757. PROCEDURE GETBITS(ANZ:BYTE);
  758. VAR   I  : BYTE;
  759.       J  : INTEGER;
  760. BEGIN
  761.   FOR I := 1 TO ANZ DO BEGIN
  762.     IF BBC = 0 THEN BEGIN
  763. {$IFDEF FILEBUFFER }
  764.       BGET(1,TIFF,@PP,1);
  765. {$ELSE}
  766.       BLOCKREAD(TIFF,PP,1,J);
  767. {$ENDIF}
  768.       DEC(SBC);
  769.       BBC := 8;
  770.     END;
  771.     BITBUF := BITBUF SHL 1;
  772.     IF (PP AND $80) <> 0 THEN INC(BITBUF);
  773.     PP := PP SHL 1;
  774.     DEC(BBC);
  775.   END; { NEXT I }
  776. END; { GETBITS }
  777.  
  778.  
  779. { SETZT BV AUF SCHWARZ/WEIß UND BITS AUF RUNLENGTH }
  780. PROCEDURE LIESCCITTRUN(SCHW:BOOLEAN;VAR BITS:WORD;VAR BV:BYTE);
  781. CONST T2 : ARRAY[0.. 3] OF BYTE =
  782.            ($FF,$FF,$83,$82);
  783.       T3 : ARRAY[0.. 7] OF BYTE =
  784.            ($FF,$FF,$81,$84,$FF,$FF,$FF,$FF);
  785.       T4 : ARRAY[0..15] OF BYTE =
  786.            ($FF,$FF,$86,$85,$FF,$FF,$FF,  2,   3,$FF,$FF,  4,  5,$FF,  6,  7);
  787.       T5 : ARRAY[0..31] OF BYTE =
  788.            ($FF,$FF,$FF,$87,$FF,$FF,$FF, 10,  11,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  789.             $FF,$FF,$42,  8,  9,$FF,$FF,$FF, $FF,$FF,$FF,$41,$FF,$FF,$FF,$FF);
  790.       T6 : ARRAY[0..63] OF BYTE =
  791.            ($FF,$FF,$FF, 13,$89,$88,$FF,  1,  12,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  792.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$43, $5A,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  793.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF, 16, 17,$FF,$FF,$FF,$FF,
  794.             $FF,$FF,$FF,$FF, 14, 15,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF);
  795.       T7 : ARRAY[0..63] OF BYTE =
  796.            ($FF,$FF,$FF, 22, 23,$8B,$FF,$8C,  20,$FF,$FF,$FF, 19,$FF,$FF,$FF,
  797.             $FF,$FF,$FF, 26,$FF,$FF,$FF, 21,  28,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  798.             $FF,$FF,$FF,$FF, 27,$FF,$FF, 18,  24,$FF,$FF, 25,$FF,$FF,$FF,$FF,
  799.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$44, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF);
  800.       T8 : ARRAY[0..127] OF BYTE =
  801.            ($FF,$FF, 29, 30, 45, 46,$FF,$8E, $FF,$FF, 47, 48,$FF,$FF,$FF,$FF,
  802.             $FF,$FF, 33, 34, 35, 36, 37, 38, $FF,$FF, 31, 32,$FF,$FF,$FF,$FF,
  803.             $FF,$FF,$FF,$FF, 53, 54,$FF,$FF,  39, 40, 41, 42, 43, 44,$FF,$FF,
  804.             $FF,$FF, 61, 62, 63,  0,$45,$46, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  805.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF, 59, 60,$FF,$FF,$FF,$FF,
  806.             $FF,$FF, 49, 50, 51, 52,$FF,$FF,  55, 56, 57, 58,$FF,$FF,$FF,$FF,
  807.             $FF,$FF,$FF,$FF,$47,$48,$FF,$4A, $49,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  808.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF);
  809.       T9 : ARRAY[0..127] OF BYTE =
  810.            ($FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  811.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $57,$58,$59,$5B,$FF,$FF,$FF,$FF,
  812.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  813.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  814.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$4B,$4C,$FF,$FF,
  815.             $FF,$FF,$4D,$4E,$4F,$50,$51,$52, $53,$54,$55,$56,$FF,$FF,$FF,$FF,
  816.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  817.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF);
  818.      T10 : ARRAY[0..63] OF BYTE =
  819.            ($FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $92,$FF,$FF,$FF,$FF,$FF,$FF,$C1,
  820.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$90, $91,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  821.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  822.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$80, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF);
  823.     T121 : ARRAY[0..31] OF BYTE =
  824.            ($FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  825.             $FF,$FF,$5F,$60,$61,$62,$63,$64, $FF,$FF,$FF,$FF,$65,$66,$67,$68);
  826.     T122 : ARRAY[0..255] OF BYTE =
  827.            ($FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  828.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  829.             $FF,$FF,$FF,$FF, 52,$FF,$FF, 55,  56,$FF,$FF, 59, 60,$FF,$FF,$FF,
  830.             $FF,$FF,$FF,$45,$46,$47,$FF, 53,  54,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  831.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  832.             $FF,$FF, 50, 51, 44, 45, 46, 47,  57, 58, 61,$44,$FF,$FF,$FF,$FF,
  833.             $FF,$FF,$FF,$FF, 48, 49, 62, 63,  30, 31, 32, 33, 40, 41,$FF,$FF,
  834.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  835.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  836.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  837.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  838.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  839.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $42,$43, 26, 27, 28, 29,$FF,$FF,
  840.             $FF,$FF, 34, 35, 36, 37, 38, 39, $FF,$FF, 42, 43,$FF,$FF,$FF,$FF,
  841.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,
  842.             $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF);
  843.      T13 : ARRAY[0..$37] OF BYTE =
  844.            ($FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF, $FF,$FF,$CA,$CB,$CC,$CD,$FF,$FF,
  845.             $FF,$FF,$D4,$D5,$D6,$D7,$FF,$FF, $FF,$FF,$D8,$D9,$FF,$FF,$FF,$FF,
  846.             $FF,$FF,$FF,$FF,$DA,$DB,$FF,$FF, $FF,$FF,$FF,$FF,$C8,$C9,$FF,$FF,
  847.             $FF,$FF,$CE,$CF,$D0,$D1,$D2,$D3);
  848.  
  849. VAR   I  : BYTE;
  850.  
  851. LABEL FEHLER;
  852.  
  853. FUNCTION GETVAL(WERT:BYTE):BOOLEAN;
  854. BEGIN
  855.   GETVAL := FALSE;
  856.   IF WERT = $FF THEN EXIT;
  857.   IF I <> 12 THEN BEGIN { T12x ENTHÄLT KEINE FARBINFORMATION }
  858.     IF SCHW <> (WERT > $7F) THEN EXIT;
  859.     BV := WERT AND $80;
  860.   END;
  861.   IF (WERT AND $40) <> 0 THEN BEGIN
  862.     INC(BITS,(WERT AND $3F) SHL 6);
  863.     BITBUF := 0;
  864.     GETBITS(1);
  865.     I := 1;
  866.   END ELSE BEGIN
  867.     INC(BITS,WERT AND $3F);
  868.     GETVAL := TRUE;
  869.   END;
  870. END; { GETVAL }
  871.  
  872. BEGIN { LIESCCITTRUN }
  873.   BITS := 0;
  874.   BITBUF := 0;
  875.   GETBITS(2);
  876.   I := 2;
  877.   REPEAT
  878.     CASE I OF
  879.     0,1 : BEGIN END;
  880.       2 : IF GETVAL(T2[BITBUF]) THEN EXIT;
  881.       3 : IF GETVAL(T3[BITBUF]) THEN EXIT;
  882.       4 : IF GETVAL(T4[BITBUF]) THEN EXIT;
  883.       5 : IF GETVAL(T5[BITBUF]) THEN EXIT;
  884.       6 : IF GETVAL(T6[BITBUF]) THEN EXIT;
  885.       7 : IF BITBUF < $40 THEN BEGIN
  886.             IF SCHW AND (BITBUF = 4) THEN BEGIN
  887.               BV := $80;
  888.               INC(BITS,10);
  889.               EXIT;
  890.             END;
  891.             IF GETVAL(T7[BITBUF]) THEN EXIT;
  892.           END;
  893.       8 : BEGIN
  894.             IF SCHW AND (BITBUF = 4) THEN BEGIN
  895.               BV := $80;
  896.               INC(BITS,13);
  897.               EXIT;
  898.             END;
  899.             IF BITBUF < $80 THEN BEGIN
  900.               IF GETVAL(T8[BITBUF]) THEN EXIT;
  901.             END;
  902.           END;
  903.       9 : BEGIN
  904.             IF SCHW AND (BITBUF = $18) THEN BEGIN
  905.               BV := $80;
  906.               INC(BITS,15);
  907.               EXIT;
  908.             END;
  909.             IF BITBUF > $7F THEN BEGIN
  910.               IF GETVAL(T9[BITBUF AND $7F]) THEN EXIT;
  911.             END;
  912.           END;
  913.      10 : { IF BITBUF < $40 THEN }IF GETVAL(T10[BITBUF]) THEN EXIT;
  914.      11 : BEGIN
  915.             IF SCHW THEN BEGIN
  916.               BV := $80;
  917.               CASE BITBUF OF
  918.                 $17 : BEGIN
  919.                         INC(BITS,24);
  920.                         EXIT;
  921.                       END;
  922.                 $18 : BEGIN
  923.                         INC(BITS,25);
  924.                         EXIT;
  925.                       END;
  926.                 $28 : BEGIN
  927.                         INC(BITS,23);
  928.                         EXIT;
  929.                       END;
  930.                 $37 : BEGIN
  931.                         INC(BITS,22);
  932.                         EXIT;
  933.                       END;
  934.                 $67 : BEGIN
  935.                         INC(BITS,19);
  936.                         EXIT;
  937.                       END;
  938.                 $68 : BEGIN
  939.                         INC(BITS,20);
  940.                         EXIT;
  941.                       END;
  942.                 $6C : BEGIN
  943.                         INC(BITS,21);
  944.                         EXIT;
  945.                       END;
  946.               END; { CASE BITBUF }
  947.             END ELSE BV := 0; { IF SCHW }
  948. { DECODIERUNG SCHWARZ ODER WEIß }
  949.             CASE BITBUF OF
  950.                 8 : INC(BITS,1792);
  951.               $0C : INC(BITS,1856);
  952.               $0D : INC(BITS,1920);
  953.             END; { CASE BITBUF }
  954.           END;
  955.      12 : BEGIN
  956.             IF BITBUF = 1 THEN EXIT; { EOL }
  957.             IF BITBUF < $20 THEN BEGIN
  958.               IF GETVAL(T121[BITBUF]) THEN BEGIN
  959.                 IF SCHW THEN BV := $80 ELSE BV := 0;
  960.                 EXIT;
  961.               END;
  962.             END ELSE BEGIN
  963.               IF SCHW THEN BEGIN
  964.                 IF GETVAL(T122[BITBUF]) THEN EXIT;
  965.               END; { IF SCHW }
  966.             END;
  967.           END;
  968.      13 : BEGIN
  969.             IF BITBUF IN [$40..$7F] THEN BEGIN
  970.               IF GETVAL(T13[BITBUF-$40]) THEN EXIT;
  971.             END ELSE GOTO FEHLER;
  972.           END;
  973.     END; { CASE I }
  974.     IF BITBUF > 127 THEN BEGIN
  975.       WRITE(#7);
  976.       GOTO FEHLER;
  977.     END;
  978.     GETBITS(1);
  979.     INC(I);
  980.   UNTIL I > 13;
  981.  
  982. FEHLER: { NA WAS WOHL ? }
  983.   WRITE('!!');
  984.   IF SCHW THEN WRITE('S') ELSE WRITE('W');
  985.   WRITE(I:3,':',BITS,' ',HEXB(BITBUF),' !!');
  986.   BV := 0;
  987.   IF BITS = 0 THEN BITS := IMGWID;
  988. END; { LIESCCITTRUN }
  989.  
  990.  
  991.  
  992. END. { TIFFUNIT }
  993.  
  994.