EVOLUTION-MANAGER

Edit File: gs_l2img.ps

% Copyright (C) 2001-2018 Artifex Software, Inc.
% All Rights Reserved.
%
% This software is provided AS-IS with no warranty, either express or
% implied.
%
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
%
% Refer to licensing information at http://www.artifex.com or contact
% Artifex Software, Inc.,  1305 Grant Avenue - Suite 200, Novato,
% CA 94945, U.S.A., +1(415)492-9861, for further information.
%

% Emulate the Level 2 dictionary-based image operator in Level 1,
% except for Interpolate (ignored) and MultipleDataSources = true;
% also, we require that the data source be either a procedure of a
% particular form or a stream, not a string or a general procedure.

% pdf2ps copies the portion of this file from %BEGIN to %END if Level 1
% compatible output is requested.

/currentglobal where
 { pop currentglobal { setglobal } //true setglobal }
 { { } }
ifelse

/packedarray where
 { pop }
 { /packedarray { array astore readonly } bind def }
ifelse

%BEGIN

11 dict /.csncompdict 1 index def begin
  /DeviceGray { 1 /setgray load } bind def
  /DeviceRGB { 3 /setrgbcolor load } bind def
  /DeviceCMYK { 4 /setcmykcolor load } bind def
  /Indexed
   { dup 1 index 1 get //.csncompdict exch get exec
                % Stack: [/Indexed base hival map] ncomp basesetcolor
     3 -1 roll 3 get mark 3 1 roll
                % Stack: ncomp -mark- basesetcolor map
     dup type /stringtype eq
      {  { -
            { exch round cvi get 255 div
            }
           -
            { exch round cvi 3 mul 2 copy 2 copy get 255 div
              3 1 roll 1 add get 255 div
              4 2 roll 2 add get 255 div
            }
            { exch round cvi 4 mul 2 copy 2 copy 2 copy get 255 div
              3 1 roll 1 add get 255 div
              4 2 roll 2 add get 255 div
              5 3 roll 3 add get 255 div
            }
         }
        4 index get aload pop counttomark -1 roll
      }
      { /exec load 3 -1 roll
                % Stack: -mark- mapproc --exec-- basesetcolor
      }
     ifelse .packtomark cvx
     exch pop 1 exch
   } bind def
  /Separation
   { dup 2 index //.csncompdict exch get exec
                % Stack: [/Separation name alt xform] ncomp altsetcolor
     3 -1 roll 3 get /exec load 3 -1 roll 3 array astore readonly cvx
     exch pop 1 exch
   } bind def
        % Substitute device spaces for CIE spaces.
  /CIEBasedA /DeviceGray load def
  /CIEBasedABC /DeviceRGB load def
  /CIEBasedDEF /DeviceRGB load def
  /CIEBasedDEFG /DeviceCMYK load def
end

/.packtomark { counttomark packedarray exch pop } bind def

/.csinextbits		% - .csinextbits <bits>
                        % Uses b, nnb, i, row, mask, BitsPerComponent;
                        % sets b, nnb, i.
 { /nnb nnb BitsPerComponent add
    { dup 0 le { exit } if
      /b b 8 bitshift row i get add def
      /i i 1 add def  8 sub
    }
   loop def
   b nnb bitshift mask and
 } bind def

% Note that the ColorSpace key must be present in the image dictionary.
/.colorspaceimage		% <imagedict> .colorspaceimage -
 { save exch
   dup length 15 add dict begin { cvlit def } forall
   ColorSpace dup dup type /nametype ne { 0 get } if
   .csncompdict exch get exec
     /setpixelcolor exch def  /ncomp exch def  pop
   /row ncomp BitsPerComponent mul Width mul 7 add 8 idiv string def
      /mask 1 BitsPerComponent bitshift 1 sub def
      /nextbits BitsPerComponent 8 eq
       { { row i get /i i 1 add def } }
       { /.csinextbits load }
      ifelse def
      /nextpixel mark 0 2 ncomp 1 sub 2 mul
       { /nextbits cvx exch
         Decode exch 2 getinterval
         dup aload pop exch sub
         dup mask eq { pop } { mask div /mul load 3 -1 roll } ifelse
         0 get dup 0 eq { pop } { /sub load 3 -1 roll } ifelse
       }
      for
      /setpixelcolor load dup type /operatortype ne { /exec load } if
      .packtomark cvx def
      /readrow
        /DataSource load dup type
        dup /arraytype eq exch /packedarraytype eq or
        {	% Must be { <file> <string> ... }
          aload length 1 add array /pop load exch astore
          dup 1 row put cvx
        }
        { pop
                % Adobe requires readstring to signal an error if given
                % an empty string.  Work around this nonsense here.
          row length 0 eq
           { { } }
           { { DataSource row readstring pop pop } }
          ifelse
        }
      ifelse def
      ImageMatrix matrix invertmatrix concat
      /imat matrix def
      0 1 Height 1 sub
       { imat 5 3 -1 roll neg put
         readrow
         /b 0 def  /nnb 0 def  /i 0 def
         0 1 Width 1 sub
          { imat 4 3 -1 roll neg put nextpixel
            1 1 //true imat {<80>} imagemask
          }
         for
       }
      for
   end restore
 } bind def

%END
exec
currentfile closefile

% Patch for testing.
/.cincompdict 3 dict begin
  1 { {0 1} {/DeviceGray} } def
  3 { {0 1 0 1 0 1} {/DeviceRGB} } def
  4 { {0 1 0 1 0 1 0 1} {/DeviceCMYK} } def
currentdict end def
/.imagekeys [
  /Decode /DataSource /ImageMatrix /BitsPerComponent /Height /Width
] def
/colorimage		% <width> <height> <bits/comp> <matrix>
                        %   <datasrc> false <ncomp> colorimage -
 { 1 index { /colorimage .systemvar /rangecheck signalerror } if exch pop
   //.cincompdict exch get exec
   7 dict begin /ColorSpace exch cvlit def
   .imagekeys { exch cvlit def } forall
   currentdict end .colorspaceimage
 } bind odef
/image
 { dup type /dicttype ne
    { 7 dict begin /ColorSpace /DeviceGray def [0 1]
      .imagekeys { exch cvlit def } forall
      currentdict end
    }
    { dup length 1 add dict .copydict dup /ColorSpace currentcolorspace put
    }
   ifelse
   .colorspaceimage
 } bind odef

exec