Fix conflicts

Author: atishdhu

src/core/base_stream.js

@@ -68,10 +68,6 @@ class BaseStream {
     return false;
   }
 
-  async getTransferableImage() {
-    return null;
-  }
-
   peekByte() {
     const peekedByte = this.getByte();
     if (peekedByte !== -1) {

src/core/image.js

@@ -752,10 +752,6 @@ class PDFImage {
         drawWidth === originalWidth &&
         drawHeight === originalHeight
       ) {
-        const image = await this.#getImage(originalWidth, originalHeight);
-        if (image) {
-          return image;
-        }
         const data = await this.getImageBytes(originalHeight * rowBytes, {});
         if (isOffscreenCanvasSupported) {
           if (mustBeResized) {
@@ -814,10 +810,6 @@ class PDFImage {
           }
 
           if (isHandled) {
-            const image = await this.#getImage(drawWidth, drawHeight);
-            if (image) {
-              return image;
-            }
             const rgba = await this.getImageBytes(imageLength, {
               drawWidth,
               drawHeight,
@@ -1021,20 +1013,6 @@ class PDFImage {
     };
   }
 
-  async #getImage(width, height) {
-    const bitmap = await this.image.getTransferableImage();
-    if (!bitmap) {
-      return null;
-    }
-    return {
-      data: null,
-      width,
-      height,
-      bitmap,
-      interpolate: this.interpolate,
-    };
-  }
-
   async getImageBytes(
     length,
     {

src/core/jpeg_stream.js

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 
-import { shadow, warn } from "../shared/util.js";
 import { DecodeStream } from "./decode_stream.js";
 import { Dict } from "./primitives.js";
 import { JpegImage } from "./jpg.js";
+import { shadow } from "../shared/util.js";
 
 /**
  * For JPEG's we use a library to decode these images and the stream behaves
@@ -32,18 +32,6 @@ class JpegStream extends DecodeStream {
     this.params = params;
   }
 
-  static get canUseImageDecoder() {
-    return shadow(
-      this,
-      "canUseImageDecoder",
-      // eslint-disable-next-line no-undef
-      typeof ImageDecoder === "undefined"
-        ? Promise.resolve(false)
-        : // eslint-disable-next-line no-undef
-          ImageDecoder.isTypeSupported("image/jpeg")
-    );
-  }
-
   get bytes() {
     // If `this.maybeLength` is null, we'll get the entire stream.
     return shadow(this, "bytes", this.stream.getBytes(this.maybeLength));
@@ -58,7 +46,22 @@ class JpegStream extends DecodeStream {
     this.decodeImage();
   }
 
-  get jpegOptions() {
+  decodeImage(bytes) {
+    if (this.eof) {
+      return this.buffer;
+    }
+    bytes ||= this.bytes;
+
+    // Some images may contain 'junk' before the SOI (start-of-image) marker.
+    // Note: this seems to mainly affect inline images.
+    for (let i = 0, ii = bytes.length - 1; i < ii; i++) {
+      if (bytes[i] === 0xff && bytes[i + 1] === 0xd8) {
+        if (i > 0) {
+          bytes = bytes.subarray(i);
+        }
+        break;
+      }
+    }
     const jpegOptions = {
       decodeTransform: undefined,
       colorTransform: undefined,
@@ -90,34 +93,8 @@ class JpegStream extends DecodeStream {
         jpegOptions.colorTransform = colorTransform;
       }
     }
-    return shadow(this, "jpegOptions", jpegOptions);
-  }
-
-  #skipUselessBytes(data) {
-    // Some images may contain 'junk' before the SOI (start-of-image) marker.
-    // Note: this seems to mainly affect inline images.
-    for (let i = 0, ii = data.length - 1; i < ii; i++) {
-      if (data[i] === 0xff && data[i + 1] === 0xd8) {
-        if (i > 0) {
-          data = data.subarray(i);
-        }
-        break;
-      }
-    }
-    return data;
-  }
-
-  decodeImage(bytes) {
-    if (this.eof) {
-      return this.buffer;
-    }
-    bytes = this.#skipUselessBytes(bytes || this.bytes);
 
-    // TODO: if an image has a mask we need to combine the data.
-    // So ideally get a VideoFrame from getTransferableImage and then use
-    // copyTo.
-
-    const jpegImage = new JpegImage(this.jpegOptions);
+    const jpegImage = new JpegImage(jpegOptions);
     jpegImage.parse(bytes);
     const data = jpegImage.getData({
       width: this.drawWidth,
@@ -136,48 +113,6 @@ class JpegStream extends DecodeStream {
   get canAsyncDecodeImageFromBuffer() {
     return this.stream.isAsync;
   }
-
-  async getTransferableImage() {
-    if (!(await JpegStream.canUseImageDecoder)) {
-      return null;
-    }
-    const jpegOptions = this.jpegOptions;
-    if (jpegOptions.decodeTransform) {
-      // TODO: We could decode the image thanks to ImageDecoder and then
-      // get the pixels with copyTo and apply the decodeTransform.
-      return null;
-    }
-    let decoder;
-    try {
-      // TODO: If the stream is Flate & DCT we could try to just pipe the
-      // the DecompressionStream into the ImageDecoder: it'll avoid the
-      // intermediate ArrayBuffer.
-      const bytes =
-        (this.canAsyncDecodeImageFromBuffer &&
-          (await this.stream.asyncGetBytes())) ||
-        this.bytes;
-      if (!bytes) {
-        return null;
-      }
-      const data = this.#skipUselessBytes(bytes);
-      if (!JpegImage.canUseImageDecoder(data, jpegOptions.colorTransform)) {
-        return null;
-      }
-      // eslint-disable-next-line no-undef
-      decoder = new ImageDecoder({
-        data,
-        type: "image/jpeg",
-        preferAnimation: false,
-      });
-
-      return (await decoder.decode()).image;
-    } catch (reason) {
-      warn(`getTransferableImage - failed: "${reason}".`);
-      return null;
-    } finally {
-      decoder?.close();
-    }
-  }
 }
 
 export { JpegStream };