[csw-devel] SF.net SVN: gar:[5595] csw/mgar/pkg

bensons at users.sourceforge.net bensons at users.sourceforge.net
Fri Jul 17 14:04:48 CEST 2009


Revision: 5595
          http://gar.svn.sourceforge.net/gar/?rev=5595&view=rev
Author:   bensons
Date:     2009-07-17 12:04:47 +0000 (Fri, 17 Jul 2009)

Log Message:
-----------
xpdf: GAR repackage, applied security patches, fixed bug 0002724

Added Paths:
-----------
    csw/mgar/pkg/xpdf/
    csw/mgar/pkg/xpdf/branches/
    csw/mgar/pkg/xpdf/tags/
    csw/mgar/pkg/xpdf/trunk/
    csw/mgar/pkg/xpdf/trunk/Makefile
    csw/mgar/pkg/xpdf/trunk/checksums
    csw/mgar/pkg/xpdf/trunk/files/
    csw/mgar/pkg/xpdf/trunk/files/patch-GString.cc
    csw/mgar/pkg/xpdf/trunk/files/patch-XPDFCore.cc
    csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl1.patch
    csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl2.patch
    csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl3.patch


Property changes on: csw/mgar/pkg/xpdf/trunk
___________________________________________________________________
Added: svn:ignore
   + cookies
download
work


Added: svn:externals
   + gar https://gar.svn.sourceforge.net/svnroot/gar/csw/mgar/gar/v2


Added: csw/mgar/pkg/xpdf/trunk/Makefile
===================================================================
--- csw/mgar/pkg/xpdf/trunk/Makefile	                        (rev 0)
+++ csw/mgar/pkg/xpdf/trunk/Makefile	2009-07-17 12:04:47 UTC (rev 5595)
@@ -0,0 +1,45 @@
+GARNAME = xpdf
+GARVERSION = 3.02
+CATEGORIES = utils
+
+# ftp://ftp.foolabs.com/pub/xpdf/xpdf-3.02.tar.gz
+
+
+DESCRIPTION = Open source viewer for Portable Document Format (PDF) files
+define BLURB
+  Xpdf is an open source viewer for Portable Document Format (PDF) files. 
+  (These are also sometimes also called 'Acrobat' files, from the name of 
+  Adobe's PDF software.) The Xpdf project also includes a PDF text extractor, 
+  PDF-to-PostScript converter, and various other utilities. 
+  Xpdf is designed to be small and efficient. It can use Type 1, TrueType, 
+  or standard X fonts. 
+endef
+
+MASTER_SITES = ftp://ftp.foolabs.com/pub/xpdf/
+DISTFILES  = $(GARNAME)-$(GARVERSION).tar.gz
+
+# We define upstream file regex so we can be notifed of new upstream software release
+UFILES_REGEX = $(GARNAME)-(\d+(?:\.\d+)*).tar.gz
+
+# we require
+REQUIRED_PKGS = CSWftype2 CSWt1lib CSWxpm CSWgsfonts
+
+CONFIGURE_ARGS  = $(DIRPATHS)
+CONFIGURE_ARGS += --with-Xpm-library=$(libdir)
+CONFIGURE_ARGS += --with-Xpm-includes=$(includedir)
+CONFIGURE_ARGS += --with-t1-library=$(libdir)
+CONFIGURE_ARGS += --with-t1-includes=$(includedir)
+CONFIGURE_ARGS += --with-freetype2-library=$(libdir)
+CONFIGURE_ARGS += --with-freetype2-includes=$(includedir)/freetype2
+
+# apply patches
+PATCHFILES  = xpdf-3.02pl1.patch
+PATCHFILES += xpdf-3.02pl2.patch
+PATCHFILES += xpdf-3.02pl3.patch
+PATCHFILES += patch-GString.cc
+PATCHFILES += patch-XPDFCore.cc
+
+# no test script
+TEST_SCRIPTS =
+
+include gar/category.mk

Added: csw/mgar/pkg/xpdf/trunk/checksums
===================================================================
--- csw/mgar/pkg/xpdf/trunk/checksums	                        (rev 0)
+++ csw/mgar/pkg/xpdf/trunk/checksums	2009-07-17 12:04:47 UTC (rev 5595)
@@ -0,0 +1,6 @@
+28cd772ed42159f2dbbe3a0e8e9e4dfa  download/patch-GString.cc
+4c23bc375fbb6096fb8b2266d0ef527d  download/patch-XPDFCore.cc
+599dc4cc65a07ee868cf92a667a913d2  download/xpdf-3.02.tar.gz
+877118786dfe27d1b7aa5a6759cc6e45  download/xpdf-3.02pl1.patch
+3a5cb165ae66781e0b21e6219ae06795  download/xpdf-3.02pl2.patch
+581963ede0fb5715e1a69f01b5b8ce63  download/xpdf-3.02pl3.patch

Added: csw/mgar/pkg/xpdf/trunk/files/patch-GString.cc
===================================================================
--- csw/mgar/pkg/xpdf/trunk/files/patch-GString.cc	                        (rev 0)
+++ csw/mgar/pkg/xpdf/trunk/files/patch-GString.cc	2009-07-17 12:04:47 UTC (rev 5595)
@@ -0,0 +1,11 @@
+--- xpdf-3.02.orig/goo/GString.cc	2007-02-27 23:05:51.000000000 +0100
++++ xpdf-3.02/goo/GString.cc	2009-07-17 08:14:34.059621276 +0200
+@@ -528,7 +528,7 @@
+   if ((neg = x < 0)) {
+     x = -x;
+   }
+-  x = floor(x * pow(10, prec) + 0.5);
++  x = floor(x * pow((double)10, prec) + 0.5);
+   i = bufSize;
+   started = !trim;
+   for (j = 0; j < prec && i > 1; ++j) {

Added: csw/mgar/pkg/xpdf/trunk/files/patch-XPDFCore.cc
===================================================================
--- csw/mgar/pkg/xpdf/trunk/files/patch-XPDFCore.cc	                        (rev 0)
+++ csw/mgar/pkg/xpdf/trunk/files/patch-XPDFCore.cc	2009-07-17 12:04:47 UTC (rev 5595)
@@ -0,0 +1,10 @@
+--- xpdf-3.02.orig/xpdf/XPDFCore.cc     2007-02-27 23:05:52.000000000 +0100
++++ xpdf-3.02/xpdf/XPDFCore.cc  2009-07-17 12:45:53.330184593 +0200
+@@ -271,7 +271,7 @@
+     XtVaSetValues(shell, XmNwidth, width + (topW - daW),
+                  XmNheight, height + (topH - daH), NULL);
+   } else {
+-    XtVaSetValues(drawArea, XmNwidth, width, XmNheight, height, NULL);
++    XtVaSetValues(shell, XmNwidth, width, XmNheight, height, NULL);
+   }
+ }

Added: csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl1.patch
===================================================================
--- csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl1.patch	                        (rev 0)
+++ csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl1.patch	2009-07-17 12:04:47 UTC (rev 5595)
@@ -0,0 +1,33 @@
+*** xpdf-3.02.orig/xpdf/Stream.cc	Tue Feb 27 14:05:52 2007
+--- xpdf-3.02/xpdf/Stream.cc	Thu Jul 26 14:44:43 2007
+***************
+*** 410,424 ****
+    ok = gFalse;
+  
+    nVals = width * nComps;
+-   if (width <= 0 || nComps <= 0 || nBits <= 0 ||
+-       nComps >= INT_MAX / nBits ||
+-       width >= INT_MAX / nComps / nBits ||
+-       nVals * nBits + 7 < 0) {
+-     return;
+-   }
+    pixBytes = (nComps * nBits + 7) >> 3;
+    rowBytes = ((nVals * nBits + 7) >> 3) + pixBytes;
+!   if (rowBytes <= 0) {
+      return;
+    }
+    predLine = (Guchar *)gmalloc(rowBytes);
+--- 410,422 ----
+    ok = gFalse;
+  
+    nVals = width * nComps;
+    pixBytes = (nComps * nBits + 7) >> 3;
+    rowBytes = ((nVals * nBits + 7) >> 3) + pixBytes;
+!   if (width <= 0 || nComps <= 0 || nBits <= 0 ||
+!       nComps > gfxColorMaxComps ||
+!       nBits > 16 ||
+!       width >= INT_MAX / nComps ||      // check for overflow in nVals 
+!       nVals >= (INT_MAX - 7) / nBits) { // check for overflow in rowBytes
+      return;
+    }
+    predLine = (Guchar *)gmalloc(rowBytes);

