ref: e51c4bc6e493a9cd0d9e9d7f1d24c57ae77bab65
dir: /sys/lib/ghostscript/pdfopt.ps/
% Copyright (C) 2000, 2001 Aladdin Enterprises. 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. % % For more information about licensing, please refer to % http://www.ghostscript.com/licensing/. For information on % commercial licensing, go to http://www.artifex.com/licensing/ or % contact Artifex Software, Inc., 101 Lucas Valley Road #110, % San Rafael, CA 94903, U.S.A., +1(415)492-9861. % $Id: pdfopt.ps,v 1.20 2003/06/02 19:52:58 alexcher Exp $ % PDF linearizer ("optimizer"). .currentglobal true .setglobal /pdfoptdict 200 dict def pdfoptdict begin % This linearizer is designed for simplicity, not for performance. % See the main program (the last procedure in the file) for comments % describing the main processing sequence. % ---------------- Utilities ---------------- % % ------ Data structures ------ % % Distinguish dictionaries, arrays, and everything else. /ifdaelse { % <obj> <dictproc> <arrayproc> <otherproc> ifdaelse - 3 index type dup /dicttype eq { pop pop pop } { dup /arraytype ne exch /packedarraytype ne and { exch } if pop exch pop } ifelse exec } bind def % Implement dynamically growable arrays using a dictionary. /darray { % <size> darray <darray> dict } bind def /dadd { % <darray> <value> dadd - 1 index length exch put } bind def /daforall { % <darray> <proc> daforall - /exch cvx /get cvx 3 -1 roll /exec cvx 5 packedarray cvx 0 1 2 index 0 get length 1 sub 4 -1 roll for } bind def /dacontents { % <darray> dacontents <array> [ exch { } daforall ] } bind def /dacontstring { % <darray> dacontstring <string> 0 1 index { exch pop length add } forall string dup /NullEncode filter % Stack: darray str filter 3 -1 roll { 1 index exch writestring } daforall closefile } bind def % Force an object, mapping it if it is a reference. /omforcenew { % <obj> omforce <obj'> <notseen> dup oforce 2 copy eq { pop true } { exch 0 get omapnew exch pop } ifelse } bind def /omforce { % <obj> omforce <obj'> omforcenew pop } bind def /omget { % <dict|array> <key> omget <obj> get omforce } bind def % Visit an entire tree. /omvisit { % <obj> omvisit - omforcenew { { { omvisit omvisit } forall } { { omvisit } forall } { pop } ifdaelse } { pop } ifelse } bind def % Visit a tree, stopping at references to Page objects. % (This is only needed for the OpenAction in the Catalog.) /omvisitnopage { % <obj> omvisitnopage - dup oforce dup type /dicttype eq { /Type .knownget { /Page eq } { false } ifelse } { pop false } ifelse { pop % Page reference } { omforcenew { { { omvisitnopage omvisitnopage } forall } { { omvisitnopage } forall } { pop } ifdaelse } { pop } ifelse } ifelse } bind def % Collect the list of currently mapped object numbers, in order. /omapped { % - omapped <obj#s> RMap ld_length larray exch lgrowto RMap { 2 index 3 1 roll 1 sub exch lput } ld_forall } bind def % Collect the list of object numbers passed to omap by a procedure. /visited { % <proc> visited <obj#s> false currentomap 2 .execn omapped exch setomap } bind def % ------ Output ------ % % Provide a framework for closure-based streams. .currentglobal false .setglobal userdict /clostreams 20 dict put % stream -> [data endproc] .setglobal % Create a closure-based stream. /clostream { % <data> <proc> <endproc> clostream <stream> 2 index 3 -1 roll /exec load 3 packedarray cvx /NullEncode filter % Stack: data endproc stream clostreams 1 index 5 -2 roll 2 array astore put } bind def % Close a closure-based stream. /closend { % <stream> closend <result> dup closefile clostreams exch 2 copy get 3 1 roll undef aload pop exec } bind def % Implement in-memory output streams. /msproc { % <data> <more> <accum> msproc <scratch> 3 -1 roll dadd { 100 string } { () } ifelse } bind def /mstream { % - mstream <mstream> 10 darray {msproc} {dacontstring} clostream } bind def /mcontents { % <mstream> mcontents <string> closend } bind def % Implement a stream that only keeps track of its position. % (All streams should do this, but the PLRM doesn't require it.) /posbuf 100 string def /posproc { % <data> <more> <accum> posproc <scratch> 0 2 copy get 5 -1 roll length add put pop //posbuf } bind def /postream { % - postream <postream> [0] {posproc} {0 get} clostream } bind def /poslength { % <postream> poslength <pos> closend } bind def % Implement streams with variable-bit-width data. % Note that these are dictionary objects, not stream objects. /bitstream { % <stream> bitstream <bstream> 4 dict begin /S exch def /N 8 def /B 0 def currentdict end } bind def /bitwrite { % <bstream> <value> <width> bitwrite - PDFOPTDEBUG { ( ) print 1 index =only (:) print dup = } if 3 -1 roll begin N exch sub dup 0 ge { /N exch def N bitshift B add } { 2 copy bitshift B add S exch write % Stack: value -left { 8 add dup 0 ge { exit } if 2 copy bitshift 255 and S exch write } loop /N 1 index def bitshift 255 and } ifelse /B exch def end } bind def /bitflush { % <bstream> bitflush - begin N 8 ne { S B write /B 0 def /N 8 def } if end } bind def /bwn { % <value> <width> bwn - 2 copy % v w v w 2 exch exp ge { % v w v>=2**w /bwn cvx /rangecheck signalerror } if bits 3 1 roll bitwrite } def % Capture OFile output on the temporary file, in memory, or just as a length. /totemp { % <proc> totemp <start> <end> TFile fileposition OFile /OFile TFile def 3 .execn /OFile exch def TFile fileposition } bind def /tomemory { % <proc> tomemory <string> OFile /OFile mstream def 2 .execn OFile mcontents exch /OFile exch def } bind def /tolength { % <proc> tolength <string> OFile /OFile postream def 2 .execn OFile poslength exch /OFile exch def } bind def % Copy a range of bytes from TFile to OFile. /copyrange { % <start> <end> copybytes - TFile 2 index setfileposition exch sub 1024 string exch { % Stack: buf left 2 copy 1 index length .min 0 exch getinterval TFile exch readstring pop OFile exch writestring 1 index length sub dup 0 le { exit } if } loop pop pop } bind def % Pad with blanks to a specified position. /padto { % <pos> padto - OFile fileposition sub dup 0 lt { (ERROR: file position incorrect by ) print = /padto cvx /rangecheck signalerror } { { ( ) ows } repeat } ifelse } bind def % ---------------- Read objects into memory ---------------- % /touch { % <object> touch - { { touch touch } forall } { dup xcheck { % Executable array, must be an indirect object. dup 0 get resolved? { pop pop } { oforce touch } ifelse } { { touch } forall } ifelse } { pop } ifdaelse } bind def % ---------------- Replace references with referents ---------------- % /replaceable? { % <value> replaceable? <bool> dup type /integertype eq exch xcheck not and } bind def /replacement { % <obj|ref> replacement <obj'> dup oforce dup replaceable? { exch } if pop } bind def /replacerefs { % <object> replacerefs <object> { dup { 2 index 2 index undef exch replacement exch replacement 2 index 3 1 roll put } forall } { 0 1 2 index length 1 sub { 1 index exch 2 copy get replacement put } for } { } ifdaelse } bind def /replaceReferences { % - replaceReferences - Objects { replacerefs pop } lforall % Delete replaced objects. 0 1 Objects llength 1 sub { Objects 1 index lget replaceable? { PDFOPTDEBUG { (Deleting ) print dup = } if Generations 1 index 0 lput } if pop } for } bind def % ---------------- Create new objects ---------------- % /createObjects { % [<obj>...] createObjects <firstobj#> Objects llength dup dup 3 index length add growPDFobjects % Stack: objects objn objn 3 1 roll exch { Objects 2 index 3 -1 roll lput Generations 1 index 1 lput 1 add } forall pop } bind def % ---------------- Propagate attributes ---------------- % /nopropattrs << % Never propagate these. /Type dup /Kids dup /Count dup /Parent dup % Handle Resources specially. /Resources dup >> def % Merge Resources. /mergeres { % <fromdict> <todict> mergeres - % Values in todict take priority over fromdict. 1 index /Resources .knownget { 1 index /Resources .knownget { % Stack: fromdict todict fromres tores exch oforce exch oforce % todict's Resources may be shared, so make a copy. dup length dict .copydict exch { % Stack: fromdict todict tores' fromkey fromvalue 2 index 2 index knownoget { % Stack: fromdict todict tores' fromkey fromvalue tovalue exch oforce exch % ProcSet is an array, other types are dictionaries. dup type /dicttype eq { % Dictionary, not ProcSet. exch dup length 2 index length add dict .copydict .copydict } { % Array or packed array, ProcSet. % Use dictionaries to do the merge. dup length 2 index length add dict begin exch { dup def } forall { dup def } forall mark currentdict end { pop } forall .packtomark } ifelse } if 2 index 3 1 roll put } forall } if /Resources exch put pop } { pop pop } ifelse } bind def % Merge attributes other than Resources. /mergeattrs { % <fromdict> <todict> mergeattrs <fromdict> <todict> % Values in todict take priority over fromdict. 1 index { % Stack: fromdict todict fromkey fromvalue //nopropattrs 2 index known { pop pop } { 2 index 2 index known { pop pop } { 2 index 3 1 roll put } ifelse } ifelse } forall } bind def % Propagate attributes to a subtree. /proppage { % <attrs> <subtree> proppage - % We should be able to tell when we reach a leaf % by finding a Type unequal to /Pages. Unfortunately, % some files distributed by Adobe lack the Type key % in some of the Pages nodes! Instead, we check for Kids. dup /Kids knownoget { % Accumulate inherited values. 3 1 roll % Stack: kids attrs pagesnode dup length dict .copydict mergeattrs dup 3 1 roll mergeres exch { oforce 1 index exch proppage } forall pop } { % Merge inherited values into the leaf. mergeattrs mergeres } ifelse } bind def % Propagate attributes to all pages. /propagateAttributes { % - propagateAttributes - 0 dict Trailer /Root oget /Pages oget proppage } bind def % ---------------- Identify document-level objects ---------------- % /identifyDocumentObjects { % - identifyDocumentObjects <obj#s> { Trailer /Root omget dup /PageMode .knownget { omvisit } if % Don't allow omvisit to trace references to Page objects. dup /OpenAction .knownget { omvisitnopage } if Trailer /Encrypt .knownget { omvisit } if dup /Threads .knownget { omforce { omvisit } forall } if dup /AcroForm .knownget { omvisit } if pop } visited } bind def % ---------------- Identify the objects of each page ---------------- % /identifyfont { % <fontref> identifyfont - omforce { exch /FontDescriptor eq { omforce dup /Flags .knownget { 32 and 0 ne } { false } ifelse exch { exch dup dup /FontFile eq exch /FontFile2 eq or exch /FontFile3 eq or 2 index and { fontfiles exch dadd } { omvisit } ifelse } forall pop } { omvisit } ifelse } forall } bind def % Collect all the objects referenced from a page. The first object number % (which may not be the smallest one) is that of the page object itself. /identifyPageObjects { % <extra> <page#> identifyPageObjects <obj#s> PDFOPTDEBUG { (%Objects for page: ) print dup = } if pdffindpageref dup 0 get 3 1 roll 4 dict begin /images 10 darray def /fontfiles 10 darray def { omforce % Stack: pageobj# extra page % Visit any extra objects if applicable. exch omvisit % Visit Annots, if any. % We don't try to defer the drawing information. dup /Annots .knownget { omvisit } if % Visit beads. dup /B .knownget { omvisit } if % Visit resources dictionaries. dup /Resources .knownget { omforce dup { % Visit the first-level Resource dictionaries. omforce pop pop } forall { % Visit the resources themselves. % Skip Image XObjects, and FontFile streams if the % FontDescriptor Flags have bit 6 set. % We don't try to visit the resources in the order in which % the Contents stream(s) reference(s) them. exch dup /XObject eq { pop oforce { dup oforce /Subtype get /Image eq { images exch dadd } { omvisit } ifelse pop } forall } { /Font eq { oforce { identifyfont pop } forall } { oforce omvisit } ifelse } ifelse } forall } if % Visit the Contents stream(s). dup /Contents .knownget { omvisit } if % Visit Image XObjects. We don't try to visit them in % reference order. images { omvisit } daforall % Visit FontFile streams. We don't try to visit them in % reference order. fontfiles { omvisit } daforall pop } visited end % Stack: pageobj# obj#s_larray [ 3 1 roll { 2 copy eq { pop } { exch } ifelse } lforall counttomark 1 roll ] PDFOPTDEBUG { (%Objects = ) print dup === flush } if } bind def % Identify the objects of the first page. /identifyFirstPageObjects { % - identifyFirstPageObjects <obj#s> Trailer /Root oget null 1 index /PageMode knownoget { /UseOutlines eq { 1 index /Outlines knownoget { exch pop } if } if } if exch pop 1 identifyPageObjects } bind def % Identify the non-shared objects of the other pages, and the shared objects. % Note that the page objects themselves may appear to be shared, because of % references from Dest entries in annotations, but they must be treated as % non-shared. Note also that some objects referenced on the first page may % also be referenced from other pages. /identifyOtherPageObjects { % - identifyOtherPageObjects [<pageobj#s> ...] % <sharedobj#s> 4 dict begin /marks lstring Objects llength lgrowto def % Collect objects of other pages and identify sharing. [ 2 1 pdfpagecount { null exch identifyPageObjects } for ] dup { { marks exch 2 copy lget 1 add 254 .min lput } forall } forall % Mark document-level and first page objects. CatalogNs { marks exch 255 lput } lforall FirstPageNs { marks exch 255 lput } forall % Mark the page objects themselves as non-shared. dup { 0 get marks exch 1 lput } forall % Collect the non-shared objects of each page. dup [ exch { [ exch { marks 1 index lget 1 ne { pop } if } forall ] } forall ] % Collect the shared objects of each page. exch [ exch { [ exch { marks 1 index lget dup 1 le exch 255 eq or { pop } if } forall ] } forall ] % Collect the shared objects. [ 1 1 marks llength 1 sub { marks 1 index lget dup 1 le exch 255 eq or { pop } if } for ] end } bind def % Identify objects not associated with any page. /identifyNonPageObjects { % - identifyNonPageObjects <obj#s> 4 dict begin /marks lstring Objects llength lgrowto def LPDictN marks exch 1 lput PHSN marks exch 1 lput CatalogNs { marks exch 1 lput } lforall FirstPageNs { marks exch 1 lput } forall SharedNs { marks exch 1 lput } forall OtherPageNs { { marks exch 1 lput } forall } forall %****** PUT THESE IN A REASONABLE ORDER ****** /npobj larray 0 1 1 Objects llength 1 sub { marks 1 index lget 0 eq { Generations exch lget 0 ne { 1 add } if } { pop } ifelse } for lgrowto def 0 1 1 Objects llength 1 sub { marks 1 index lget 0 eq { % i Generations 1 index lget 0 ne { % i npobj 2 index % i nobj 0 3 -1 roll % nobj 0 i lput 1 add } { pop } ifelse } { pop } ifelse } for pop npobj end } bind def % ---------------- Assign object numbers ---------------- % % Assign object numbers to all objects that will be copied. % Return the first (translated) object number in the First Page xref table. /assignObjectNumbers { % - assignObjectNumbers - OtherPageNs { { omap pop } forall } forall SharedNs { omap pop } forall NonPageNs { omap pop } lforall % Assign object numbers for the First Page xref table last. LPDictN omap % don't pop, this is the return value CatalogNs { omap pop } lforall FirstPageNs { omap pop } forall PHSN omap pop } bind def % ---------------- Create the LPDict ---------------- % % Create the contents of the LPDict. /createLPDict { % <phsstart> <phsend> <firstpageend> % <xref0start> <filelength> createLPDict - LPDict dup /Linearized 1 put dup /L 4 -1 roll put % filelength dup /T 4 -1 roll put % xref0start dup /E 4 -1 roll put % firstpageend dup /H 5 -2 roll 1 index sub 2 array astore put % phsstart, end-start dup /O 1 pdffindpageref 0 get omap put /N pdfpagecount put } bind def % ---------------- Adjust object positions ---------------- % /adjustObjectPositions { % <boundary> <deltabelow> <deltaabove> % adjustObjectPositions - % Objects fall into 4 categories: LPDict, PHS, Catalog, and others. % We handle the first two as special cases. XRef { % Stack: bdy below above key loc dup 5 index ge { 2 } { 3 } ifelse index add XRef 3 1 roll ld_put } ld_forall pop pop pop XRef LPDictN omap HeaderLength ld_put XRef PHSN omap PHSStart ld_put } bind def % ---------------- Write the output file ---------------- % % Write objects identified by object number. /writeobjn { % <obj#> writeobjn - Generations 1 index lget pdfwriteobj } bind def /writeobjns { % <obj#s> writeobjns - { writeobjn } forall } bind def /lwriteobjns { % <obj#s> writeobjns - { writeobjn } lforall } bind def % Write a part of the output file. /writePart { % <proc> <label> writePart - PDFOPTDEBUG { dup print ( count=) print count =only ( start=) print OFile { .fileposition } stopped { pop (???) } if = 2 .execn print ( end=) print OFile { .fileposition } stopped { pop (???) } if = } { pop exec } ifelse } bind def % Write the header. /writePart1 { % - writePart1 - { pdfwriteheader } (part1) writePart } bind def % Write the linearization parameters dictionary. /writePart2 { % - writePart2 - { LPDictN writeobjn } (part2) writePart } bind def % Write the First Page xref table and trailer. % Free variables: FirstPageXN. /writePart3 { % <xrefstart> writePart3 - { FirstPageXN NObjects 1 add 1 index sub pdfwritexref Trailer dup length 1 add dict copy dup /Size NObjects 1 add put dup /Prev 4 -1 roll put pdfwritetrailer 0 pdfwritestartxref } (part3) writePart } bind def % Write the Catalog and other required document-level objects. % Free variables: CatalogNs. /writePart4 { % - writePart4 - { CatalogNs lwriteobjns } (part4) writePart } bind def % Write the Primary Hint Stream. /writePart5 { % - writePart5 - { PHSN writeobjn } (part5) writePart } bind def % Write the First Page's objects. % Free variables: FirstPageNs. /writePart6 { % - writePart6 - { FirstPageNs writeobjns } (part6) writePart } bind def % Write the objects of other pages (Page + non-shared objects). % Free variables: OtherPageNs. /writePart7 { % - writePart7 <lengths> { [ OtherPageNs { OFile fileposition exch writeobjns OFile fileposition exch sub } forall ] } (part7) writePart } bind def % Write the shared objects of other pages. % Free variables: SharedNs. /writePart8 { % - writePart8 - { SharedNs writeobjns } (part8) writePart } bind def % Write the other objects not associated with pages. % Free variables: NonPageNs. /writePart9 { % - writePart9 - { NonPageNs { writeobjn } lforall } (part9) writePart } bind def % Write the main xref table and trailer. % Free variables: FirstPageXN. /writePart11xref { % writePart11 - { 0 FirstPageXN pdfwritexref } (part11xref) writePart } bind def /writePart11rest { % <part3start> writePart11rest - { << /Size FirstPageXN >> pdfwritetrailer pdfwritestartxref } (part11rest) writePart } bind def % ---------------- Write hint tables ---------------- % /bitsneeded { % <maxvalue> bitsneeded <#bits> 0 exch { dup 0 eq { pop exit } if exch 1 add exch 2 idiv } loop } bind def % Find the start and end of objects in the output. /omstart { % <obj#> omstart <pos> PDFOPTDEBUG { (start\() print dup =only } if omap PDFOPTDEBUG { (=>) print dup =only } if XRef exch ld_get PDFOPTDEBUG { (\) = ) print dup = } if } bind def /omend { % <obj#> omend <pos> % The end of an object is the start of the next object. % The caller must be sure that this object is not the last one % in part 9. PDFOPTDEBUG { (end\() print dup =only } if omap PDFOPTDEBUG { (=>) print dup =only } if 1 add % Check that the requested object wasn't the last one in part 6: % the next object in the output file is the first in part 7. PHSN omap 1 index eq { pop 1 } if XRef exch ld_get PDFOPTDEBUG { (\) = ) print dup = } if } bind def /omlength { % <obj#> omlength <length> dup omend exch omstart sub } bind def % Find the Contents of a page. /contentsobjects { % <pagedict> contentsobjects <firstobj#> <lastobj#> true % <pagedict> contentsobjects false /Contents .knownget { dup oforce % ref [] dup type /dicttype eq { pop 0 get dup true % ref ref } { exch pop % [] dup length 0 ne { dup 0 get 0 get % [] 1st exch dup % 1st [] [] length 1 sub get 0 get % 1st last true } { pop false } ifelse } ifelse } { false } ifelse } bind def /contentsstart { % <pagedict> contentsstart <pos> true % <pagedict> contentsstart false contentsobjects { pop omstart true } { false } ifelse } bind def /contentslength { % <pagedict> contentslength <length> contentsobjects { omend exch omstart sub } { 0 } ifelse } bind def /writePageOffsetHints { PDFOPTDEBUG { /writePageOffsetHints == } if 20 dict begin /bits OFile bitstream def % Calculate least length of a page. FirstPageLength OtherPageLengths { .min } forall /minpl exch def % Calculate least contents length. FirstPageNs 0 get Objects exch lget contentslength OtherPageNs { 0 get Objects exch lget contentslength .min } forall /mincl exch def % The Adobe documentation says that all versions of Acrobat % require item 8 (mincl) to be zero. Patch this here. /mincl 0 def % Calculate bits needed to represent greatest page length. FirstPageLength OtherPageLengths { .max } forall minpl sub bitsneeded /maxplbits exch def % Calculate bits needed to represent the greatest Contents length. FirstPageNs 0 get Objects exch lget contentslength OtherPageNs { 0 get Objects exch lget contentslength .max } forall mincl sub bitsneeded /maxclbits exch def % Per Adobe documentation, Acrobat requires that item 5 (maxplbits) % be equal to item 9 (maxclbits). Set both to the max of the two. maxplbits maxclbits .max /maxplbits 1 index def /maxclbits exch def % Mapping from object number to shared object reference /shared_id_dict FirstPageNs length SharedNs length add dict begin 0 FirstPageNs { 1 index def 1 add } forall SharedNs { 1 index def 1 add } forall pop currentdict end def % Table F.3 Page offset hint table, header section % 1: Least number of objects in a page: FirstPageNs length OtherPageNs { length .min } forall /minnop 1 index def 32 bwn % 2: Location of first page's Page object: FirstPageNs 0 get omap XRef exch ld_get 32 bwn % 3: Bits needed to represent greatest # of objects in a page: FirstPageNs length OtherPageNs { length .max } forall minnop sub bitsneeded /maxnopbits 1 index def 16 bwn % 4: Least length of a page: minpl 32 bwn % 5: Bits needed to represent the greatest page length: maxplbits 16 bwn % 6: Least start of Contents offset: 0 % (Acrobat requires that this be 0.) /minsco 1 index def 32 bwn % 7: Bits needed to represent the greatest start of Contents % offset: 0 % (Acrobat ignores this.) /maxscobits 1 index def 16 bwn % 8: Least contents length: mincl 32 bwn % 9: Bits needed to represent the greatest Contents length: maxclbits 16 bwn % 10: Bits needed to represent the greatest number of Shared % Object references: FirstPageNs length SharedPageNs { length .max } forall bitsneeded /maxsorbits 1 index def 16 bwn % 11: Bits needed to identify a Shared Object: FirstPageNs length SharedNs length add bitsneeded /sobits 1 index def 16 bwn % 12: Bits needed to represent numerator of fraction: 2 /numfbits 1 index def 16 bwn % 13: Denominator of fraction: 1 /denf 1 index def 16 bwn % Table F.4 Page offset hint table, per-page entry % 1: Number of objects in pages: FirstPageNs length minnop sub maxnopbits bwn OtherPageNs { length minnop sub maxnopbits bwn } forall bits bitflush % 2: Total length of pages in bytes; FirstPageLength minpl sub maxplbits bwn OtherPageLengths { minpl sub maxplbits bwn } forall bits bitflush % 3: Number of shared objects referenced from page: FirstPageNs length maxsorbits bwn SharedPageNs { length maxsorbits bwn } forall bits bitflush % 4: A shared object identifier: FirstPageNs { shared_id_dict exch get sobits bwn } forall SharedPageNs { { shared_id_dict exch get sobits bwn } forall } forall bits bitflush % 5: Numerator of fractional position for each shared object: FirstPageNs { pop 0 numfbits bwn } forall SharedPageNs { { pop 0 numfbits bwn } forall } forall bits bitflush % 6: Contents offsets: % Following Implementation Note 133 section 6 is empty. maxscobits 0 gt { [FirstPageNs OtherPageNs aload pop] { 0 get Objects exch lget contentsstart { minsco sub } { 0 } ifelse maxscobits bwn } forall bits bitflush } if % 7: Contents lengths: [FirstPageNs OtherPageNs aload pop] { 0 get Objects exch lget contentslength mincl sub maxclbits bwn } forall bits bitflush end } bind def /writeSharedObjectHints { PDFOPTDEBUG { /writeSharedObjectHints == } if 20 dict begin /bits OFile bitstream def /obj_count SharedNs length FirstPageNs length add def % Table F.5 Shared object hint table, header section % 1: Object number of first object in Shared Objects section 0 32 bwn % 2: Location of first object in Shared Objects section: % If there are no shared objects, % Acrobat sets this to the location of linearization % parameters object (the very first object). { pdfwriteheader } tomemory length 32 bwn % 3: Number of Shared Object entries for first page: FirstPageNs length 32 bwn % 4: Number of Shared Object entries for Shared Objects % section obj_count 32 bwn % 5: Bits needed to represent the greatest number of objects % in a shared object group (always 0, because all groups % have only 1 object): 0 16 bwn % 6: Least length of a Shared Object Group in bytes: 16#7fffffff FirstPageNs { omlength .min } forall SharedNs { omlength .min } forall /minsol 1 index def 32 bwn % 7: Bits needed to represent the greatest length of a % Shared Object Group: 0 FirstPageNs { omlength .max } forall SharedNs { omlength .max } forall minsol sub bitsneeded /maxsolbits 1 index def 16 bwn % Table F.6 Shared object hint table, shared object group entry % 1: Lengths of shared object groups: FirstPageNs { omlength minsol sub maxsolbits bwn } forall SharedNs { omlength minsol sub maxsolbits bwn } forall bits bitflush % 2: MD5 flag: obj_count { 0 1 bwn } repeat bits bitflush % 3: No MD5 shared object signatures. % 4: No number_number_of_objects_in_the_group - 1 end } bind def % ---------------- Main program ---------------- % /pdfOptimize { % <infile> <outfile> pdfOptimize - realtime 3 1 roll exch pdfdict begin pdfopenfile dup begin 40 dict begin /IDict exch def /OFile exch def /starttime exch def /now { QUIET { pop } { print (, t = ) print realtime starttime sub = flush } ifelse } def omapinit % Create and open a temporary file. % Because of .setsafe, we have to open it as read-write, rather than % opening for writing, then closing it and reopening it for reading. null (w+) .tempfile /TFile exch def /TFileName exch def .setsafe % Read all objects into memory. Trailer touch (Read objects) now % Encrypted files are not yet supported. Trailer /Encrypt known { (ERROR: Encrypted files are not yet supported.) = flush /pdfOptimize cvx /limitcheck signalerror } if % Replace indirect references to numbers. This is needed % for the Length of streams, and doesn't hurt anything else. replaceReferences (Replaced references) now % Create the two new objects: the linearization parameter % dictionary, and the Primary Hint Stream. /LPDict 10 dict def /PHS 10 dict cvx def % executable = stream [LPDict PHS] createObjects /LPDictN 1 index def 1 add /PHSN exch def PDFOPTDEBUG { << /LPDictN LPDictN /PHSN PHSN >> === } if % Count the number of objects in the output. 0 0 1 Objects llength 1 sub { Generations exch lget 0 ne { 1 add } if } for /NObjects exch def QUIET not { NObjects =only ( objects total) = flush } if % Propagate inherited attributes down the page tree. propagateAttributes (Propagated attributes) now % Identify the document-level objects (part 4). identifyDocumentObjects /CatalogNs exch def QUIET not { CatalogNs === flush } if (Identified Catalog) now % Identify the first page's objects (part 6), % including the Outlines tree if appropriate. pdfopencache /FirstPageNs identifyFirstPageObjects def QUIET not { FirstPageNs === flush } if (Identified first page) now % Identify shared vs. non-shared objects for remaining pages % (parts 7 and 8). identifyOtherPageObjects /SharedNs exch def /SharedPageNs exch def /OtherPageNs exch def QUIET not { OtherPageNs === flush SharedNs === flush } if (Identified other pages) now % Identify objects not associated with any page (part 9). /NonPageNs identifyNonPageObjects def QUIET not { NonPageNs { === } forall flush } if (Identified non-pages) now % Assign final object numbers to all the objects. % (The omap is currently empty.) /FirstPageXN assignObjectNumbers def (Assigned objects #s) now % Write the document-level objects (part 4). { writePart4 } totemp /CatalogTempEnd exch def /CatalogTempStart exch def (Wrote Catalog) now % Write the first page's objects (part 6). { writePart6 } totemp /FirstPageTempEnd exch def /FirstPageTempStart exch def (Wrote first page) now % Write the non-shared objects for other pages (part 7). { writePart7 /OtherPageLengths exch def } totemp /OtherPageTempEnd exch def /OtherPageTempStart exch def (Wrote other pages) now % Write the shared objects for other pages (part 8). { writePart8 } totemp /SharedTempEnd exch def /SharedTempStart exch def (Wrote shared objects) now % Write the objects not associated with pages (part 9). { writePart9 } totemp /NonPageTempEnd exch def /NonPageTempStart exch def % Compute conservative lengths of parts 2,3,5,11 of the output. % It's OK for these to be too large, but not too small. % Make dummy XRef entres for LPDict and PHS. XRef LPDictN omap 0 ld_put XRef PHSN omap 0 ld_put /HeaderLength { % this is exact writePart1 % part 1 } tolength def /CatalogLength % this is exact CatalogTempEnd CatalogTempStart sub def % part 4 /FirstPageLength % this is exact FirstPageTempEnd FirstPageTempStart sub def % part 6 /OtherObjectsLength % this is exact NonPageTempEnd OtherPageTempStart sub def % parts 7,8,9 /ObjectsLength % this is exact CatalogLength FirstPageLength add OtherObjectsLength add def /XrefLength { % part 11 % The LPDict must end within the first 1024 bytes, % so the start of the FirstPage xref table can't exceed 1024. writePart11xref 1024 writePart11rest } tolength def /NominalFileLength % Make a generous allowance for parts 2,3,5. HeaderLength ObjectsLength 3 mul add 10000 add 99999 .max def /FirstPageXrefLength { % part 3 NominalFileLength writePart3 } tolength def /LPDictLength { % part 2 NominalFileLength dup 2 mul 2 copy add 1 index dup createLPDict writePart2 } tolength def % Compute a few additional values from the above. /XrefBeginLength { (xref\n0 ) ows OFile FirstPageXN write= } tolength def HeaderLength LPDictLength add /FirstPageXrefStart 1 index def FirstPageXrefLength add /CatalogStart 1 index def CatalogLength add % phsstart /PHSStart exch def % Adjust the object positions ignoring PHS. % (Writing the PHS needs these.) 0 0 CatalogStart CatalogTempStart sub adjustObjectPositions % Make a temporary XRef entry for the PHS, for the benefit of omend. XRef PHSN omap CatalogStart ld_put (Adjusted positions) now % Construct the hint tables (part 5). { writePageOffsetHints } totemp pop /PHSTempStart exch def { writeSharedObjectHints } totemp exch PHSTempStart sub PHS /S 3 -1 roll put PHSTempStart sub /PHSTempLength exch def (Wrote hints) now % Prepare to read TFile. % TFile closefile % /TFile TFileName (r) file def PHS dup /File TFile put dup /FilePosition PHSTempStart put dup /Length PHSTempLength put pop /PHSLength { writePart5 } tolength def % Construct the linearization parameter dictionary (part 2). PHSStart dup PHSLength add % phsend /FirstPageStart 1 index def dup FirstPageLength add % firstpageend dup OtherObjectsLength add /XrefStart 1 index def XrefBeginLength add % xref0start dup XrefBeginLength sub XrefLength add % fileend % Because of a bug, Acrobat Reader doesn't recognize any file % shorter than 1K as linearized. Patch this here. 1024 .max /FileLength 1 index def createLPDict % Adjust the object positions again, taking the PHS into account. PHSStart 0 PHSLength adjustObjectPositions (Readjusted positions) now % Finally, write the output file. writePart1 writePart2 FirstPageXrefStart padto XrefStart writePart3 CatalogStart padto CatalogTempStart CatalogTempEnd copyrange % part 4 writePart5 FirstPageStart padto FirstPageTempStart NonPageTempEnd copyrange % parts 6,7,8,9 % No Overflow Hint Stream (part 10). XrefStart padto writePart11xref { FirstPageXrefStart writePart11rest } tomemory FileLength 1 index length sub padto ows (Wrote output file) now % Wrap up. TFile closefile TFileName deletefile end % temporary dict end % IDict } bind def end % pdfoptdict .setglobal % Check for command line arguments. [ shellarguments { ] dup length 2 eq { % Load the pdfwrite utilities if necessary. /omapinit where { pop } { (pdfwrite.ps) runlibfile } ifelse save exch aload pop exch (r) file exch (w) file 3000000 setvmthreshold 0 setobjectformat pdfoptdict begin pdfOptimize end restore } { (Usage: gs -dNODISPLAY -- pdfopt.ps input.pdf output.pdf) = flush quit } ifelse } { pop } ifelse