Attachment 121480 Details for Bug 81760 – Patch to add LZW compression based on xpdf-3.04

[patch] Patch to add LZW compression based on xpdf-3.04

poppler-02feb16-lzw.pat (text/plain), 23.96 KB, created by William Bader on 2016-02-03 05:33:55 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: William Bader

Created: 2016-02-03 05:33:55 UTC

Size: 23.96 KB

patch

obsolete

> poppler/Gfx.cc         |  21 ++++++++++++++++---
> poppler/PSOutputDev.cc | 163 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------------
> poppler/PSOutputDev.h  |   3 +++
> poppler/Stream.cc      | 145 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> poppler/Stream.h       |  38 ++++++++++++++++++++++++++++++++++
> utils/pdftops.1        |   5 +++++
> utils/pdftops.cc       |   4 ++++
> 7 files changed, 327 insertions(+), 52 deletions(-)
>
>diff --git a/poppler/Gfx.cc b/poppler/Gfx.cc
>index 577c482..bb5f9b1 100644
>--- a/poppler/Gfx.cc
>+++ b/poppler/Gfx.cc
>@@ -2126,7 +2126,12 @@ void Gfx::doTilingPatternFill(GfxTilingPattern *tPat,
>   btm = baseMatrix;
>   ptm = tPat->getMatrix();
>   // iCTM = invert CTM
>-  det = 1 / (ctm[0] * ctm[3] - ctm[1] * ctm[2]);
>+  det = ctm[0] * ctm[3] - ctm[1] * ctm[2];
>+  if (fabs(det) < 0.000001) {
>+    error(errSyntaxError, getPos(), "Singular matrix in tiling pattern fill");
>+    return;
>+  }
>+  det = 1 / det;
>   ictm[0] = ctm[3] * det;
>   ictm[1] = -ctm[1] * det;
>   ictm[2] = -ctm[2] * det;
>@@ -2149,7 +2154,12 @@ void Gfx::doTilingPatternFill(GfxTilingPattern *tPat,
>   m[5] = m1[4] * ictm[1] + m1[5] * ictm[3] + ictm[5];
> 
>   // construct a (device space) -> (pattern space) transform matrix
>-  det = 1 / (m1[0] * m1[3] - m1[1] * m1[2]);
>+  det = m1[0] * m1[3] - m1[1] * m1[2];
>+  if (fabs(det) < 0.000001) {
>+    error(errSyntaxError, getPos(), "Singular matrix in tiling pattern fill");
>+    return;
>+  }
>+  det = 1 / det;
>   imb[0] = m1[3] * det;
>   imb[1] = -m1[1] * det;
>   imb[2] = -m1[2] * det;
>@@ -2335,7 +2345,12 @@ void Gfx::doShadingPatternFill(GfxShadingPattern *sPat,
>   btm = baseMatrix;
>   ptm = sPat->getMatrix();
>   // iCTM = invert CTM
>-  det = 1 / (ctm[0] * ctm[3] - ctm[1] * ctm[2]);
>+  det = ctm[0] * ctm[3] - ctm[1] * ctm[2];
>+  if (fabs(det) < 0.000001) {
>+    error(errSyntaxError, getPos(), "Singular matrix in shading pattern fill");
>+    return;
>+  }
>+  det = 1 / det;
>   ictm[0] = ctm[3] * det;
>   ictm[1] = -ctm[1] * det;
>   ictm[2] = -ctm[2] * det;
>diff --git a/poppler/PSOutputDev.cc b/poppler/PSOutputDev.cc
>index 2d01edb..48be569 100644
>--- a/poppler/PSOutputDev.cc
>+++ b/poppler/PSOutputDev.cc
>@@ -2953,7 +2953,7 @@ void PSOutputDev::setupImages(Dict *resDict) {
> }
> 
> void PSOutputDev::setupImage(Ref id, Stream *str, GBool mask) {
>-  GBool useRLE, useCompressed, doUseASCIIHex;
>+  GBool useLZW, useRLE, useCompressed, doUseASCIIHex;
>   GooString *s;
>   int c;
>   int size, line, col, i;
>@@ -2963,21 +2963,27 @@ void PSOutputDev::setupImage(Ref id, Stream *str, GBool mask) {
>   //~ this does not correctly handle the DeviceN color space
>   //~   -- need to use DeviceNRecoder
>   if (level < psLevel2) {
>-    useRLE = gFalse;
>+    useLZW = useRLE = gFalse;
>     useCompressed = gFalse;
>     doUseASCIIHex = gTrue;
>   } else {
>     if (uncompressPreloadedImages) {
>-      useRLE = gFalse;
>+      useLZW = useRLE = gFalse;
>       useCompressed = gFalse;
>     } else {
>       s = str->getPSFilter(level < psLevel3 ? 2 : 3, "");
>       if (s) {
>-	useRLE = gFalse;
>+	useLZW = useRLE = gFalse;
> 	useCompressed = gTrue;
> 	delete s;
>       } else {
>-	useRLE = gTrue;
>+	if (getEnableLZW()) {
>+	  useLZW = gTrue;
>+	  useRLE = gFalse;
>+	} else {
>+	  useRLE = gTrue;
>+	  useLZW = gFalse;
>+	}
> 	useCompressed = gFalse;
>       }
>     }
>@@ -2986,7 +2992,9 @@ void PSOutputDev::setupImage(Ref id, Stream *str, GBool mask) {
>   if (useCompressed) {
>     str = str->getUndecodedStream();
>   }
>-  if (useRLE) {
>+  if (useLZW) {
>+    str = new LZWEncoder(str);
>+  } else if (useRLE) {
>     str = new RunLengthEncoder(str);
>   }
>   if (doUseASCIIHex) {
>@@ -3028,9 +3036,9 @@ void PSOutputDev::setupImage(Ref id, Stream *str, GBool mask) {
>     }
>   } while (c != (doUseASCIIHex ? '>' : '~') && c != EOF);
>   // add one entry for the final line of data; add another entry
>-  // because the RunLengthDecode filter may read past the end
>+  // because the LZWDecode/RunLengthDecode filter may read past the end
>   ++size;
>-  if (useRLE) {
>+  if (useLZW || useRLE) {
>     ++size;
>   }
>   outerSize = size/65535 + 1;
>@@ -3090,7 +3098,7 @@ void PSOutputDev::setupImage(Ref id, Stream *str, GBool mask) {
>     }
>     if (c == (doUseASCIIHex ? '>' : '~') || c == EOF) {
>       writePS((char *)(doUseASCIIHex ? "> put\n" : "~> put\n"));
>-      if (useRLE) {
>+      if (useLZW || useRLE) {
> 	++line;
> 	writePSFmt("{0:d} <> put\n", line);
>       } else {
>@@ -3231,6 +3239,7 @@ GBool PSOutputDev::checkPageSlice(Page *page, double /*hDPI*/, double /*vDPI*/,
>   PreScanOutputDev *scan;
>   GBool rasterize;
> #if HAVE_SPLASH
>+  GBool useLZW;
>   SplashOutputDev *splashOut;
>   SplashColor paperColor;
>   PDFRectangle box;
>@@ -3269,6 +3278,8 @@ GBool PSOutputDev::checkPageSlice(Page *page, double /*hDPI*/, double /*vDPI*/,
>   }
> 
> #if HAVE_SPLASH
>+  // get the rasterization parameters
>+  useLZW = getEnableLZW();
>   // start the PS page
>   page->makeBox(rasterResolution, rasterResolution, rotateA, useMediaBox, gFalse,
> 		sliceX, sliceY, sliceW, sliceH, &box, &crop);
>@@ -3579,14 +3590,26 @@ GBool PSOutputDev::checkPageSlice(Page *page, double /*hDPI*/, double /*vDPI*/,
>         isGray = gFalse;
>       }
>       str0->reset();
>-      if (isGray && numComps == 4) {
>-	str = new RunLengthEncoder(new CMYKGrayEncoder(str0));
>-	numComps = 1;
>-      } else if (isGray && numComps == 3) {
>-	str = new RunLengthEncoder(new RGBGrayEncoder(str0));
>-	numComps = 1;
>+      if (useLZW) {
>+        if (isGray && numComps == 4) {
>+	  str = new LZWEncoder(new CMYKGrayEncoder(str0));
>+	  numComps = 1;
>+        } else if (isGray && numComps == 3) {
>+	  str = new LZWEncoder(new RGBGrayEncoder(str0));
>+	  numComps = 1;
>+        } else {
>+	  str = new LZWEncoder(str0);
>+        }
>       } else {
>-	str = new RunLengthEncoder(str0);
>+        if (isGray && numComps == 4) {
>+	  str = new RunLengthEncoder(new CMYKGrayEncoder(str0));
>+	  numComps = 1;
>+        } else if (isGray && numComps == 3) {
>+	  str = new RunLengthEncoder(new RGBGrayEncoder(str0));
>+	  numComps = 1;
>+        } else {
>+	  str = new RunLengthEncoder(str0);
>+        }
>       }
>       if (numComps == 1) {
> 	writePS("/DeviceGray setcolorspace\n");
>@@ -3615,7 +3638,11 @@ GBool PSOutputDev::checkPageSlice(Page *page, double /*hDPI*/, double /*vDPI*/,
>       } else {
> 	writePS("    /ASCII85Decode filter\n");
>       }
>-      writePS("    /RunLengthDecode filter\n");
>+      if (useLZW) {
>+	writePS("    /LZWDecode filter\n");
>+      } else {
>+	writePS("    /RunLengthDecode filter\n");
>+      }
>       writePS(">>\n");
>       if (useBinary) {
> 	/* nothing to do */;
>@@ -4349,7 +4376,7 @@ void PSOutputDev::restoreTextPos(GfxState *state) {
> void PSOutputDev::stroke(GfxState *state) {
>   doPath(state->getPath());
>   if (inType3Char && t3FillColorOnly) {
>-    // if we're construct a cacheable Type 3 glyph, we need to do
>+    // if we're constructing a cacheable Type 3 glyph, we need to do
>     // everything in the fill color
>     writePS("Sf\n");
>   } else {
>@@ -5651,7 +5678,7 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
>   GBool emitRect, addRect, extendRect;
>   GooString *s;
>   int n, numComps;
>-  GBool useRLE, useASCII, useCompressed;
>+  GBool useLZW, useRLE, useASCII, useCompressed;
>   GfxSeparationColorSpace *sepCS;
>   GfxColor color;
>   GfxCMYK cmyk;
>@@ -5835,7 +5862,11 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
>     if (inlineImg) {
>       // create an array
>       str2 = new FixedLengthEncoder(str, len);
>-      str2 = new RunLengthEncoder(str2);
>+      if (getEnableLZW()) {
>+	str2 = new LZWEncoder(str2);
>+      } else {
>+	str2 = new RunLengthEncoder(str2);
>+      }
>       if (useASCIIHex) {
> 	str2 = new ASCIIHexEncoder(str2);
>       } else {
>@@ -5878,7 +5909,7 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
> 	}
>       } while (c != (useASCIIHex ? '>' : '~') && c != EOF);
>       writePS((char *)(useASCIIHex ? ">\n" : "~>\n"));
>-      // add an extra entry because the RunLengthDecode filter may
>+      // add an extra entry because the LZWDecode/RunLengthDecode filter may
>       // read past the end
>       writePS("<>]\n");
>       writePS("0\n");
>@@ -5956,7 +5987,7 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
>   if ((mode == psModeForm || inType3Char || preloadImagesForms) &&
>       uncompressPreloadedImages) {
>     s = NULL;
>-    useRLE = gFalse;
>+    useLZW = useRLE = gFalse;
>     useCompressed = gFalse;
>     useASCII = gFalse;
>   } else {
>@@ -5964,11 +5995,17 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
> 			 "    ");
>     if ((colorMap && colorMap->getColorSpace()->getMode() == csDeviceN) ||
> 	inlineImg || !s) {
>-      useRLE = gTrue;
>+      if (getEnableLZW()) {
>+	useLZW = gTrue;
>+	useRLE = gFalse;
>+      } else {
>+	useRLE = gTrue;
>+	useLZW = gFalse;
>+      }
>       useASCII = !(mode == psModeForm || inType3Char || preloadImagesForms);
>       useCompressed = gFalse;
>     } else {
>-      useRLE = gFalse;
>+      useLZW = useRLE = gFalse;
>       useASCII = str->isBinary() &&
> 	         !(mode == psModeForm || inType3Char || preloadImagesForms);
>       useCompressed = gTrue;
>@@ -5978,7 +6015,9 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
>     writePSFmt("    /ASCII{0:s}Decode filter\n",
> 	       useASCIIHex ? "Hex" : "85");
>   }
>-  if (useRLE) {
>+  if (useLZW) {
>+    writePS("    /LZWDecode filter\n");
>+  } else if (useRLE) {
>     writePS("    /RunLengthDecode filter\n");
>   }
>   if (useCompressed) {
>@@ -6011,8 +6050,10 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
>       str = new DeviceNRecoder(str, width, height, colorMap);
>     }
> 
>-    // add RunLengthEncode and ASCIIHex/85 encode filters
>-    if (useRLE) {
>+    // add LZWEncode/RunLengthEncode and ASCIIHex/85 encode filters
>+    if (useLZW) {
>+      str = new LZWEncoder(str);
>+    } else if (useRLE) {
>       str = new RunLengthEncoder(str);
>     }
>     if (useASCII) {
>@@ -6033,7 +6074,7 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
> 	n = 0;
>       } else {
> 	// need to read the stream to count characters -- the length
>-	// is data-dependent (because of ASCII and RLE filters)
>+	// is data-dependent (because of ASCII and LZW/RLE filters)
> 	str->reset();
> 	n = 0;
> 	while ((c = str->getChar()) != EOF) {
>@@ -6085,7 +6126,7 @@ void PSOutputDev::doImageL2(Object *ref, GfxImageColorMap *colorMap,
> #endif
> 
>     // delete encoders
>-    if (useRLE || useASCII || inlineImg) {
>+    if (useLZW || useRLE || useASCII || inlineImg) {
>       delete str;
>     }
>   }
>@@ -6108,8 +6149,8 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>   Stream *str2;
>   GooString *s;
>   int n, numComps;
>-  GBool useRLE, useASCII, useCompressed;
>-  GBool maskUseRLE, maskUseASCII, maskUseCompressed;
>+  GBool useLZW, useRLE, useASCII, useCompressed;
>+  GBool maskUseLZW, maskUseRLE, maskUseASCII, maskUseCompressed;
>   GooString *maskFilters;
>   GfxSeparationColorSpace *sepCS;
>   GfxColor color;
>@@ -6117,8 +6158,8 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>   int c;
>   int col, i;
> 
>-  useRLE = useASCII = useCompressed = gFalse; // make gcc happy
>-  maskUseRLE = maskUseASCII = maskUseCompressed = gFalse; // make gcc happy
>+  useLZW = useRLE = useASCII = useCompressed = gFalse; // make gcc happy
>+  maskUseLZW = maskUseRLE = maskUseASCII = maskUseCompressed = gFalse; // make gcc happy
>   maskFilters = NULL; // make gcc happy
> 
>   // explicit masking
>@@ -6128,17 +6169,23 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>     if ((mode == psModeForm || inType3Char || preloadImagesForms) &&
>       uncompressPreloadedImages) {
>       s = NULL;
>-      maskUseRLE = gFalse;
>+      maskUseLZW = maskUseRLE = gFalse;
>       maskUseCompressed = gFalse;
>       maskUseASCII = gFalse;
>     } else {
>       s = maskStr->getPSFilter(3, "  ");
>       if (!s) {
>-	maskUseRLE = gTrue;
>+	if (getEnableLZW()) {
>+	  maskUseLZW = gTrue;
>+	  maskUseRLE = gFalse;
>+	} else {
>+	  maskUseRLE = gTrue;
>+	  maskUseLZW = gFalse;
>+	}
> 	maskUseASCII = !(mode == psModeForm || inType3Char || preloadImagesForms);
> 	maskUseCompressed = gFalse;
>       } else {
>-	maskUseRLE = gFalse;
>+	maskUseLZW = maskUseRLE = gFalse;
> 	maskUseASCII = maskStr->isBinary() &&
> 	               !(mode == psModeForm || inType3Char || preloadImagesForms);
> 	maskUseCompressed = gTrue;
>@@ -6149,7 +6196,9 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>       maskFilters->appendf("  /ASCII{0:s}Decode filter\n",
> 			   useASCIIHex ? "Hex" : "85");
>     }
>-    if (maskUseRLE) {
>+    if (maskUseLZW) {
>+      maskFilters->append("  /LZWDecode filter\n");      
>+    } else if (maskUseRLE) {
>       maskFilters->append("  /RunLengthDecode filter\n");
>     }
>     if (maskUseCompressed) {
>@@ -6166,11 +6215,13 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>       writePS(maskFilters->getCString());
>       writePS("pdfMask\n");
> 
>-      // add RunLengthEncode and ASCIIHex/85 encode filters
>+      // add LZWEncode/RunLengthEncode and ASCIIHex/85 encode filters
>       if (maskUseCompressed) {
> 	maskStr = maskStr->getUndecodedStream();
>       }
>-      if (maskUseRLE) {
>+      if (maskUseLZW) {
>+	maskStr = new LZWEncoder(maskStr);
>+      } else if (maskUseRLE) {
> 	maskStr = new RunLengthEncoder(maskStr);
>       }
>       if (maskUseASCII) {
>@@ -6191,7 +6242,7 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>       writePS("%-EOD-\n");
>       
>       // delete encoders
>-      if (maskUseRLE || maskUseASCII) {
>+      if (maskUseLZW || maskUseRLE || maskUseASCII) {
> 	delete maskStr;
>       }
>     }
>@@ -6208,7 +6259,11 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>     if (inlineImg) {
>       // create an array
>       str2 = new FixedLengthEncoder(str, len);
>-      str2 = new RunLengthEncoder(str2);
>+      if (getEnableLZW()) {
>+	str2 = new LZWEncoder(str2);
>+      } else {
>+	str2 = new RunLengthEncoder(str2);
>+      }
>       if (useASCIIHex) {
> 	str2 = new ASCIIHexEncoder(str2);
>       } else {
>@@ -6251,7 +6306,7 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
> 	}
>       } while (c != (useASCIIHex ? '>' : '~') && c != EOF);
>       writePS((char *)(useASCIIHex ? ">\n" : "~>\n"));
>-      // add an extra entry because the RunLengthDecode filter may
>+      // add an extra entry because the LZWDecode/RunLengthDecode filter may
>       // read past the end
>       writePS("<>]\n");
>       writePS("0\n");
>@@ -6337,7 +6392,7 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>   if ((mode == psModeForm || inType3Char || preloadImagesForms) &&
>       uncompressPreloadedImages) {
>     s = NULL;
>-    useRLE = gFalse;
>+    useLZW = useRLE = gFalse;
>     useCompressed = gFalse;
>     useASCII = gFalse;
>   } else {
>@@ -6345,11 +6400,17 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
> 			 "    ");
>     if ((colorMap && colorMap->getColorSpace()->getMode() == csDeviceN) ||
> 	inlineImg || !s) {
>-      useRLE = gTrue;
>+      if (getEnableLZW()) {
>+	useLZW = gTrue;
>+	useRLE = gFalse;
>+      } else {
>+	useRLE = gTrue;
>+	useLZW = gFalse;
>+      }
>       useASCII = !(mode == psModeForm || inType3Char || preloadImagesForms);
>       useCompressed = gFalse;
>     } else {
>-      useRLE = gFalse;
>+      useLZW = useRLE = gFalse;
>       useASCII = str->isBinary() &&
>                  !(mode == psModeForm || inType3Char || preloadImagesForms);
>       useCompressed = gTrue;
>@@ -6359,7 +6420,9 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>     writePSFmt("    /ASCII{0:s}Decode filter\n",
> 	       useASCIIHex ? "Hex" : "85");
>   }
>-  if (useRLE) {
>+  if (useLZW) {
>+    writePS("    /LZWDecode filter\n");
>+  } else if (useRLE) {
>     writePS("    /RunLengthDecode filter\n");
>   }
>   if (useCompressed) {
>@@ -6435,8 +6498,10 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>       str = str->getUndecodedStream();
>     }
> 
>-    // add RunLengthEncode and ASCIIHex/85 encode filters
>-    if (useRLE) {
>+    // add LZWEncode/RunLengthEncode and ASCIIHex/85 encode filters
>+    if (useLZW) {
>+      str = new LZWEncoder(str);
>+    } else if (useRLE) {
>       str = new RunLengthEncoder(str);
>     }
>     if (useASCII) {
>@@ -6459,7 +6524,7 @@ void PSOutputDev::doImageL3(Object *ref, GfxImageColorMap *colorMap,
>     writePS("%-EOD-\n");
> 
>     // delete encoders
>-    if (useRLE || useASCII || inlineImg) {
>+    if (useLZW || useRLE || useASCII || inlineImg) {
>       delete str;
>     }
>   }
>diff --git a/poppler/PSOutputDev.h b/poppler/PSOutputDev.h
>index 7318caf..bd5b075 100644
>--- a/poppler/PSOutputDev.h
>+++ b/poppler/PSOutputDev.h
>@@ -320,6 +320,7 @@ public:
>   GBool getEmbedCIDTrueType() const { return embedCIDTrueType; }
>   GBool getFontPassthrough() const { return fontPassthrough; }
>   GBool getOptimizeColorSpace() const { return optimizeColorSpace; }
>+  GBool getEnableLZW() const { return enableLZW; };
>   void setEmbedType1(GBool b) { embedType1 = b; }
>   void setEmbedTrueType(GBool b) { embedTrueType = b; }
>   void setEmbedCIDPostScript(GBool b) { embedCIDPostScript = b; }
>@@ -330,6 +331,7 @@ public:
>   void setGenerateOPI(GBool b) { generateOPI = b; }
>   void setUseASCIIHex(GBool b) { useASCIIHex = b; }
>   void setUseBinary(GBool b) { useBinary = b; }
>+  void setEnableLZW(GBool b) { enableLZW = b; }
> 
> private:
> 
>@@ -532,6 +534,7 @@ private:
>   GBool generateOPI;		// generate PostScript OPI comments?
>   GBool useASCIIHex;		// use ASCIIHex instead of ASCII85?
>   GBool useBinary;		// use binary instead of hex
>+  GBool enableLZW;		// enable LZW compression
> 
> #if OPI_SUPPORT
>   int opi13Nest;		// nesting level of OPI 1.3 objects
>diff --git a/poppler/Stream.cc b/poppler/Stream.cc
>index 9617678..f2ca60b 100644
>--- a/poppler/Stream.cc
>+++ b/poppler/Stream.cc
>@@ -5302,6 +5302,151 @@ GBool RunLengthEncoder::fillBuf() {
> }
> 
> //------------------------------------------------------------------------
>+// LZWEncoder
>+//------------------------------------------------------------------------
>+
>+LZWEncoder::LZWEncoder(Stream *strA):
>+  FilterStream(strA)
>+{
>+  inBufLen = 0;
>+  outBufLen = 0;
>+}
>+
>+LZWEncoder::~LZWEncoder() {
>+  if (str->isEncoder()) {
>+    delete str;
>+  }
>+}
>+
>+void LZWEncoder::reset() {
>+  int i;
>+
>+  str->reset();
>+
>+  // initialize code table
>+  for (i = 0; i < 256; ++i) {
>+    table[i].byte = i;
>+    table[i].next = NULL;
>+    table[i].children = NULL;
>+  }
>+  nextSeq = 258;
>+  codeLen = 9;
>+
>+  // initialize input buffer
>+  inBufLen = str->doGetChars(sizeof(inBuf), inBuf);
>+
>+  // initialize output buffer with a clear-table code
>+  outBuf = 256;
>+  outBufLen = 9;
>+  needEOD = gFalse;
>+}
>+
>+int LZWEncoder::getChar() {
>+  int ret;
>+
>+  if (inBufLen == 0 && !needEOD && outBufLen == 0) {
>+    return EOF;
>+  }
>+  if (outBufLen < 8 && (inBufLen > 0 || needEOD)) {
>+    fillBuf();
>+  }
>+  if (outBufLen >= 8) {
>+    ret = (outBuf >> (outBufLen - 8)) & 0xff;
>+    outBufLen -= 8;
>+  } else {
>+    ret = (outBuf << (8 - outBufLen)) & 0xff;
>+    outBufLen = 0;
>+  }
>+  return ret;
>+}
>+
>+int LZWEncoder::lookChar() {
>+  if (inBufLen == 0 && !needEOD && outBufLen == 0) {
>+    return EOF;
>+  }
>+  if (outBufLen < 8 && (inBufLen > 0 || needEOD)) {
>+    fillBuf();
>+  }
>+  if (outBufLen >= 8) {
>+    return (outBuf >> (outBufLen - 8)) & 0xff;
>+  } else {
>+    return (outBuf << (8 - outBufLen)) & 0xff;
>+  }
>+}
>+
>+// On input, outBufLen < 8.
>+// This function generates, at most, 2 12-bit codes
>+//   --> outBufLen < 8 + 12 + 12 = 32
>+void LZWEncoder::fillBuf() {
>+  LZWEncoderNode *p0, *p1;
>+  int seqLen, code, i;
>+
>+  if (needEOD) {
>+    outBuf = (outBuf << codeLen) | 257;
>+    outBufLen += codeLen;
>+    needEOD = gFalse;
>+    return;
>+  }
>+
>+  // find longest matching sequence (if any)
>+  p0 = table + inBuf[0];
>+  seqLen = 1;
>+  while (inBufLen > seqLen) {
>+    for (p1 = p0->children; p1; p1 = p1->next) {
>+      if (p1->byte == inBuf[seqLen]) {
>+	break;
>+      }
>+    }
>+    if (!p1) {
>+      break;
>+    }
>+    p0 = p1;
>+    ++seqLen;
>+  }
>+  code = (int)(p0 - table);
>+
>+  // generate an output code
>+  outBuf = (outBuf << codeLen) | code;
>+  outBufLen += codeLen;
>+
>+  // update the table
>+  table[nextSeq].byte = seqLen < inBufLen ? inBuf[seqLen] : 0;
>+  table[nextSeq].children = NULL;
>+  if (table[code].children) {
>+    table[nextSeq].next = table[code].children;
>+  } else {
>+    table[nextSeq].next = NULL;
>+  }
>+  table[code].children = table + nextSeq;
>+  ++nextSeq;
>+
>+  // update the input buffer
>+  memmove(inBuf, inBuf + seqLen, inBufLen - seqLen);
>+  inBufLen -= seqLen;
>+  inBufLen += str->doGetChars(sizeof(inBuf) - inBufLen, inBuf + inBufLen);
>+
>+  // increment codeLen; generate clear-table code
>+  if (nextSeq == (1 << codeLen)) {
>+    ++codeLen;
>+    if (codeLen == 13) {
>+      outBuf = (outBuf << 12) | 256;
>+      outBufLen += 12;
>+      for (i = 0; i < 256; ++i) {
>+	table[i].next = NULL;
>+	table[i].children = NULL;
>+      }
>+      nextSeq = 258;
>+      codeLen = 9;
>+    }
>+  }
>+
>+  // generate EOD next time
>+  if (inBufLen == 0) {
>+    needEOD = gTrue;
>+  }
>+}
>+
>+//------------------------------------------------------------------------
> // CMYKGrayEncoder
> //------------------------------------------------------------------------
> 
>diff --git a/poppler/Stream.h b/poppler/Stream.h
>index 00b2925..84a8cf9 100644
>--- a/poppler/Stream.h
>+++ b/poppler/Stream.h
>@@ -1198,6 +1198,44 @@ private:
> };
> 
> //------------------------------------------------------------------------
>+// LZWEncoder
>+//------------------------------------------------------------------------
>+
>+struct LZWEncoderNode {
>+  int byte;
>+  LZWEncoderNode *next;		// next sibling
>+  LZWEncoderNode *children;	// first child
>+};
>+
>+class LZWEncoder: public FilterStream {
>+public:
>+
>+  LZWEncoder(Stream *strA);
>+  virtual ~LZWEncoder();
>+  virtual StreamKind getKind() { return strWeird; }
>+  virtual void reset();
>+  virtual int getChar();
>+  virtual int lookChar();
>+  virtual GooString *getPSFilter(int psLevel, const char *indent)
>+    { return NULL; }
>+  virtual GBool isBinary(GBool last = gTrue) { return gTrue; }
>+  virtual GBool isEncoder() { return gTrue; }
>+
>+private:
>+
>+  LZWEncoderNode table[4096];
>+  int nextSeq;
>+  int codeLen;
>+  Guchar inBuf[4096];
>+  int inBufLen;
>+  int outBuf;
>+  int outBufLen;
>+  GBool needEOD;
>+
>+  void fillBuf();
>+};
>+
>+//------------------------------------------------------------------------
> // CMYKGrayEncoder
> //------------------------------------------------------------------------
> 
>diff --git a/utils/pdftops.1 b/utils/pdftops.1
>index acaec99..25ba97c 100644
>--- a/utils/pdftops.1
>+++ b/utils/pdftops.1
>@@ -91,6 +91,11 @@ in Level 1 PostScript but reduces the file size and can be useful
> when Level 1 PostScript is required only for its restricted use
> of PostScript operators.
> .TP
>+.B \-nolzw
>+Disable LZW compression.  By default, pdftops encodes images
>+in Level 2 and 3 PostScript with LZW.  With -nolzw, pdftops
>+uses Run Length Encoding compression.
>+.TP
> .BI \-r " number"
> Set the resolution in DPI when pdftops rasterizes images with
> transparencies or, for Level 1 PostScript, when pdftops
>diff --git a/utils/pdftops.cc b/utils/pdftops.cc
>index dfeaa14..e2026d0 100644
>--- a/utils/pdftops.cc
>+++ b/utils/pdftops.cc
>@@ -90,6 +90,7 @@ static GBool doOPI = gFalse;
> #endif
> static int splashResolution = 0;
> static GBool psBinary = gFalse;
>+static GBool disableLZW = gFalse;
> static GBool noEmbedT1Fonts = gFalse;
> static GBool noEmbedTTFonts = gFalse;
> static GBool noEmbedCIDPSFonts = gFalse;
>@@ -146,6 +147,8 @@ static const ArgDesc argDesc[] = {
>    "resolution for rasterization, in DPI (default is 300)"},
>   {"-binary",     argFlag,     &psBinary,       0,
>    "write binary data in Level 1 PostScript"},
>+  {"-nolzw",      argFlag,     &disableLZW,     0,
>+   "don't use LZW compression"},
>   {"-noembt1",    argFlag,     &noEmbedT1Fonts, 0,
>    "don't embed Type 1 fonts"},
>   {"-noembtt",    argFlag,     &noEmbedTTFonts, 0,
>@@ -411,6 +414,7 @@ int main(int argc, char *argv[]) {
>   psOut->setGenerateOPI(doOPI);
> #endif
>   psOut->setUseBinary(psBinary);
>+  psOut->setEnableLZW(!disableLZW);
> 
>   psOut->setRasterAntialias(rasterAntialias);
>   if (psOut->isOk()) {

Actions: View | Splinter Review

Attachments on bug 81760: 103465 | 103466 | 103467 | 103468 | 103469 | 121480 | 121501 | 121582 | 121862 | 121863 | 121864 | 121868

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.