Added: csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl2.patch
===================================================================
--- csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl2.patch	                        (rev 0)
+++ csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl2.patch	2009-07-17 12:04:47 UTC (rev 5595)
@@ -0,0 +1,823 @@
+diff -c -r xpdf-3.02pl1.orig/xpdf/Stream.cc xpdf-3.02/xpdf/Stream.cc
+*** xpdf-3.02pl1.orig/xpdf/Stream.cc	Thu Oct 25 15:47:38 2007
+--- xpdf-3.02/xpdf/Stream.cc	Thu Oct 25 15:48:19 2007
+***************
+*** 1243,1265 ****
+    columns = columnsA;
+    if (columns < 1) {
+      columns = 1;
+!   }
+!   if (columns + 4 <= 0) {
+!     columns = INT_MAX - 4;
+    }
+    rows = rowsA;
+    endOfBlock = endOfBlockA;
+    black = blackA;
+!   refLine = (short *)gmallocn(columns + 3, sizeof(short));
+!   codingLine = (short *)gmallocn(columns + 2, sizeof(short));
+  
+    eof = gFalse;
+    row = 0;
+    nextLine2D = encoding < 0;
+    inputBits = 0;
+!   codingLine[0] = 0;
+!   codingLine[1] = refLine[2] = columns;
+!   a0 = 1;
+  
+    buf = EOF;
+  }
+--- 1243,1268 ----
+    columns = columnsA;
+    if (columns < 1) {
+      columns = 1;
+!   } else if (columns > INT_MAX - 2) {
+!     columns = INT_MAX - 2;
+    }
+    rows = rowsA;
+    endOfBlock = endOfBlockA;
+    black = blackA;
+!   // 0 <= codingLine[0] < codingLine[1] < ... < codingLine[n] = columns
+!   // ---> max codingLine size = columns + 1
+!   // refLine has one extra guard entry at the end
+!   // ---> max refLine size = columns + 2
+!   codingLine = (int *)gmallocn(columns + 1, sizeof(int));
+!   refLine = (int *)gmallocn(columns + 2, sizeof(int));
+  
+    eof = gFalse;
+    row = 0;
+    nextLine2D = encoding < 0;
+    inputBits = 0;
+!   codingLine[0] = columns;
+!   a0i = 0;
+!   outputBits = 0;
+  
+    buf = EOF;
+  }
+***************
+*** 1278,1286 ****
+    row = 0;
+    nextLine2D = encoding < 0;
+    inputBits = 0;
+!   codingLine[0] = 0;
+!   codingLine[1] = columns;
+!   a0 = 1;
+    buf = EOF;
+  
+    // skip any initial zero bits and end-of-line marker, and get the 2D
+--- 1281,1289 ----
+    row = 0;
+    nextLine2D = encoding < 0;
+    inputBits = 0;
+!   codingLine[0] = columns;
+!   a0i = 0;
+!   outputBits = 0;
+    buf = EOF;
+  
+    // skip any initial zero bits and end-of-line marker, and get the 2D
+***************
+*** 1297,1507 ****
+    }
+  }
+  
+  int CCITTFaxStream::lookChar() {
+    short code1, code2, code3;
+!   int a0New;
+!   GBool err, gotEOL;
+!   int ret;
+!   int bits, i;
+  
+!   // if at eof just return EOF
+!   if (eof && codingLine[a0] >= columns) {
+!     return EOF;
+    }
+  
+    // read the next row
+!   err = gFalse;
+!   if (codingLine[a0] >= columns) {
+  
+      // 2-D encoding
+      if (nextLine2D) {
+-       // state:
+-       //   a0New = current position in coding line (0 <= a0New <= columns)
+-       //   codingLine[a0] = last change in coding line
+-       //                    (black-to-white if a0 is even,
+-       //                     white-to-black if a0 is odd)
+-       //   refLine[b1] = next change in reference line of opposite color
+-       //                 to a0
+-       // invariants:
+-       //   0 <= codingLine[a0] <= a0New
+-       //           <= refLine[b1] <= refLine[b1+1] <= columns
+-       //   0 <= a0 <= columns+1
+-       //   refLine[0] = 0
+-       //   refLine[n] = refLine[n+1] = columns
+-       //     -- for some 1 <= n <= columns+1
+-       // end condition:
+-       //   0 = codingLine[0] <= codingLine[1] < codingLine[2] < ...
+-       //     < codingLine[n-1] < codingLine[n] = columns
+-       //     -- where 1 <= n <= columns+1
+        for (i = 0; codingLine[i] < columns; ++i) {
+  	refLine[i] = codingLine[i];
+        }
+!       refLine[i] = refLine[i + 1] = columns;
+!       b1 = 1;
+!       a0New = codingLine[a0 = 0] = 0;
+!       do {
+  	code1 = getTwoDimCode();
+  	switch (code1) {
+  	case twoDimPass:
+! 	  if (refLine[b1] < columns) {
+! 	    a0New = refLine[b1 + 1];
+! 	    b1 += 2;
+  	  }
+  	  break;
+  	case twoDimHoriz:
+! 	  if ((a0 & 1) == 0) {
+! 	    code1 = code2 = 0;
+  	    do {
+! 	      code1 += code3 = getWhiteCode();
+  	    } while (code3 >= 64);
+  	    do {
+! 	      code2 += code3 = getBlackCode();
+  	    } while (code3 >= 64);
+  	  } else {
+- 	    code1 = code2 = 0;
+  	    do {
+! 	      code1 += code3 = getBlackCode();
+  	    } while (code3 >= 64);
+  	    do {
+! 	      code2 += code3 = getWhiteCode();
+  	    } while (code3 >= 64);
+  	  }
+! 	  if (code1 > 0 || code2 > 0) {
+! 	    if (a0New + code1 <= columns) {
+! 	      codingLine[a0 + 1] = a0New + code1;
+! 	    } else {
+! 	      codingLine[a0 + 1] = columns;
+! 	    }
+! 	    ++a0;
+! 	    if (codingLine[a0] + code2 <= columns) {
+! 	      codingLine[a0 + 1] = codingLine[a0] + code2;
+! 	    } else {
+! 	      codingLine[a0 + 1] = columns;
+! 	    }
+! 	    ++a0;
+! 	    a0New = codingLine[a0];
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+  	  }
+  	  break;
+! 	case twoDimVert0:
+! 	  if (refLine[b1] < columns) {
+! 	    a0New = codingLine[++a0] = refLine[b1];
+! 	    ++b1;
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+- 	  } else {
+- 	    a0New = codingLine[++a0] = columns;
+  	  }
+  	  break;
+  	case twoDimVertR1:
+! 	  if (refLine[b1] + 1 < columns) {
+! 	    a0New = codingLine[++a0] = refLine[b1] + 1;
+! 	    ++b1;
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+- 	  } else {
+- 	    a0New = codingLine[++a0] = columns;
+  	  }
+  	  break;
+! 	case twoDimVertL1:
+! 	  if (refLine[b1] - 1 > a0New || (a0 == 0 && refLine[b1] == 1)) {
+! 	    a0New = codingLine[++a0] = refLine[b1] - 1;
+! 	    --b1;
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+  	  }
+  	  break;
+! 	case twoDimVertR2:
+! 	  if (refLine[b1] + 2 < columns) {
+! 	    a0New = codingLine[++a0] = refLine[b1] + 2;
+! 	    ++b1;
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+- 	  } else {
+- 	    a0New = codingLine[++a0] = columns;
+  	  }
+  	  break;
+  	case twoDimVertL2:
+! 	  if (refLine[b1] - 2 > a0New || (a0 == 0 && refLine[b1] == 2)) {
+! 	    a0New = codingLine[++a0] = refLine[b1] - 2;
+! 	    --b1;
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+! 	  }
+! 	  break;
+! 	case twoDimVertR3:
+! 	  if (refLine[b1] + 3 < columns) {
+! 	    a0New = codingLine[++a0] = refLine[b1] + 3;
+! 	    ++b1;
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+- 	  } else {
+- 	    a0New = codingLine[++a0] = columns;
+  	  }
+  	  break;
+! 	case twoDimVertL3:
+! 	  if (refLine[b1] - 3 > a0New || (a0 == 0 && refLine[b1] == 3)) {
+! 	    a0New = codingLine[++a0] = refLine[b1] - 3;
+! 	    --b1;
+! 	    while (refLine[b1] <= a0New && refLine[b1] < columns) {
+! 	      b1 += 2;
+  	    }
+  	  }
+  	  break;
+  	case EOF:
+  	  eof = gTrue;
+! 	  codingLine[a0 = 0] = columns;
+! 	  return EOF;
+  	default:
+  	  error(getPos(), "Bad 2D code %04x in CCITTFax stream", code1);
+  	  err = gTrue;
+  	  break;
+  	}
+!       } while (codingLine[a0] < columns);
+  
+      // 1-D encoding
+      } else {
+!       codingLine[a0 = 0] = 0;
+!       while (1) {
+  	code1 = 0;
+! 	do {
+! 	  code1 += code3 = getWhiteCode();
+! 	} while (code3 >= 64);
+! 	codingLine[a0+1] = codingLine[a0] + code1;
+! 	++a0;
+! 	if (codingLine[a0] >= columns) {
+! 	  break;
+! 	}
+! 	code2 = 0;
+! 	do {
+! 	  code2 += code3 = getBlackCode();
+! 	} while (code3 >= 64);
+! 	codingLine[a0+1] = codingLine[a0] + code2;
+! 	++a0;
+! 	if (codingLine[a0] >= columns) {
+! 	  break;
+  	}
+        }
+      }
+  
+-     if (codingLine[a0] != columns) {
+-       error(getPos(), "CCITTFax row is wrong length (%d)", codingLine[a0]);
+-       // force the row to be the correct length
+-       while (codingLine[a0] > columns) {
+- 	--a0;
+-       }
+-       codingLine[++a0] = columns;
+-       err = gTrue;
+-     }
+- 
+      // byte-align the row
+      if (byteAlign) {
+        inputBits &= ~7;
+--- 1300,1529 ----
+    }
+  }
+  
++ inline void CCITTFaxStream::addPixels(int a1, int blackPixels) {
++   if (a1 > codingLine[a0i]) {
++     if (a1 > columns) {
++       error(getPos(), "CCITTFax row is wrong length (%d)", a1);
++       err = gTrue;
++       a1 = columns;
++     }
++     if ((a0i & 1) ^ blackPixels) {
++       ++a0i;
++     }
++     codingLine[a0i] = a1;
++   }
++ }
++ 
++ inline void CCITTFaxStream::addPixelsNeg(int a1, int blackPixels) {
++   if (a1 > codingLine[a0i]) {
++     if (a1 > columns) {
++       error(getPos(), "CCITTFax row is wrong length (%d)", a1);
++       err = gTrue;
++       a1 = columns;
++     }
++     if ((a0i & 1) ^ blackPixels) {
++       ++a0i;
++     }
++     codingLine[a0i] = a1;
++   } else if (a1 < codingLine[a0i]) {
++     if (a1 < 0) {
++       error(getPos(), "Invalid CCITTFax code");
++       err = gTrue;
++       a1 = 0;
++     }
++     while (a0i > 0 && a1 <= codingLine[a0i - 1]) {
++       --a0i;
++     }
++     codingLine[a0i] = a1;
++   }
++ }
++ 
+  int CCITTFaxStream::lookChar() {
+    short code1, code2, code3;
+!   int b1i, blackPixels, i, bits;
+!   GBool gotEOL;
+  
+!   if (buf != EOF) {
+!     return buf;
+    }
+  
+    // read the next row
+!   if (outputBits == 0) {
+! 
+!     // if at eof just return EOF
+!     if (eof) {
+!       return EOF;
+!     }
+! 
+!     err = gFalse;
+  
+      // 2-D encoding
+      if (nextLine2D) {
+        for (i = 0; codingLine[i] < columns; ++i) {
+  	refLine[i] = codingLine[i];
+        }
+!       refLine[i++] = columns;
+!       refLine[i] = columns;
+!       codingLine[0] = 0;
+!       a0i = 0;
+!       b1i = 0;
+!       blackPixels = 0;
+!       // invariant:
+!       // refLine[b1i-1] <= codingLine[a0i] < refLine[b1i] < refLine[b1i+1]
+!       //                                                             <= columns
+!       // exception at left edge:
+!       //   codingLine[a0i = 0] = refLine[b1i = 0] = 0 is possible
+!       // exception at right edge:
+!       //   refLine[b1i] = refLine[b1i+1] = columns is possible
+!       while (codingLine[a0i] < columns) {
+  	code1 = getTwoDimCode();
+  	switch (code1) {
+  	case twoDimPass:
+! 	  addPixels(refLine[b1i + 1], blackPixels);
+! 	  if (refLine[b1i + 1] < columns) {
+! 	    b1i += 2;
+  	  }
+  	  break;
+  	case twoDimHoriz:
+! 	  code1 = code2 = 0;
+! 	  if (blackPixels) {
+  	    do {
+! 	      code1 += code3 = getBlackCode();
+  	    } while (code3 >= 64);
+  	    do {
+! 	      code2 += code3 = getWhiteCode();
+  	    } while (code3 >= 64);
+  	  } else {
+  	    do {
+! 	      code1 += code3 = getWhiteCode();
+  	    } while (code3 >= 64);
+  	    do {
+! 	      code2 += code3 = getBlackCode();
+  	    } while (code3 >= 64);
+  	  }
+! 	  addPixels(codingLine[a0i] + code1, blackPixels);
+! 	  if (codingLine[a0i] < columns) {
+! 	    addPixels(codingLine[a0i] + code2, blackPixels ^ 1);
+! 	  }
+! 	  while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	    b1i += 2;
+! 	  }
+! 	  break;
+! 	case twoDimVertR3:
+! 	  addPixels(refLine[b1i] + 3, blackPixels);
+! 	  blackPixels ^= 1;
+! 	  if (codingLine[a0i] < columns) {
+! 	    ++b1i;
+! 	    while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	      b1i += 2;
+  	    }
+  	  }
+  	  break;
+! 	case twoDimVertR2:
+! 	  addPixels(refLine[b1i] + 2, blackPixels);
+! 	  blackPixels ^= 1;
+! 	  if (codingLine[a0i] < columns) {
+! 	    ++b1i;
+! 	    while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	      b1i += 2;
+  	    }
+  	  }
+  	  break;
+  	case twoDimVertR1:
+! 	  addPixels(refLine[b1i] + 1, blackPixels);
+! 	  blackPixels ^= 1;
+! 	  if (codingLine[a0i] < columns) {
+! 	    ++b1i;
+! 	    while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	      b1i += 2;
+  	    }
+  	  }
+  	  break;
+! 	case twoDimVert0:
+! 	  addPixels(refLine[b1i], blackPixels);
+! 	  blackPixels ^= 1;
+! 	  if (codingLine[a0i] < columns) {
+! 	    ++b1i;
+! 	    while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	      b1i += 2;
+  	    }
+  	  }
+  	  break;
+! 	case twoDimVertL3:
+! 	  addPixelsNeg(refLine[b1i] - 3, blackPixels);
+! 	  blackPixels ^= 1;
+! 	  if (codingLine[a0i] < columns) {
+! 	    if (b1i > 0) {
+! 	      --b1i;
+! 	    } else {
+! 	      ++b1i;
+! 	    }
+! 	    while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	      b1i += 2;
+  	    }
+  	  }
+  	  break;
+  	case twoDimVertL2:
+! 	  addPixelsNeg(refLine[b1i] - 2, blackPixels);
+! 	  blackPixels ^= 1;
+! 	  if (codingLine[a0i] < columns) {
+! 	    if (b1i > 0) {
+! 	      --b1i;
+! 	    } else {
+! 	      ++b1i;
+  	    }
+! 	    while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	      b1i += 2;
+  	    }
+  	  }
+  	  break;
+! 	case twoDimVertL1:
+! 	  addPixelsNeg(refLine[b1i] - 1, blackPixels);
+! 	  blackPixels ^= 1;
+! 	  if (codingLine[a0i] < columns) {
+! 	    if (b1i > 0) {
+! 	      --b1i;
+! 	    } else {
+! 	      ++b1i;
+! 	    }
+! 	    while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < columns) {
+! 	      b1i += 2;
+  	    }
+  	  }
+  	  break;
+  	case EOF:
++ 	  addPixels(columns, 0);
+  	  eof = gTrue;
+! 	  break;
+  	default:
+  	  error(getPos(), "Bad 2D code %04x in CCITTFax stream", code1);
++ 	  addPixels(columns, 0);
+  	  err = gTrue;
+  	  break;
+  	}
+!       }
+  
+      // 1-D encoding
+      } else {
+!       codingLine[0] = 0;
+!       a0i = 0;
+!       blackPixels = 0;
+!       while (codingLine[a0i] < columns) {
+  	code1 = 0;
+! 	if (blackPixels) {
+! 	  do {
+! 	    code1 += code3 = getBlackCode();
+! 	  } while (code3 >= 64);
+! 	} else {
+! 	  do {
+! 	    code1 += code3 = getWhiteCode();
+! 	  } while (code3 >= 64);
+  	}
++ 	addPixels(codingLine[a0i] + code1, blackPixels);
++ 	blackPixels ^= 1;
+        }
+      }
+  
+      // byte-align the row
+      if (byteAlign) {
+        inputBits &= ~7;
+***************
+*** 1560,1573 ****
+      // this if we know the stream contains end-of-line markers because
+      // the "just plow on" technique tends to work better otherwise
+      } else if (err && endOfLine) {
+!       do {
+  	if (code1 == EOF) {
+  	  eof = gTrue;
+  	  return EOF;
+  	}
+  	eatBits(1);
+! 	code1 = lookBits(13);
+!       } while ((code1 >> 1) != 0x001);
+        eatBits(12); 
+        if (encoding > 0) {
+  	eatBits(1);
+--- 1582,1598 ----
+      // this if we know the stream contains end-of-line markers because
+      // the "just plow on" technique tends to work better otherwise
+      } else if (err && endOfLine) {
+!       while (1) {
+! 	code1 = lookBits(13);
+  	if (code1 == EOF) {
+  	  eof = gTrue;
+  	  return EOF;
+  	}
++ 	if ((code1 >> 1) == 0x001) {
++ 	  break;
++ 	}
+  	eatBits(1);
+!       }
+        eatBits(12); 
+        if (encoding > 0) {
+  	eatBits(1);
+***************
+*** 1575,1585 ****
+        }
+      }
+  
+!     a0 = 0;
+!     outputBits = codingLine[1] - codingLine[0];
+!     if (outputBits == 0) {
+!       a0 = 1;
+!       outputBits = codingLine[2] - codingLine[1];
+      }
+  
+      ++row;
+--- 1600,1610 ----
+        }
+      }
+  
+!     // set up for output
+!     if (codingLine[0] > 0) {
+!       outputBits = codingLine[a0i = 0];
+!     } else {
+!       outputBits = codingLine[a0i = 1];
+      }
+  
+      ++row;
+***************
+*** 1587,1625 ****
+  
+    // get a byte
+    if (outputBits >= 8) {
+!     ret = ((a0 & 1) == 0) ? 0xff : 0x00;
+!     if ((outputBits -= 8) == 0) {
+!       ++a0;
+!       if (codingLine[a0] < columns) {
+! 	outputBits = codingLine[a0 + 1] - codingLine[a0];
+!       }
+      }
+    } else {
+      bits = 8;
+!     ret = 0;
+      do {
+        if (outputBits > bits) {
+! 	i = bits;
+! 	bits = 0;
+! 	if ((a0 & 1) == 0) {
+! 	  ret |= 0xff >> (8 - i);
+  	}
+! 	outputBits -= i;
+        } else {
+! 	i = outputBits;
+! 	bits -= outputBits;
+! 	if ((a0 & 1) == 0) {
+! 	  ret |= (0xff >> (8 - i)) << bits;
+  	}
+  	outputBits = 0;
+! 	++a0;
+! 	if (codingLine[a0] < columns) {
+! 	  outputBits = codingLine[a0 + 1] - codingLine[a0];
+  	}
+        }
+!     } while (bits > 0 && codingLine[a0] < columns);
+    }
+-   buf = black ? (ret ^ 0xff) : ret;
+    return buf;
+  }
+  
+--- 1612,1654 ----
+  
+    // get a byte
+    if (outputBits >= 8) {
+!     buf = (a0i & 1) ? 0x00 : 0xff;
+!     outputBits -= 8;
+!     if (outputBits == 0 && codingLine[a0i] < columns) {
+!       ++a0i;
+!       outputBits = codingLine[a0i] - codingLine[a0i - 1];
+      }
+    } else {
+      bits = 8;
+!     buf = 0;
+      do {
+        if (outputBits > bits) {
+! 	buf <<= bits;
+! 	if (!(a0i & 1)) {
+! 	  buf |= 0xff >> (8 - bits);
+  	}
+! 	outputBits -= bits;
+! 	bits = 0;
+        } else {
+! 	buf <<= outputBits;
+! 	if (!(a0i & 1)) {
+! 	  buf |= 0xff >> (8 - outputBits);
+  	}
++ 	bits -= outputBits;
+  	outputBits = 0;
+! 	if (codingLine[a0i] < columns) {
+! 	  ++a0i;
+! 	  outputBits = codingLine[a0i] - codingLine[a0i - 1];
+! 	} else if (bits > 0) {
+! 	  buf <<= bits;
+! 	  bits = 0;
+  	}
+        }
+!     } while (bits);
+!   }
+!   if (black) {
+!     buf ^= 0xff;
+    }
+    return buf;
+  }
+  
+***************
+*** 1661,1666 ****
+--- 1690,1698 ----
+    code = 0; // make gcc happy
+    if (endOfBlock) {
+      code = lookBits(12);
++     if (code == EOF) {
++       return 1;
++     }
+      if ((code >> 5) == 0) {
+        p = &whiteTab1[code];
+      } else {
+***************
+*** 1673,1678 ****
+--- 1705,1713 ----
+    } else {
+      for (n = 1; n <= 9; ++n) {
+        code = lookBits(n);
++       if (code == EOF) {
++ 	return 1;
++       }
+        if (n < 9) {
+  	code <<= 9 - n;
+        }
+***************
+*** 1684,1689 ****
+--- 1719,1727 ----
+      }
+      for (n = 11; n <= 12; ++n) {
+        code = lookBits(n);
++       if (code == EOF) {
++ 	return 1;
++       }
+        if (n < 12) {
+  	code <<= 12 - n;
+        }
+***************
+*** 1709,1717 ****
+    code = 0; // make gcc happy
+    if (endOfBlock) {
+      code = lookBits(13);
+      if ((code >> 7) == 0) {
+        p = &blackTab1[code];
+!     } else if ((code >> 9) == 0) {
+        p = &blackTab2[(code >> 1) - 64];
+      } else {
+        p = &blackTab3[code >> 7];
+--- 1747,1758 ----
+    code = 0; // make gcc happy
+    if (endOfBlock) {
+      code = lookBits(13);
++     if (code == EOF) {
++       return 1;
++     }
+      if ((code >> 7) == 0) {
+        p = &blackTab1[code];
+!     } else if ((code >> 9) == 0 && (code >> 7) != 0) {
+        p = &blackTab2[(code >> 1) - 64];
+      } else {
+        p = &blackTab3[code >> 7];
+***************
+*** 1723,1728 ****
+--- 1764,1772 ----
+    } else {
+      for (n = 2; n <= 6; ++n) {
+        code = lookBits(n);
++       if (code == EOF) {
++ 	return 1;
++       }
+        if (n < 6) {
+  	code <<= 6 - n;
+        }
+***************
+*** 1734,1739 ****
+--- 1778,1786 ----
+      }
+      for (n = 7; n <= 12; ++n) {
+        code = lookBits(n);
++       if (code == EOF) {
++ 	return 1;
++       }
+        if (n < 12) {
+  	code <<= 12 - n;
+        }
+***************
+*** 1747,1752 ****
+--- 1794,1802 ----
+      }
+      for (n = 10; n <= 13; ++n) {
+        code = lookBits(n);
++       if (code == EOF) {
++ 	return 1;
++       }
+        if (n < 13) {
+  	code <<= 13 - n;
+        }
+***************
+*** 1961,1966 ****
+--- 2011,2022 ----
+      // allocate a buffer for the whole image
+      bufWidth = ((width + mcuWidth - 1) / mcuWidth) * mcuWidth;
+      bufHeight = ((height + mcuHeight - 1) / mcuHeight) * mcuHeight;
++     if (bufWidth <= 0 || bufHeight <= 0 ||
++ 	bufWidth > INT_MAX / bufWidth / (int)sizeof(int)) {
++       error(getPos(), "Invalid image size in DCT stream");
++       y = height;
++       return;
++     }
+      for (i = 0; i < numComps; ++i) {
+        frameBuf[i] = (int *)gmallocn(bufWidth * bufHeight, sizeof(int));
+        memset(frameBuf[i], 0, bufWidth * bufHeight * sizeof(int));
+***************
+*** 3036,3041 ****
+--- 3092,3102 ----
+    }
+    scanInfo.firstCoeff = str->getChar();
+    scanInfo.lastCoeff = str->getChar();
++   if (scanInfo.firstCoeff < 0 || scanInfo.lastCoeff > 63 ||
++       scanInfo.firstCoeff > scanInfo.lastCoeff) {
++     error(getPos(), "Bad DCT coefficient numbers in scan info block");
++     return gFalse;
++   }
+    c = str->getChar();
+    scanInfo.ah = (c >> 4) & 0x0f;
+    scanInfo.al = c & 0x0f;
+diff -c -r xpdf-3.02pl1.orig/xpdf/Stream.h xpdf-3.02/xpdf/Stream.h
+*** xpdf-3.02pl1.orig/xpdf/Stream.h	Tue Feb 27 14:05:52 2007
+--- xpdf-3.02/xpdf/Stream.h	Thu Oct 25 15:48:15 2007
+***************
+*** 528,540 ****
+    int row;			// current row
+    int inputBuf;			// input buffer
+    int inputBits;		// number of bits in input buffer
+!   short *refLine;		// reference line changing elements
+!   int b1;			// index into refLine
+!   short *codingLine;		// coding line changing elements
+!   int a0;			// index into codingLine
+    int outputBits;		// remaining ouput bits
+    int buf;			// character buffer
+  
+    short getTwoDimCode();
+    short getWhiteCode();
+    short getBlackCode();
+--- 528,542 ----
+    int row;			// current row
+    int inputBuf;			// input buffer
+    int inputBits;		// number of bits in input buffer
+!   int *codingLine;		// coding line changing elements
+!   int *refLine;			// reference line changing elements
+!   int a0i;			// index into codingLine
+!   GBool err;			// error on current line
+    int outputBits;		// remaining ouput bits
+    int buf;			// character buffer
+  
++   void addPixels(int a1, int black);
++   void addPixelsNeg(int a1, int black);
+    short getTwoDimCode();
+    short getWhiteCode();
+    short getBlackCode();

Added: csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl3.patch
===================================================================
--- csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl3.patch	                        (rev 0)
+++ csw/mgar/pkg/xpdf/trunk/files/xpdf-3.02pl3.patch	2009-07-17 12:04:47 UTC (rev 5595)
@@ -0,0 +1,1145 @@
+diff -r -c xpdf-3.02.orig/goo/gmem.cc xpdf-3.02/goo/gmem.cc
+*** xpdf-3.02.orig/goo/gmem.cc	Tue Feb 27 14:05:51 2007
+--- xpdf-3.02/goo/gmem.cc	Thu Mar 19 15:47:25 2009
+***************
+*** 55,61 ****
+    void *data;
+    unsigned long *trl, *p;
+  
+!   if (size <= 0) {
+      return NULL;
+    }
+    size1 = gMemDataSize(size);
+--- 55,69 ----
+    void *data;
+    unsigned long *trl, *p;
+  
+!   if (size < 0) {
+! #if USE_EXCEPTIONS
+!     throw GMemException();
+! #else
+!     fprintf(stderr, "Invalid memory allocation size\n");
+!     exit(1);
+! #endif
+!   }
+!   if (size == 0) {
+      return NULL;
+    }
+    size1 = gMemDataSize(size);
+***************
+*** 91,97 ****
+  #else
+    void *p;
+  
+!   if (size <= 0) {
+      return NULL;
+    }
+    if (!(p = malloc(size))) {
+--- 99,113 ----
+  #else
+    void *p;
+  
+!   if (size < 0) {
+! #if USE_EXCEPTIONS
+!     throw GMemException();
+! #else
+!     fprintf(stderr, "Invalid memory allocation size\n");
+!     exit(1);
+! #endif
+!   }
+!   if (size == 0) {
+      return NULL;
+    }
+    if (!(p = malloc(size))) {
+***************
+*** 112,118 ****
+    void *q;
+    int oldSize;
+  
+!   if (size <= 0) {
+      if (p) {
+        gfree(p);
+      }
+--- 128,142 ----
+    void *q;
+    int oldSize;
+  
+!   if (size < 0) {
+! #if USE_EXCEPTIONS
+!     throw GMemException();
+! #else
+!     fprintf(stderr, "Invalid memory allocation size\n");
+!     exit(1);
+! #endif
+!   }
+!   if (size == 0) {
+      if (p) {
+        gfree(p);
+      }
+***************
+*** 131,137 ****
+  #else
+    void *q;
+  
+!   if (size <= 0) {
+      if (p) {
+        free(p);
+      }
+--- 155,169 ----
+  #else
+    void *q;
+  
+!   if (size < 0) {
+! #if USE_EXCEPTIONS
+!     throw GMemException();
+! #else
+!     fprintf(stderr, "Invalid memory allocation size\n");
+!     exit(1);
+! #endif
+!   }
+!   if (size == 0) {
+      if (p) {
+        free(p);
+      }
+diff -r -c xpdf-3.02.orig/xpdf/JBIG2Stream.cc xpdf-3.02/xpdf/JBIG2Stream.cc
+*** xpdf-3.02.orig/xpdf/JBIG2Stream.cc	Tue Feb 27 14:05:52 2007
+--- xpdf-3.02/xpdf/JBIG2Stream.cc	Tue Mar 31 10:55:23 2009
+***************
+*** 422,433 ****
+    table[i] = table[len];
+  
+    // assign prefixes
+!   i = 0;
+!   prefix = 0;
+!   table[i++].prefix = prefix++;
+!   for (; table[i].rangeLen != jbig2HuffmanEOT; ++i) {
+!     prefix <<= table[i].prefixLen - table[i-1].prefixLen;
+!     table[i].prefix = prefix++;
+    }
+  }
+  
+--- 422,435 ----
+    table[i] = table[len];
+  
+    // assign prefixes
+!   if (table[0].rangeLen != jbig2HuffmanEOT) {
+!     i = 0;
+!     prefix = 0;
+!     table[i++].prefix = prefix++;
+!     for (; table[i].rangeLen != jbig2HuffmanEOT; ++i) {
+!       prefix <<= table[i].prefixLen - table[i-1].prefixLen;
+!       table[i].prefix = prefix++;
+!     }
+    }
+  }
+  
+***************
+*** 491,497 ****
+    }
+    if (p->bits < 0) {
+      error(str->getPos(), "Bad two dim code in JBIG2 MMR stream");
+!     return 0;
+    }
+    bufLen -= p->bits;
+    return p->n;
+--- 493,499 ----
+    }
+    if (p->bits < 0) {
+      error(str->getPos(), "Bad two dim code in JBIG2 MMR stream");
+!     return EOF;
+    }
+    bufLen -= p->bits;
+    return p->n;
+***************
+*** 507,513 ****
+      ++nBytesRead;
+    }
+    while (1) {
+!     if (bufLen >= 7 && ((buf >> (bufLen - 7)) & 0x7f) == 0) {
+        if (bufLen <= 12) {
+  	code = buf << (12 - bufLen);
+        } else {
+--- 509,515 ----
+      ++nBytesRead;
+    }
+    while (1) {
+!     if (bufLen >= 11 && ((buf >> (bufLen - 7)) & 0x7f) == 0) {
+        if (bufLen <= 12) {
+  	code = buf << (12 - bufLen);
+        } else {
+***************
+*** 550,563 ****
+      ++nBytesRead;
+    }
+    while (1) {
+!     if (bufLen >= 6 && ((buf >> (bufLen - 6)) & 0x3f) == 0) {
+        if (bufLen <= 13) {
+  	code = buf << (13 - bufLen);
+        } else {
+  	code = buf >> (bufLen - 13);
+        }
+        p = &blackTab1[code & 0x7f];
+!     } else if (bufLen >= 4 && ((buf >> (bufLen - 4)) & 0x0f) == 0) {
+        if (bufLen <= 12) {
+  	code = buf << (12 - bufLen);
+        } else {
+--- 552,566 ----
+      ++nBytesRead;
+    }
+    while (1) {
+!     if (bufLen >= 10 && ((buf >> (bufLen - 6)) & 0x3f) == 0) {
+        if (bufLen <= 13) {
+  	code = buf << (13 - bufLen);
+        } else {
+  	code = buf >> (bufLen - 13);
+        }
+        p = &blackTab1[code & 0x7f];
+!     } else if (bufLen >= 7 && ((buf >> (bufLen - 4)) & 0x0f) == 0 &&
+! 	       ((buf >> (bufLen - 6)) & 0x03) != 0) {
+        if (bufLen <= 12) {
+  	code = buf << (12 - bufLen);
+        } else {
+***************
+*** 683,690 ****
+    h = hA;
+    line = (wA + 7) >> 3;
+    if (w <= 0 || h <= 0 || line <= 0 || h >= (INT_MAX - 1) / line) {
+!     data = NULL;
+!     return;
+    }
+    // need to allocate one extra guard byte for use in combine()
+    data = (Guchar *)gmalloc(h * line + 1);
+--- 686,694 ----
+    h = hA;
+    line = (wA + 7) >> 3;
+    if (w <= 0 || h <= 0 || line <= 0 || h >= (INT_MAX - 1) / line) {
+!     // force a call to gmalloc(-1), which will throw an exception
+!     h = -1;
+!     line = 2;
+    }
+    // need to allocate one extra guard byte for use in combine()
+    data = (Guchar *)gmalloc(h * line + 1);
+***************
+*** 698,705 ****
+    h = bitmap->h;
+    line = bitmap->line;
+    if (w <= 0 || h <= 0 || line <= 0 || h >= (INT_MAX - 1) / line) {
+!     data = NULL;
+!     return;
+    }
+    // need to allocate one extra guard byte for use in combine()
+    data = (Guchar *)gmalloc(h * line + 1);
+--- 702,710 ----
+    h = bitmap->h;
+    line = bitmap->line;
+    if (w <= 0 || h <= 0 || line <= 0 || h >= (INT_MAX - 1) / line) {
+!     // force a call to gmalloc(-1), which will throw an exception
+!     h = -1;
+!     line = 2;
+    }
+    // need to allocate one extra guard byte for use in combine()
+    data = (Guchar *)gmalloc(h * line + 1);
+***************
+*** 754,759 ****
+--- 759,766 ----
+  inline void JBIG2Bitmap::getPixelPtr(int x, int y, JBIG2BitmapPtr *ptr) {
+    if (y < 0 || y >= h || x >= w) {
+      ptr->p = NULL;
++     ptr->shift = 0; // make gcc happy
++     ptr->x = 0; // make gcc happy
+    } else if (x < 0) {
+      ptr->p = &data[y * line];
+      ptr->shift = 7;
+***************
+*** 798,803 ****
+--- 805,814 ----
+    Guint src0, src1, src, dest, s1, s2, m1, m2, m3;
+    GBool oneByte;
+  
++   // check for the pathological case where y = -2^31
++   if (y < -0x7fffffff) {
++     return;
++   }
+    if (y < 0) {
+      y0 = -y;
+    } else {
+***************
+*** 1011,1018 ****
+--- 1022,1034 ----
+  JBIG2SymbolDict::JBIG2SymbolDict(Guint segNumA, Guint sizeA):
+    JBIG2Segment(segNumA)
+  {
++   Guint i;
++ 
+    size = sizeA;
+    bitmaps = (JBIG2Bitmap **)gmallocn(size, sizeof(JBIG2Bitmap *));
++   for (i = 0; i < size; ++i) {
++     bitmaps[i] = NULL;
++   }
+    genericRegionStats = NULL;
+    refinementRegionStats = NULL;
+  }
+***************
+*** 1021,1027 ****
+    Guint i;
+  
+    for (i = 0; i < size; ++i) {
+!     delete bitmaps[i];
+    }
+    gfree(bitmaps);
+    if (genericRegionStats) {
+--- 1037,1045 ----
+    Guint i;
+  
+    for (i = 0; i < size; ++i) {
+!     if (bitmaps[i]) {
+!       delete bitmaps[i];
+!     }
+    }
+    gfree(bitmaps);
+    if (genericRegionStats) {
+***************
+*** 1296,1301 ****
+--- 1314,1326 ----
+        goto eofError2;
+      }
+  
++     // check for missing page information segment
++     if (!pageBitmap && ((segType >= 4 && segType <= 7) ||
++ 			(segType >= 20 && segType <= 43))) {
++       error(getPos(), "First JBIG2 segment associated with a page must be a page information segment");
++       goto syntaxError;
++     }
++ 
+      // read the segment data
+      switch (segType) {
+      case 0:
+***************
+*** 1411,1416 ****
+--- 1436,1443 ----
+    Guint i, j, k;
+    Guchar *p;
+  
++   symWidths = NULL;
++ 
+    // symbol dictionary flags
+    if (!readUWord(&flags)) {
+      goto eofError;
+***************
+*** 1466,1485 ****
+    codeTables = new GList();
+    numInputSyms = 0;
+    for (i = 0; i < nRefSegs; ++i) {
+!     seg = findSegment(refSegs[i]);
+!     if (seg->getType() == jbig2SegSymbolDict) {
+!       numInputSyms += ((JBIG2SymbolDict *)seg)->getSize();
+!     } else if (seg->getType() == jbig2SegCodeTable) {
+!       codeTables->append(seg);
+      }
+    }
+  
+    // compute symbol code length
+!   symCodeLen = 0;
+!   i = 1;
+!   while (i < numInputSyms + numNewSyms) {
+      ++symCodeLen;
+!     i <<= 1;
+    }
+  
+    // get the input symbol bitmaps
+--- 1493,1524 ----
+    codeTables = new GList();
+    numInputSyms = 0;
+    for (i = 0; i < nRefSegs; ++i) {
+!     if ((seg = findSegment(refSegs[i]))) {
+!       if (seg->getType() == jbig2SegSymbolDict) {
+! 	j = ((JBIG2SymbolDict *)seg)->getSize();
+! 	if (numInputSyms > UINT_MAX - j) {
+! 	  error(getPos(), "Too many input symbols in JBIG2 symbol dictionary");
+! 	  delete codeTables;
+! 	  goto eofError;
+! 	}
+! 	numInputSyms += j;
+!       } else if (seg->getType() == jbig2SegCodeTable) {
+! 	codeTables->append(seg);
+!       }
+      }
+    }
++   if (numInputSyms > UINT_MAX - numNewSyms) {
++     error(getPos(), "Too many input symbols in JBIG2 symbol dictionary");
++     delete codeTables;
++     goto eofError;
++   }
+  
+    // compute symbol code length
+!   symCodeLen = 1;
+!   i = (numInputSyms + numNewSyms) >> 1;
+!   while (i) {
+      ++symCodeLen;
+!     i >>= 1;
+    }
+  
+    // get the input symbol bitmaps
+***************
+*** 1491,1501 ****
+    k = 0;
+    inputSymbolDict = NULL;
+    for (i = 0; i < nRefSegs; ++i) {
+!     seg = findSegment(refSegs[i]);
+!     if (seg->getType() == jbig2SegSymbolDict) {
+!       inputSymbolDict = (JBIG2SymbolDict *)seg;
+!       for (j = 0; j < inputSymbolDict->getSize(); ++j) {
+! 	bitmaps[k++] = inputSymbolDict->getBitmap(j);
+        }
+      }
+    }
+--- 1530,1541 ----
+    k = 0;
+    inputSymbolDict = NULL;
+    for (i = 0; i < nRefSegs; ++i) {
+!     if ((seg = findSegment(refSegs[i]))) {
+!       if (seg->getType() == jbig2SegSymbolDict) {
+! 	inputSymbolDict = (JBIG2SymbolDict *)seg;
+! 	for (j = 0; j < inputSymbolDict->getSize(); ++j) {
+! 	  bitmaps[k++] = inputSymbolDict->getBitmap(j);
+! 	}
+        }
+      }
+    }
+***************
+*** 1510,1515 ****
+--- 1550,1558 ----
+      } else if (huffDH == 1) {
+        huffDHTable = huffTableE;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffDHTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffDW == 0) {
+***************
+*** 1517,1533 ****
+--- 1560,1585 ----
+      } else if (huffDW == 1) {
+        huffDWTable = huffTableC;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffDWTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffBMSize == 0) {
+        huffBMSizeTable = huffTableA;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffBMSizeTable =
+  	  ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffAggInst == 0) {
+        huffAggInstTable = huffTableA;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffAggInstTable =
+  	  ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+***************
+*** 1560,1566 ****
+    }
+  
+    // allocate symbol widths storage
+-   symWidths = NULL;
+    if (huff && !refAgg) {
+      symWidths = (Guint *)gmallocn(numNewSyms, sizeof(Guint));
+    }
+--- 1612,1617 ----
+***************
+*** 1602,1607 ****
+--- 1653,1662 ----
+  	goto syntaxError;
+        }
+        symWidth += dw;
++       if (i >= numNewSyms) {
++ 	error(getPos(), "Too many symbols in JBIG2 symbol dictionary");
++ 	goto syntaxError;
++       }
+  
+        // using a collective bitmap, so don't read a bitmap here
+        if (huff && !refAgg) {
+***************
+*** 1638,1643 ****
+--- 1693,1702 ----
+  	    arithDecoder->decodeInt(&refDX, iardxStats);
+  	    arithDecoder->decodeInt(&refDY, iardyStats);
+  	  }
++ 	  if (symID >= numInputSyms + i) {
++ 	    error(getPos(), "Invalid symbol ID in JBIG2 symbol dictionary");
++ 	    goto syntaxError;
++ 	  }
+  	  refBitmap = bitmaps[symID];
+  	  bitmaps[numInputSyms + i] =
+  	      readGenericRefinementRegion(symWidth, symHeight,
+***************
+*** 1704,1709 ****
+--- 1763,1774 ----
+      } else {
+        arithDecoder->decodeInt(&run, iaexStats);
+      }
++     if (i + run > numInputSyms + numNewSyms ||
++ 	(ex && j + run > numExSyms)) {
++       error(getPos(), "Too many exported symbols in JBIG2 symbol dictionary");
++       delete symbolDict;
++       goto syntaxError;
++     }
+      if (ex) {
+        for (cnt = 0; cnt < run; ++cnt) {
+  	symbolDict->setBitmap(j++, bitmaps[i++]->copy());
+***************
+*** 1713,1718 ****
+--- 1778,1788 ----
+      }
+      ex = !ex;
+    }
++   if (j != numExSyms) {
++     error(getPos(), "Too few symbols in JBIG2 symbol dictionary");
++     delete symbolDict;
++     goto syntaxError;
++   }
+  
+    for (i = 0; i < numNewSyms; ++i) {
+      delete bitmaps[numInputSyms + i];
+***************
+*** 1735,1740 ****
+--- 1805,1814 ----
+  
+    return gTrue;
+  
++  codeTableError:
++   error(getPos(), "Missing code table in JBIG2 symbol dictionary");
++   delete codeTables;
++ 
+   syntaxError:
+    for (i = 0; i < numNewSyms; ++i) {
+      if (bitmaps[numInputSyms + i]) {
+***************
+*** 1837,1842 ****
+--- 1911,1918 ----
+        }
+      } else {
+        error(getPos(), "Invalid segment reference in JBIG2 text region");
++       delete codeTables;
++       return;
+      }
+    }
+    symCodeLen = 0;
+***************
+*** 1871,1876 ****
+--- 1947,1955 ----
+      } else if (huffFS == 1) {
+        huffFSTable = huffTableG;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffFSTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffDS == 0) {
+***************
+*** 1880,1885 ****
+--- 1959,1967 ----
+      } else if (huffDS == 2) {
+        huffDSTable = huffTableJ;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffDSTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffDT == 0) {
+***************
+*** 1889,1894 ****
+--- 1971,1979 ----
+      } else if (huffDT == 2) {
+        huffDTTable = huffTableM;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffDTTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffRDW == 0) {
+***************
+*** 1896,1901 ****
+--- 1981,1989 ----
+      } else if (huffRDW == 1) {
+        huffRDWTable = huffTableO;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffRDWTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffRDH == 0) {
+***************
+*** 1903,1908 ****
+--- 1991,1999 ----
+      } else if (huffRDH == 1) {
+        huffRDHTable = huffTableO;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffRDHTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffRDX == 0) {
+***************
+*** 1910,1915 ****
+--- 2001,2009 ----
+      } else if (huffRDX == 1) {
+        huffRDXTable = huffTableO;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffRDXTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffRDY == 0) {
+***************
+*** 1917,1927 ****
+--- 2011,2027 ----
+      } else if (huffRDY == 1) {
+        huffRDYTable = huffTableO;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffRDYTable = ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+      if (huffRSize == 0) {
+        huffRSizeTable = huffTableA;
+      } else {
++       if (i >= (Guint)codeTables->getLength()) {
++ 	goto codeTableError;
++       }
+        huffRSizeTable =
+  	  ((JBIG2CodeTable *)codeTables->get(i++))->getHuffTable();
+      }
+***************
+*** 2016,2023 ****
+--- 2116,2130 ----
+  
+    return;
+  
++  codeTableError:
++   error(getPos(), "Missing code table in JBIG2 text region");
++   gfree(codeTables);
++   delete syms;
++   return;
++ 
+   eofError:
+    error(getPos(), "Unexpected EOF in JBIG2 stream");
++   return;
+  }
+  
+  JBIG2Bitmap *JBIG2Stream::readTextRegion(GBool huff, GBool refine,
+***************
+*** 2324,2331 ****
+      error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
+      return;
+    }
+!   seg = findSegment(refSegs[0]);
+!   if (seg->getType() != jbig2SegPatternDict) {
+      error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
+      return;
+    }
+--- 2431,2438 ----
+      error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
+      return;
+    }
+!   if (!(seg = findSegment(refSegs[0])) ||
+!       seg->getType() != jbig2SegPatternDict) {
+      error(getPos(), "Bad symbol dictionary reference in JBIG2 halftone segment");
+      return;
+    }
+***************
+*** 2483,2489 ****
+  
+    // read the bitmap
+    bitmap = readGenericBitmap(mmr, w, h, templ, tpgdOn, gFalse,
+! 			     NULL, atx, aty, mmr ? 0 : length - 18);
+  
+    // combine the region bitmap into the page bitmap
+    if (imm) {
+--- 2590,2596 ----
+  
+    // read the bitmap
+    bitmap = readGenericBitmap(mmr, w, h, templ, tpgdOn, gFalse,
+! 			     NULL, atx, aty, mmr ? length - 18 : 0);
+  
+    // combine the region bitmap into the page bitmap
+    if (imm) {
+***************
+*** 2505,2510 ****
+--- 2612,2654 ----
+    error(getPos(), "Unexpected EOF in JBIG2 stream");
+  }
+  
++ inline void JBIG2Stream::mmrAddPixels(int a1, int blackPixels,
++ 				      int *codingLine, int *a0i, int w) {
++   if (a1 > codingLine[*a0i]) {
++     if (a1 > w) {
++       error(getPos(), "JBIG2 MMR row is wrong length ({0:d})", a1);
++       a1 = w;
++     }
++     if ((*a0i & 1) ^ blackPixels) {
++       ++*a0i;
++     }
++     codingLine[*a0i] = a1;
++   }
++ }
++ 
++ inline void JBIG2Stream::mmrAddPixelsNeg(int a1, int blackPixels,
++ 					 int *codingLine, int *a0i, int w) {
++   if (a1 > codingLine[*a0i]) {
++     if (a1 > w) {
++       error(getPos(), "JBIG2 MMR row is wrong length ({0:d})", a1);
++       a1 = w;
++     }
++     if ((*a0i & 1) ^ blackPixels) {
++       ++*a0i;
++     }
++     codingLine[*a0i] = a1;
++   } else if (a1 < codingLine[*a0i]) {
++     if (a1 < 0) {
++       error(getPos(), "Invalid JBIG2 MMR code");
++       a1 = 0;
++     }
++     while (*a0i > 0 && a1 <= codingLine[*a0i - 1]) {
++       --*a0i;
++     }
++     codingLine[*a0i] = a1;
++   }
++ }
++ 
+  JBIG2Bitmap *JBIG2Stream::readGenericBitmap(GBool mmr, int w, int h,
+  					    int templ, GBool tpgdOn,
+  					    GBool useSkip, JBIG2Bitmap *skip,
+***************
+*** 2517,2523 ****
+    JBIG2BitmapPtr atPtr0, atPtr1, atPtr2, atPtr3;
+    int *refLine, *codingLine;
+    int code1, code2, code3;
+!   int x, y, a0, pix, i, refI, codingI;
+  
+    bitmap = new JBIG2Bitmap(0, w, h);
+    bitmap->clearToZero();
+--- 2661,2667 ----
+    JBIG2BitmapPtr atPtr0, atPtr1, atPtr2, atPtr3;
+    int *refLine, *codingLine;
+    int code1, code2, code3;
+!   int x, y, a0i, b1i, blackPixels, pix, i;
+  
+    bitmap = new JBIG2Bitmap(0, w, h);
+    bitmap->clearToZero();
+***************
+*** 2527,2535 ****
+    if (mmr) {
+  
+      mmrDecoder->reset();
+      refLine = (int *)gmallocn(w + 2, sizeof(int));
+!     codingLine = (int *)gmallocn(w + 2, sizeof(int));
+!     codingLine[0] = codingLine[1] = w;
+  
+      for (y = 0; y < h; ++y) {
+  
+--- 2671,2688 ----
+    if (mmr) {
+  
+      mmrDecoder->reset();
++     if (w > INT_MAX - 2) {
++       error(getPos(), "Bad width in JBIG2 generic bitmap");
++       // force a call to gmalloc(-1), which will throw an exception
++       w = -3;
++     }
++     // 0 <= codingLine[0] < codingLine[1] < ... < codingLine[n] = w
++     // ---> max codingLine size = w + 1
++     // refLine has one extra guard entry at the end
++     // ---> max refLine size = w + 2
++     codingLine = (int *)gmallocn(w + 1, sizeof(int));
+      refLine = (int *)gmallocn(w + 2, sizeof(int));
+!     codingLine[0] = w;
+  
+      for (y = 0; y < h; ++y) {
+  
+***************
+*** 2537,2664 ****
+        for (i = 0; codingLine[i] < w; ++i) {
+  	refLine[i] = codingLine[i];
+        }
+!       refLine[i] = refLine[i + 1] = w;
+  
+        // decode a line
+!       refI = 0;     // b1 = refLine[refI]
+!       codingI = 0;  // a1 = codingLine[codingI]
+!       a0 = 0;
+!       do {
+  	code1 = mmrDecoder->get2DCode();
+  	switch (code1) {
+  	case twoDimPass:
+! 	  if (refLine[refI] < w) {
+! 	    a0 = refLine[refI + 1];
+! 	    refI += 2;
+! 	  }
+! 	  break;
+  	case twoDimHoriz:
+! 	  if (codingI & 1) {
+! 	    code1 = 0;
+! 	    do {
+! 	      code1 += code3 = mmrDecoder->getBlackCode();
+! 	    } while (code3 >= 64);
+! 	    code2 = 0;
+! 	    do {
+! 	      code2 += code3 = mmrDecoder->getWhiteCode();
+! 	    } while (code3 >= 64);
+! 	  } else {
+! 	    code1 = 0;
+! 	    do {
+! 	      code1 += code3 = mmrDecoder->getWhiteCode();
+! 	    } while (code3 >= 64);
+! 	    code2 = 0;
+! 	    do {
+! 	      code2 += code3 = mmrDecoder->getBlackCode();
+! 	    } while (code3 >= 64);
+! 	  }
+! 	  if (code1 > 0 || code2 > 0) {
+! 	    a0 = codingLine[codingI++] = a0 + code1;
+! 	    a0 = codingLine[codingI++] = a0 + code2;
+! 	    while (refLine[refI] <= a0 && refLine[refI] < w) {
+! 	      refI += 2;
+! 	    }
+! 	  }
+! 	  break;
+! 	case twoDimVert0:
+! 	  a0 = codingLine[codingI++] = refLine[refI];
+! 	  if (refLine[refI] < w) {
+! 	    ++refI;
+! 	  }
+! 	  break;
+! 	case twoDimVertR1:
+! 	  a0 = codingLine[codingI++] = refLine[refI] + 1;
+! 	  if (refLine[refI] < w) {
+! 	    ++refI;
+! 	    while (refLine[refI] <= a0 && refLine[refI] < w) {
+! 	      refI += 2;
+! 	    }
+! 	  }
+! 	  break;
+! 	case twoDimVertR2:
+! 	  a0 = codingLine[codingI++] = refLine[refI] + 2;
+! 	  if (refLine[refI] < w) {
+! 	    ++refI;
+! 	    while (refLine[refI] <= a0 && refLine[refI] < w) {
+! 	      refI += 2;
+! 	    }
+! 	  }
+! 	  break;
+  	case twoDimVertR3:
+! 	  a0 = codingLine[codingI++] = refLine[refI] + 3;
+! 	  if (refLine[refI] < w) {
+! 	    ++refI;
+! 	    while (refLine[refI] <= a0 && refLine[refI] < w) {
+! 	      refI += 2;
+! 	    }
+! 	  }
+! 	  break;
+! 	case twoDimVertL1:
+! 	  a0 = codingLine[codingI++] = refLine[refI] - 1;
+! 	  if (refI > 0) {
+! 	    --refI;
+! 	  } else {
+! 	    ++refI;
+! 	  }
+! 	  while (refLine[refI] <= a0 && refLine[refI] < w) {
+! 	    refI += 2;
+! 	  }
+! 	  break;
+! 	case twoDimVertL2:
+! 	  a0 = codingLine[codingI++] = refLine[refI] - 2;
+! 	  if (refI > 0) {
+! 	    --refI;
+! 	  } else {
+! 	    ++refI;
+! 	  }
+! 	  while (refLine[refI] <= a0 && refLine[refI] < w) {
+! 	    refI += 2;
+! 	  }
+! 	  break;
+  	case twoDimVertL3:
+! 	  a0 = codingLine[codingI++] = refLine[refI] - 3;
+! 	  if (refI > 0) {
+! 	    --refI;
+! 	  } else {
+! 	    ++refI;
+! 	  }
+! 	  while (refLine[refI] <= a0 && refLine[refI] < w) {
+! 	    refI += 2;
+! 	  }
+! 	  break;
+  	default:
+  	  error(getPos(), "Illegal code in JBIG2 MMR bitmap data");
+  	  break;
+  	}
+!       } while (a0 < w);
+!       codingLine[codingI++] = w;
+  
+        // convert the run lengths to a bitmap line
+        i = 0;
+!       while (codingLine[i] < w) {
+  	for (x = codingLine[i]; x < codingLine[i+1]; ++x) {
+  	  bitmap->setPixel(x, y);
+  	}
+  	i += 2;
+        }
+      }
+--- 2690,2846 ----
+        for (i = 0; codingLine[i] < w; ++i) {
+  	refLine[i] = codingLine[i];
+        }
+!       refLine[i++] = w;
+!       refLine[i] = w;
+  
+        // decode a line
+!       codingLine[0] = 0;
+!       a0i = 0;
+!       b1i = 0;
+!       blackPixels = 0;
+!       // invariant:
+!       // refLine[b1i-1] <= codingLine[a0i] < refLine[b1i] < refLine[b1i+1] <= w
+!       // exception at left edge:
+!       //   codingLine[a0i = 0] = refLine[b1i = 0] = 0 is possible
+!       // exception at right edge:
+!       //   refLine[b1i] = refLine[b1i+1] = w is possible
+!       while (codingLine[a0i] < w) {
+  	code1 = mmrDecoder->get2DCode();
+  	switch (code1) {
+  	case twoDimPass:
+!           mmrAddPixels(refLine[b1i + 1], blackPixels, codingLine, &a0i, w);
+!           if (refLine[b1i + 1] < w) {
+!             b1i += 2;
+!           }
+!           break;
+  	case twoDimHoriz:
+!           code1 = code2 = 0;
+!           if (blackPixels) {
+!             do {
+!               code1 += code3 = mmrDecoder->getBlackCode();
+!             } while (code3 >= 64);
+!             do {
+!               code2 += code3 = mmrDecoder->getWhiteCode();
+!             } while (code3 >= 64);
+!           } else {
+!             do {
+!               code1 += code3 = mmrDecoder->getWhiteCode();
+!             } while (code3 >= 64);
+!             do {
+!               code2 += code3 = mmrDecoder->getBlackCode();
+!             } while (code3 >= 64);
+!           }
+!           mmrAddPixels(codingLine[a0i] + code1, blackPixels,
+! 		       codingLine, &a0i, w);
+!           if (codingLine[a0i] < w) {
+!             mmrAddPixels(codingLine[a0i] + code2, blackPixels ^ 1,
+! 			 codingLine, &a0i, w);
+!           }
+!           while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!             b1i += 2;
+!           }
+!           break;
+  	case twoDimVertR3:
+!           mmrAddPixels(refLine[b1i] + 3, blackPixels, codingLine, &a0i, w);
+!           blackPixels ^= 1;
+!           if (codingLine[a0i] < w) {
+!             ++b1i;
+!             while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!               b1i += 2;
+!             }
+!           }
+!           break;
+! 	case twoDimVertR2:
+!           mmrAddPixels(refLine[b1i] + 2, blackPixels, codingLine, &a0i, w);
+!           blackPixels ^= 1;
+!           if (codingLine[a0i] < w) {
+!             ++b1i;
+!             while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!               b1i += 2;
+!             }
+!           }
+!           break;
+! 	case twoDimVertR1:
+!           mmrAddPixels(refLine[b1i] + 1, blackPixels, codingLine, &a0i, w);
+!           blackPixels ^= 1;
+!           if (codingLine[a0i] < w) {
+!             ++b1i;
+!             while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!               b1i += 2;
+!             }
+!           }
+!           break;
+! 	case twoDimVert0:
+!           mmrAddPixels(refLine[b1i], blackPixels, codingLine, &a0i, w);
+!           blackPixels ^= 1;
+!           if (codingLine[a0i] < w) {
+!             ++b1i;
+!             while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!               b1i += 2;
+!             }
+!           }
+!           break;
+  	case twoDimVertL3:
+!           mmrAddPixelsNeg(refLine[b1i] - 3, blackPixels, codingLine, &a0i, w);
+!           blackPixels ^= 1;
+!           if (codingLine[a0i] < w) {
+!             if (b1i > 0) {
+!               --b1i;
+!             } else {
+!               ++b1i;
+!             }
+!             while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!               b1i += 2;
+!             }
+!           }
+!           break;
+! 	case twoDimVertL2:
+!           mmrAddPixelsNeg(refLine[b1i] - 2, blackPixels, codingLine, &a0i, w);
+!           blackPixels ^= 1;
+!           if (codingLine[a0i] < w) {
+!             if (b1i > 0) {
+!               --b1i;
+!             } else {
+!               ++b1i;
+!             }
+!             while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!               b1i += 2;
+!             }
+!           }
+!           break;
+! 	case twoDimVertL1:
+!           mmrAddPixelsNeg(refLine[b1i] - 1, blackPixels, codingLine, &a0i, w);
+!           blackPixels ^= 1;
+!           if (codingLine[a0i] < w) {
+!             if (b1i > 0) {
+!               --b1i;
+!             } else {
+!               ++b1i;
+!             }
+!             while (refLine[b1i] <= codingLine[a0i] && refLine[b1i] < w) {
+!               b1i += 2;
+!             }
+!           }
+!           break;
+! 	case EOF:
+!           mmrAddPixels(w, 0, codingLine, &a0i, w);
+!           break;
+  	default:
+  	  error(getPos(), "Illegal code in JBIG2 MMR bitmap data");
++           mmrAddPixels(w, 0, codingLine, &a0i, w);
+  	  break;
+  	}
+!       }
+  
+        // convert the run lengths to a bitmap line
+        i = 0;
+!       while (1) {
+  	for (x = codingLine[i]; x < codingLine[i+1]; ++x) {
+  	  bitmap->setPixel(x, y);
+  	}
++ 	if (codingLine[i+1] >= w || codingLine[i+2] >= w) {
++ 	  break;
++ 	}
+  	i += 2;
+        }
+      }
+***************
+*** 2706,2712 ****
+  	  ltp = !ltp;
+  	}
+  	if (ltp) {
+! 	  bitmap->duplicateRow(y, y-1);
+  	  continue;
+  	}
+        }
+--- 2888,2896 ----
+  	  ltp = !ltp;
+  	}
+  	if (ltp) {
+! 	  if (y > 0) {
+! 	    bitmap->duplicateRow(y, y-1);
+! 	  }
+  	  continue;
+  	}
+        }
+***************
+*** 2909,2916 ****
+      return;
+    }
+    if (nRefSegs == 1) {
+!     seg = findSegment(refSegs[0]);
+!     if (seg->getType() != jbig2SegBitmap) {
+        error(getPos(), "Bad bitmap reference in JBIG2 generic refinement segment");
+        return;
+      }
+--- 3093,3100 ----
+      return;
+    }
+    if (nRefSegs == 1) {
+!     if (!(seg = findSegment(refSegs[0])) ||
+! 	seg->getType() != jbig2SegBitmap) {
+        error(getPos(), "Bad bitmap reference in JBIG2 generic refinement segment");
+        return;
+      }
+***************
+*** 3004,3009 ****
+--- 3188,3197 ----
+  	tpgrCX2 = refBitmap->nextPixel(&tpgrCXPtr2);
+  	tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
+  	tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
++       } else {
++ 	tpgrCXPtr0.p = tpgrCXPtr1.p = tpgrCXPtr2.p = NULL; // make gcc happy
++ 	tpgrCXPtr0.shift = tpgrCXPtr1.shift = tpgrCXPtr2.shift = 0;
++ 	tpgrCXPtr0.x = tpgrCXPtr1.x = tpgrCXPtr2.x = 0;
+        }
+  
+        for (x = 0; x < w; ++x) {
+***************
+*** 3075,3080 ****
+--- 3263,3272 ----
+  	tpgrCX2 = refBitmap->nextPixel(&tpgrCXPtr2);
+  	tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
+  	tpgrCX2 = (tpgrCX2 << 1) | refBitmap->nextPixel(&tpgrCXPtr2);
++       } else {
++ 	tpgrCXPtr0.p = tpgrCXPtr1.p = tpgrCXPtr2.p = NULL; // make gcc happy
++ 	tpgrCXPtr0.shift = tpgrCXPtr1.shift = tpgrCXPtr2.shift = 0;
++ 	tpgrCXPtr0.x = tpgrCXPtr1.x = tpgrCXPtr2.x = 0;
+        }
+  
+        for (x = 0; x < w; ++x) {
+diff -r -c xpdf-3.02.orig/xpdf/JBIG2Stream.h xpdf-3.02/xpdf/JBIG2Stream.h
+*** xpdf-3.02.orig/xpdf/JBIG2Stream.h	Tue Feb 27 14:05:52 2007
+--- xpdf-3.02/xpdf/JBIG2Stream.h	Tue Mar 31 10:50:07 2009
+***************
+*** 78,83 ****
+--- 78,87 ----
+  			     Guint *refSegs, Guint nRefSegs);
+    void readGenericRegionSeg(Guint segNum, GBool imm,
+  			    GBool lossless, Guint length);
++   void mmrAddPixels(int a1, int blackPixels,
++ 		    int *codingLine, int *a0i, int w);
++   void mmrAddPixelsNeg(int a1, int blackPixels,
++ 		       int *codingLine, int *a0i, int w);
+    JBIG2Bitmap *readGenericBitmap(GBool mmr, int w, int h,
+  				 int templ, GBool tpgdOn,
+  				 GBool useSkip, JBIG2Bitmap *skip,


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.



More information about the devel mailing list