Fix the interface of JpegStream/JpxStream/Jbig2Stream to agree with the other DecodeStreams

The interface of all of the "image" streams look kind of weird, and I'm actually a bit surprised that there hasn't been any errors because of it.
For example: None of them actually implement `readBlock` methods, and it seems more luck that anything else that we're not calling `getBytes()` (without providing a length) for those streams, since that would trigger a code-path in `getBytes` that assumes `readBlock` to exist.

To address this long-standing issue, the `ensureBuffer` methods are thus renamed to `readBlock`. Furthermore, the new `ensureBuffer` methods are now no-ops.
Finally, this patch also replaces `var` with `let` in a number of places.

src/core/jbig2_stream.js

@@ -22,7 +22,7 @@ import { shadow } from '../shared/util';
  * For JBIG2's we use a library to decode these images and
  * the stream behaves like all the other DecodeStreams.
  */
-var Jbig2Stream = (function Jbig2StreamClosure() {
+let Jbig2Stream = (function Jbig2StreamClosure() {
   function Jbig2Stream(stream, maybeLength, dict, params) {
     this.stream = stream;
     this.maybeLength = maybeLength;
@@ -36,36 +36,39 @@ var Jbig2Stream = (function Jbig2StreamClosure() {
 
   Object.defineProperty(Jbig2Stream.prototype, 'bytes', {
     get() {
-      // If this.maybeLength is null, we'll get the entire stream.
+      // If `this.maybeLength` is null, we'll get the entire stream.
       return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));
     },
     configurable: true,
   });
 
-  Jbig2Stream.prototype.ensureBuffer = function(req) {
+  Jbig2Stream.prototype.ensureBuffer = function(requested) {
-    if (this.bufferLength) {
+    // No-op, since `this.readBlock` will always parse the entire image and
+    // directly insert all of its data into `this.buffer`.
+  };
+
+  Jbig2Stream.prototype.readBlock = function() {
+    if (this.eof) {
       return;
     }
+    let jbig2Image = new Jbig2Image();
 
-    var jbig2Image = new Jbig2Image();
+    let chunks = [];
-
-    var chunks = [];
     if (isDict(this.params)) {
-      var globalsStream = this.params.get('JBIG2Globals');
+      let globalsStream = this.params.get('JBIG2Globals');
       if (isStream(globalsStream)) {
-        var globals = globalsStream.getBytes();
+        let globals = globalsStream.getBytes();
         chunks.push({ data: globals, start: 0, end: globals.length, });
       }
     }
     chunks.push({ data: this.bytes, start: 0, end: this.bytes.length, });
-    var data = jbig2Image.parseChunks(chunks);
+    let data = jbig2Image.parseChunks(chunks);
-    var dataLength = data.length;
+    let dataLength = data.length;
 
     // JBIG2 had black as 1 and white as 0, inverting the colors
-    for (var i = 0; i < dataLength; i++) {
+    for (let i = 0; i < dataLength; i++) {
       data[i] ^= 0xFF;
     }
-
     this.buffer = data;
     this.bufferLength = dataLength;
     this.eof = true;

src/core/jpeg_stream.js

@@ -21,15 +21,15 @@ import { JpegImage } from './jpg';
 /**
  * Depending on the type of JPEG a JpegStream is handled in different ways. For
  * JPEG's that are supported natively such as DeviceGray and DeviceRGB the image
- * data is stored and then loaded by the browser.  For unsupported JPEG's we use
+ * data is stored and then loaded by the browser. For unsupported JPEG's we use
  * a library to decode these images and the stream behaves like all the other
  * DecodeStreams.
  */
-var JpegStream = (function JpegStreamClosure() {
+let JpegStream = (function JpegStreamClosure() {
   function JpegStream(stream, maybeLength, dict, params) {
     // Some images may contain 'junk' before the SOI (start-of-image) marker.
     // Note: this seems to mainly affect inline images.
-    var ch;
+    let ch;
     while ((ch = stream.getByte()) !== -1) {
       if (ch === 0xFF) { // Find the first byte of the SOI marker (0xFFD8).
         stream.skip(-1); // Reset the stream position to the SOI.
@@ -48,27 +48,32 @@ var JpegStream = (function JpegStreamClosure() {
 
   Object.defineProperty(JpegStream.prototype, 'bytes', {
     get: function JpegStream_bytes() {
-      // If this.maybeLength is null, we'll get the entire stream.
+      // If `this.maybeLength` is null, we'll get the entire stream.
       return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));
     },
     configurable: true,
   });
 
-  JpegStream.prototype.ensureBuffer = function JpegStream_ensureBuffer(req) {
+  JpegStream.prototype.ensureBuffer = function(requested) {
-    if (this.bufferLength) {
+    // No-op, since `this.readBlock` will always parse the entire image and
+    // directly insert all of its data into `this.buffer`.
+  };
+
+  JpegStream.prototype.readBlock = function() {
+    if (this.eof) {
       return;
     }
-    var jpegImage = new JpegImage();
+    let jpegImage = new JpegImage();
 
     // Checking if values need to be transformed before conversion.
-    var decodeArr = this.dict.getArray('Decode', 'D');
+    let decodeArr = this.dict.getArray('Decode', 'D');
     if (this.forceRGB && Array.isArray(decodeArr)) {
-      var bitsPerComponent = this.dict.get('BitsPerComponent') || 8;
+      let bitsPerComponent = this.dict.get('BitsPerComponent') || 8;
-      var decodeArrLength = decodeArr.length;
+      let decodeArrLength = decodeArr.length;
-      var transform = new Int32Array(decodeArrLength);
+      let transform = new Int32Array(decodeArrLength);
-      var transformNeeded = false;
+      let transformNeeded = false;
-      var maxValue = (1 << bitsPerComponent) - 1;
+      let maxValue = (1 << bitsPerComponent) - 1;
-      for (var i = 0; i < decodeArrLength; i += 2) {
+      for (let i = 0; i < decodeArrLength; i += 2) {
         transform[i] = ((decodeArr[i + 1] - decodeArr[i]) * 256) | 0;
         transform[i + 1] = (decodeArr[i] * maxValue) | 0;
         if (transform[i] !== 256 || transform[i + 1] !== 0) {
@@ -81,26 +86,26 @@ var JpegStream = (function JpegStreamClosure() {
     }
     // Fetching the 'ColorTransform' entry, if it exists.
     if (isDict(this.params)) {
-      var colorTransform = this.params.get('ColorTransform');
+      let colorTransform = this.params.get('ColorTransform');
       if (Number.isInteger(colorTransform)) {
         jpegImage.colorTransform = colorTransform;
       }
     }
 
     jpegImage.parse(this.bytes);
-    var data = jpegImage.getData(this.drawWidth, this.drawHeight,
+    let data = jpegImage.getData(this.drawWidth, this.drawHeight,
                                  this.forceRGB);
     this.buffer = data;
     this.bufferLength = data.length;
     this.eof = true;
   };
 
-  JpegStream.prototype.getBytes = function JpegStream_getBytes(length) {
+  JpegStream.prototype.getBytes = function(length) {
-    this.ensureBuffer();
+    this.readBlock();
     return this.buffer;
   };
 
-  JpegStream.prototype.getIR = function JpegStream_getIR(forceDataSchema) {
+  JpegStream.prototype.getIR = function(forceDataSchema = false) {
     return createObjectURL(this.bytes, 'image/jpeg', forceDataSchema);
   };
 

src/core/jpx_stream.js

@@ -21,7 +21,7 @@ import { shadow } from '../shared/util';
  * For JPEG 2000's we use a library to decode these images and
  * the stream behaves like all the other DecodeStreams.
  */
-var JpxStream = (function JpxStreamClosure() {
+let JpxStream = (function JpxStreamClosure() {
   function JpxStream(stream, maybeLength, dict, params) {
     this.stream = stream;
     this.maybeLength = maybeLength;
@@ -35,44 +35,48 @@ var JpxStream = (function JpxStreamClosure() {
 
   Object.defineProperty(JpxStream.prototype, 'bytes', {
     get: function JpxStream_bytes() {
-      // If this.maybeLength is null, we'll get the entire stream.
+      // If `this.maybeLength` is null, we'll get the entire stream.
       return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));
     },
     configurable: true,
   });
 
-  JpxStream.prototype.ensureBuffer = function JpxStream_ensureBuffer(req) {
+  JpxStream.prototype.ensureBuffer = function(requested) {
-    if (this.bufferLength) {
+    // No-op, since `this.readBlock` will always parse the entire image and
+    // directly insert all of its data into `this.buffer`.
+  };
+
+  JpxStream.prototype.readBlock = function() {
+    if (this.eof) {
       return;
     }
-
+    let jpxImage = new JpxImage();
-    var jpxImage = new JpxImage();
     jpxImage.parse(this.bytes);
 
-    var width = jpxImage.width;
+    let width = jpxImage.width;
-    var height = jpxImage.height;
+    let height = jpxImage.height;
-    var componentsCount = jpxImage.componentsCount;
+    let componentsCount = jpxImage.componentsCount;
-    var tileCount = jpxImage.tiles.length;
+    let tileCount = jpxImage.tiles.length;
     if (tileCount === 1) {
       this.buffer = jpxImage.tiles[0].items;
     } else {
-      var data = new Uint8ClampedArray(width * height * componentsCount);
+      let data = new Uint8ClampedArray(width * height * componentsCount);
 
-      for (var k = 0; k < tileCount; k++) {
+      for (let k = 0; k < tileCount; k++) {
-        var tileComponents = jpxImage.tiles[k];
+        let tileComponents = jpxImage.tiles[k];
-        var tileWidth = tileComponents.width;
+        let tileWidth = tileComponents.width;
-        var tileHeight = tileComponents.height;
+        let tileHeight = tileComponents.height;
-        var tileLeft = tileComponents.left;
+        let tileLeft = tileComponents.left;
-        var tileTop = tileComponents.top;
+        let tileTop = tileComponents.top;
 
-        var src = tileComponents.items;
+        let src = tileComponents.items;
-        var srcPosition = 0;
+        let srcPosition = 0;
-        var dataPosition = (width * tileTop + tileLeft) * componentsCount;
+        let dataPosition = (width * tileTop + tileLeft) * componentsCount;
-        var imgRowSize = width * componentsCount;
+        let imgRowSize = width * componentsCount;
-        var tileRowSize = tileWidth * componentsCount;
+        let tileRowSize = tileWidth * componentsCount;
 
-        for (var j = 0; j < tileHeight; j++) {
+        for (let j = 0; j < tileHeight; j++) {
-          var rowBytes = src.subarray(srcPosition, srcPosition + tileRowSize);
+          let rowBytes = src.subarray(srcPosition, srcPosition + tileRowSize);
           data.set(rowBytes, dataPosition);
           srcPosition += tileRowSize;
           dataPosition += imgRowSize;