lightdrift-libraw 1.0.0-alpha.2 → 1.0.0-alpha.3

package/lib/index.js

@@ -691,11 +691,10 @@ class LibRaw {
     });
   }
 
-  // ============== JPEG CONVERSION (NEW FEATURE) ==============
+  // ============== MEMORY STREAM OPERATIONS (NEW FEATURE) ==============
 
   /**
-   * Convert RAW to JPEG with advanced options
-   * @param {string} outputPath - Output JPEG file path
+   * Create processed image as JPEG buffer in memory
    * @param {Object} options - JPEG conversion options
    * @param {number} [options.quality=85] - JPEG quality (1-100)
    * @param {number} [options.width] - Target width (maintains aspect ratio if height not specified)
@@ -708,9 +707,9 @@ class LibRaw {
    * @param {number} [options.overshootDeringing=false] - Overshoot deringing
    * @param {boolean} [options.optimizeCoding=true] - Optimize Huffman coding
    * @param {string} [options.colorSpace='srgb'] - Output color space ('srgb', 'rec2020', 'p3', 'cmyk')
-   * @returns {Promise<Object>} - Conversion result with metadata
+   * @returns {Promise<Object>} - JPEG buffer with metadata
    */
-  async convertToJPEG(outputPath, options = {}) {
+  async createJPEGBuffer(options = {}) {
     return new Promise(async (resolve, reject) => {
       try {
         // Set default options with performance-optimized values
@@ -846,29 +845,22 @@ class LibRaw {
             break;
         }
 
-        // Convert to JPEG and save
+        // Convert to JPEG and get buffer
         const jpegBuffer = await sharpInstance
           .jpeg(jpegOptions)
           .toBuffer({ resolveWithObject: true });
 
-        // Write to file
-        await sharp(jpegBuffer.data).toFile(outputPath);
-
         const endTime = process.hrtime.bigint();
         const processingTime = Number(endTime - startTime) / 1000000; // Convert to milliseconds
 
-        // Get output file stats
-        const fs = require("fs");
-        const stats = fs.statSync(outputPath);
-
         // Calculate compression ratio
         const originalSize = imageData.dataSize;
-        const compressedSize = stats.size;
+        const compressedSize = jpegBuffer.data.length;
         const compressionRatio = originalSize / compressedSize;
 
         const result = {
           success: true,
-          outputPath: outputPath,
+          buffer: jpegBuffer.data,
           metadata: {
             originalDimensions: {
               width: imageData.width,
@@ -897,6 +889,880 @@ class LibRaw {
         };
 
         resolve(result);
+      } catch (error) {
+        reject(new Error(`JPEG buffer creation failed: ${error.message}`));
+      }
+    });
+  }
+
+  /**
+   * Create processed image as PNG buffer in memory
+   * @param {Object} options - PNG conversion options
+   * @param {number} [options.width] - Target width
+   * @param {number} [options.height] - Target height
+   * @param {number} [options.compressionLevel=6] - PNG compression level (0-9)
+   * @param {boolean} [options.progressive=false] - Use progressive PNG
+   * @param {string} [options.colorSpace='srgb'] - Output color space
+   * @returns {Promise<Object>} - PNG buffer with metadata
+   */
+  async createPNGBuffer(options = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const startTime = process.hrtime.bigint();
+
+        // Smart processing: only process if not already processed
+        if (!this._isProcessed) {
+          await this.processImage();
+        }
+
+        // Create processed image in memory (uses cache if available)
+        const imageData = await this.createMemoryImage();
+
+        if (!imageData || !imageData.data) {
+          throw new Error("Failed to create memory image from RAW data");
+        }
+
+        // Set up Sharp configuration
+        const sharpConfig = {
+          raw: {
+            width: imageData.width,
+            height: imageData.height,
+            channels: imageData.colors,
+            premultiplied: false,
+          },
+          sequentialRead: true,
+          limitInputPixels: false,
+        };
+
+        if (imageData.bits === 16) {
+          sharpConfig.raw.depth = "ushort";
+        }
+
+        let sharpInstance = sharp(imageData.data, sharpConfig);
+
+        // Apply resizing if specified
+        if (options.width || options.height) {
+          const resizeOptions = {
+            withoutEnlargement: true,
+            kernel: sharp.kernel.lanczos3,
+            fit: "inside",
+            fastShrinkOnLoad: true,
+          };
+
+          if (options.width && options.height) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              options.height,
+              resizeOptions
+            );
+          } else if (options.width) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              null,
+              resizeOptions
+            );
+          } else {
+            sharpInstance = sharpInstance.resize(
+              null,
+              options.height,
+              resizeOptions
+            );
+          }
+        }
+
+        // Configure color space
+        switch ((options.colorSpace || "srgb").toLowerCase()) {
+          case "rec2020":
+            sharpInstance = sharpInstance.toColorspace("rec2020");
+            break;
+          case "p3":
+            sharpInstance = sharpInstance.toColorspace("p3");
+            break;
+          case "srgb":
+          default:
+            sharpInstance = sharpInstance.toColorspace("srgb");
+            break;
+        }
+
+        // Configure PNG options
+        const pngOptions = {
+          compressionLevel: Math.max(
+            0,
+            Math.min(9, options.compressionLevel || 6)
+          ),
+          progressive: options.progressive || false,
+          quality: 100, // PNG is lossless
+        };
+
+        // Convert to PNG and get buffer
+        const pngBuffer = await sharpInstance
+          .png(pngOptions)
+          .toBuffer({ resolveWithObject: true });
+
+        const endTime = process.hrtime.bigint();
+        const processingTime = Number(endTime - startTime) / 1000000;
+
+        const result = {
+          success: true,
+          buffer: pngBuffer.data,
+          metadata: {
+            originalDimensions: {
+              width: imageData.width,
+              height: imageData.height,
+            },
+            outputDimensions: {
+              width: pngBuffer.info.width,
+              height: pngBuffer.info.height,
+            },
+            fileSize: {
+              original: imageData.dataSize,
+              compressed: pngBuffer.data.length,
+              compressionRatio: (
+                imageData.dataSize / pngBuffer.data.length
+              ).toFixed(2),
+            },
+            processing: {
+              timeMs: processingTime.toFixed(2),
+              throughputMBps: (
+                imageData.dataSize /
+                1024 /
+                1024 /
+                (processingTime / 1000)
+              ).toFixed(2),
+            },
+            pngOptions: pngOptions,
+          },
+        };
+
+        resolve(result);
+      } catch (error) {
+        reject(new Error(`PNG buffer creation failed: ${error.message}`));
+      }
+    });
+  }
+
+  /**
+   * Create processed image as TIFF buffer in memory
+   * @param {Object} options - TIFF conversion options
+   * @param {number} [options.width] - Target width
+   * @param {number} [options.height] - Target height
+   * @param {string} [options.compression='lzw'] - TIFF compression ('none', 'lzw', 'jpeg', 'zip')
+   * @param {number} [options.quality=90] - JPEG quality when using JPEG compression
+   * @param {boolean} [options.pyramid=false] - Create pyramidal TIFF
+   * @param {string} [options.colorSpace='srgb'] - Output color space
+   * @returns {Promise<Object>} - TIFF buffer with metadata
+   */
+  async createTIFFBuffer(options = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const startTime = process.hrtime.bigint();
+
+        // Smart processing: only process if not already processed
+        if (!this._isProcessed) {
+          await this.processImage();
+        }
+
+        // Create processed image in memory (uses cache if available)
+        const imageData = await this.createMemoryImage();
+
+        if (!imageData || !imageData.data) {
+          throw new Error("Failed to create memory image from RAW data");
+        }
+
+        // Set up Sharp configuration
+        const sharpConfig = {
+          raw: {
+            width: imageData.width,
+            height: imageData.height,
+            channels: imageData.colors,
+            premultiplied: false,
+          },
+          sequentialRead: true,
+          limitInputPixels: false,
+        };
+
+        if (imageData.bits === 16) {
+          sharpConfig.raw.depth = "ushort";
+        }
+
+        let sharpInstance = sharp(imageData.data, sharpConfig);
+
+        // Apply resizing if specified
+        if (options.width || options.height) {
+          const resizeOptions = {
+            withoutEnlargement: true,
+            kernel: sharp.kernel.lanczos3,
+            fit: "inside",
+            fastShrinkOnLoad: true,
+          };
+
+          if (options.width && options.height) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              options.height,
+              resizeOptions
+            );
+          } else if (options.width) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              null,
+              resizeOptions
+            );
+          } else {
+            sharpInstance = sharpInstance.resize(
+              null,
+              options.height,
+              resizeOptions
+            );
+          }
+        }
+
+        // Configure color space
+        switch ((options.colorSpace || "srgb").toLowerCase()) {
+          case "rec2020":
+            sharpInstance = sharpInstance.toColorspace("rec2020");
+            break;
+          case "p3":
+            sharpInstance = sharpInstance.toColorspace("p3");
+            break;
+          case "srgb":
+          default:
+            sharpInstance = sharpInstance.toColorspace("srgb");
+            break;
+        }
+
+        // Configure TIFF options
+        const tiffOptions = {
+          compression: options.compression || "lzw",
+          pyramid: options.pyramid || false,
+          quality: options.quality || 90,
+        };
+
+        // Convert to TIFF and get buffer
+        const tiffBuffer = await sharpInstance
+          .tiff(tiffOptions)
+          .toBuffer({ resolveWithObject: true });
+
+        const endTime = process.hrtime.bigint();
+        const processingTime = Number(endTime - startTime) / 1000000;
+
+        const result = {
+          success: true,
+          buffer: tiffBuffer.data,
+          metadata: {
+            originalDimensions: {
+              width: imageData.width,
+              height: imageData.height,
+            },
+            outputDimensions: {
+              width: tiffBuffer.info.width,
+              height: tiffBuffer.info.height,
+            },
+            fileSize: {
+              original: imageData.dataSize,
+              compressed: tiffBuffer.data.length,
+              compressionRatio: (
+                imageData.dataSize / tiffBuffer.data.length
+              ).toFixed(2),
+            },
+            processing: {
+              timeMs: processingTime.toFixed(2),
+              throughputMBps: (
+                imageData.dataSize /
+                1024 /
+                1024 /
+                (processingTime / 1000)
+              ).toFixed(2),
+            },
+            tiffOptions: tiffOptions,
+          },
+        };
+
+        resolve(result);
+      } catch (error) {
+        reject(new Error(`TIFF buffer creation failed: ${error.message}`));
+      }
+    });
+  }
+
+  /**
+   * Create processed image as WebP buffer in memory
+   * @param {Object} options - WebP conversion options
+   * @param {number} [options.width] - Target width
+   * @param {number} [options.height] - Target height
+   * @param {number} [options.quality=80] - WebP quality (1-100)
+   * @param {boolean} [options.lossless=false] - Use lossless WebP
+   * @param {number} [options.effort=4] - Encoding effort (0-6)
+   * @param {string} [options.colorSpace='srgb'] - Output color space
+   * @returns {Promise<Object>} - WebP buffer with metadata
+   */
+  async createWebPBuffer(options = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const startTime = process.hrtime.bigint();
+
+        // Smart processing: only process if not already processed
+        if (!this._isProcessed) {
+          await this.processImage();
+        }
+
+        // Create processed image in memory (uses cache if available)
+        const imageData = await this.createMemoryImage();
+
+        if (!imageData || !imageData.data) {
+          throw new Error("Failed to create memory image from RAW data");
+        }
+
+        // Set up Sharp configuration
+        const sharpConfig = {
+          raw: {
+            width: imageData.width,
+            height: imageData.height,
+            channels: imageData.colors,
+            premultiplied: false,
+          },
+          sequentialRead: true,
+          limitInputPixels: false,
+        };
+
+        if (imageData.bits === 16) {
+          sharpConfig.raw.depth = "ushort";
+        }
+
+        let sharpInstance = sharp(imageData.data, sharpConfig);
+
+        // Apply resizing if specified
+        if (options.width || options.height) {
+          const resizeOptions = {
+            withoutEnlargement: true,
+            kernel: sharp.kernel.lanczos3,
+            fit: "inside",
+            fastShrinkOnLoad: true,
+          };
+
+          if (options.width && options.height) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              options.height,
+              resizeOptions
+            );
+          } else if (options.width) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              null,
+              resizeOptions
+            );
+          } else {
+            sharpInstance = sharpInstance.resize(
+              null,
+              options.height,
+              resizeOptions
+            );
+          }
+        }
+
+        // Configure color space
+        switch ((options.colorSpace || "srgb").toLowerCase()) {
+          case "rec2020":
+            sharpInstance = sharpInstance.toColorspace("rec2020");
+            break;
+          case "p3":
+            sharpInstance = sharpInstance.toColorspace("p3");
+            break;
+          case "srgb":
+          default:
+            sharpInstance = sharpInstance.toColorspace("srgb");
+            break;
+        }
+
+        // Configure WebP options
+        const webpOptions = {
+          quality: Math.max(1, Math.min(100, options.quality || 80)),
+          lossless: options.lossless || false,
+          effort: Math.max(0, Math.min(6, options.effort || 4)),
+        };
+
+        // Convert to WebP and get buffer
+        const webpBuffer = await sharpInstance
+          .webp(webpOptions)
+          .toBuffer({ resolveWithObject: true });
+
+        const endTime = process.hrtime.bigint();
+        const processingTime = Number(endTime - startTime) / 1000000;
+
+        const result = {
+          success: true,
+          buffer: webpBuffer.data,
+          metadata: {
+            originalDimensions: {
+              width: imageData.width,
+              height: imageData.height,
+            },
+            outputDimensions: {
+              width: webpBuffer.info.width,
+              height: webpBuffer.info.height,
+            },
+            fileSize: {
+              original: imageData.dataSize,
+              compressed: webpBuffer.data.length,
+              compressionRatio: (
+                imageData.dataSize / webpBuffer.data.length
+              ).toFixed(2),
+            },
+            processing: {
+              timeMs: processingTime.toFixed(2),
+              throughputMBps: (
+                imageData.dataSize /
+                1024 /
+                1024 /
+                (processingTime / 1000)
+              ).toFixed(2),
+            },
+            webpOptions: webpOptions,
+          },
+        };
+
+        resolve(result);
+      } catch (error) {
+        reject(new Error(`WebP buffer creation failed: ${error.message}`));
+      }
+    });
+  }
+
+  /**
+   * Create processed image as AVIF buffer in memory
+   * @param {Object} options - AVIF conversion options
+   * @param {number} [options.width] - Target width
+   * @param {number} [options.height] - Target height
+   * @param {number} [options.quality=50] - AVIF quality (1-100)
+   * @param {boolean} [options.lossless=false] - Use lossless AVIF
+   * @param {number} [options.effort=4] - Encoding effort (0-9)
+   * @param {string} [options.colorSpace='srgb'] - Output color space
+   * @returns {Promise<Object>} - AVIF buffer with metadata
+   */
+  async createAVIFBuffer(options = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const startTime = process.hrtime.bigint();
+
+        // Smart processing: only process if not already processed
+        if (!this._isProcessed) {
+          await this.processImage();
+        }
+
+        // Create processed image in memory (uses cache if available)
+        const imageData = await this.createMemoryImage();
+
+        if (!imageData || !imageData.data) {
+          throw new Error("Failed to create memory image from RAW data");
+        }
+
+        // Set up Sharp configuration
+        const sharpConfig = {
+          raw: {
+            width: imageData.width,
+            height: imageData.height,
+            channels: imageData.colors,
+            premultiplied: false,
+          },
+          sequentialRead: true,
+          limitInputPixels: false,
+        };
+
+        if (imageData.bits === 16) {
+          sharpConfig.raw.depth = "ushort";
+        }
+
+        let sharpInstance = sharp(imageData.data, sharpConfig);
+
+        // Apply resizing if specified
+        if (options.width || options.height) {
+          const resizeOptions = {
+            withoutEnlargement: true,
+            kernel: sharp.kernel.lanczos3,
+            fit: "inside",
+            fastShrinkOnLoad: true,
+          };
+
+          if (options.width && options.height) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              options.height,
+              resizeOptions
+            );
+          } else if (options.width) {
+            sharpInstance = sharpInstance.resize(
+              options.width,
+              null,
+              resizeOptions
+            );
+          } else {
+            sharpInstance = sharpInstance.resize(
+              null,
+              options.height,
+              resizeOptions
+            );
+          }
+        }
+
+        // Configure color space
+        switch ((options.colorSpace || "srgb").toLowerCase()) {
+          case "rec2020":
+            sharpInstance = sharpInstance.toColorspace("rec2020");
+            break;
+          case "p3":
+            sharpInstance = sharpInstance.toColorspace("p3");
+            break;
+          case "srgb":
+          default:
+            sharpInstance = sharpInstance.toColorspace("srgb");
+            break;
+        }
+
+        // Configure AVIF options
+        const avifOptions = {
+          quality: Math.max(1, Math.min(100, options.quality || 50)),
+          lossless: options.lossless || false,
+          effort: Math.max(0, Math.min(9, options.effort || 4)),
+        };
+
+        // Convert to AVIF and get buffer
+        const avifBuffer = await sharpInstance
+          .avif(avifOptions)
+          .toBuffer({ resolveWithObject: true });
+
+        const endTime = process.hrtime.bigint();
+        const processingTime = Number(endTime - startTime) / 1000000;
+
+        const result = {
+          success: true,
+          buffer: avifBuffer.data,
+          metadata: {
+            originalDimensions: {
+              width: imageData.width,
+              height: imageData.height,
+            },
+            outputDimensions: {
+              width: avifBuffer.info.width,
+              height: avifBuffer.info.height,
+            },
+            fileSize: {
+              original: imageData.dataSize,
+              compressed: avifBuffer.data.length,
+              compressionRatio: (
+                imageData.dataSize / avifBuffer.data.length
+              ).toFixed(2),
+            },
+            processing: {
+              timeMs: processingTime.toFixed(2),
+              throughputMBps: (
+                imageData.dataSize /
+                1024 /
+                1024 /
+                (processingTime / 1000)
+              ).toFixed(2),
+            },
+            avifOptions: avifOptions,
+          },
+        };
+
+        resolve(result);
+      } catch (error) {
+        reject(new Error(`AVIF buffer creation failed: ${error.message}`));
+      }
+    });
+  }
+
+  /**
+   * Create raw PPM buffer from processed image data
+   * @returns {Promise<Object>} - PPM buffer with metadata
+   */
+  async createPPMBuffer() {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const startTime = process.hrtime.bigint();
+
+        // Smart processing: only process if not already processed
+        if (!this._isProcessed) {
+          await this.processImage();
+        }
+
+        // Create processed image in memory (uses cache if available)
+        const imageData = await this.createMemoryImage();
+
+        if (!imageData || !imageData.data) {
+          throw new Error("Failed to create memory image from RAW data");
+        }
+
+        // Create PPM header
+        const header = `P6\n${imageData.width} ${imageData.height}\n255\n`;
+        const headerBuffer = Buffer.from(header, "ascii");
+
+        // Convert image data to 8-bit RGB if needed
+        let rgbData;
+        if (imageData.bits === 16) {
+          // Convert 16-bit to 8-bit
+          const pixels = imageData.width * imageData.height;
+          const channels = imageData.colors;
+          rgbData = Buffer.alloc(pixels * 3); // PPM is always RGB
+
+          for (let i = 0; i < pixels; i++) {
+            const srcOffset = i * channels * 2; // 16-bit data
+            const dstOffset = i * 3;
+
+            // Read 16-bit values and convert to 8-bit
+            rgbData[dstOffset] = Math.min(
+              255,
+              Math.floor((imageData.data.readUInt16LE(srcOffset) / 65535) * 255)
+            ); // R
+            rgbData[dstOffset + 1] = Math.min(
+              255,
+              Math.floor(
+                (imageData.data.readUInt16LE(srcOffset + 2) / 65535) * 255
+              )
+            ); // G
+            rgbData[dstOffset + 2] = Math.min(
+              255,
+              Math.floor(
+                (imageData.data.readUInt16LE(srcOffset + 4) / 65535) * 255
+              )
+            ); // B
+          }
+        } else {
+          // Already 8-bit, just copy RGB channels
+          const pixels = imageData.width * imageData.height;
+          const channels = imageData.colors;
+          rgbData = Buffer.alloc(pixels * 3);
+
+          for (let i = 0; i < pixels; i++) {
+            const srcOffset = i * channels;
+            const dstOffset = i * 3;
+
+            rgbData[dstOffset] = imageData.data[srcOffset]; // R
+            rgbData[dstOffset + 1] = imageData.data[srcOffset + 1]; // G
+            rgbData[dstOffset + 2] = imageData.data[srcOffset + 2]; // B
+          }
+        }
+
+        // Combine header and data
+        const ppmBuffer = Buffer.concat([headerBuffer, rgbData]);
+
+        const endTime = process.hrtime.bigint();
+        const processingTime = Number(endTime - startTime) / 1000000;
+
+        const result = {
+          success: true,
+          buffer: ppmBuffer,
+          metadata: {
+            format: "PPM",
+            dimensions: {
+              width: imageData.width,
+              height: imageData.height,
+            },
+            fileSize: {
+              original: imageData.dataSize,
+              compressed: ppmBuffer.length,
+              compressionRatio: (imageData.dataSize / ppmBuffer.length).toFixed(
+                2
+              ),
+            },
+            processing: {
+              timeMs: processingTime.toFixed(2),
+              throughputMBps: (
+                imageData.dataSize /
+                1024 /
+                1024 /
+                (processingTime / 1000)
+              ).toFixed(2),
+            },
+          },
+        };
+
+        resolve(result);
+      } catch (error) {
+        reject(new Error(`PPM buffer creation failed: ${error.message}`));
+      }
+    });
+  }
+
+  /**
+   * Create thumbnail as JPEG buffer in memory
+   * @param {Object} options - JPEG options for thumbnail
+   * @param {number} [options.quality=85] - JPEG quality
+   * @param {number} [options.maxSize] - Maximum dimension size
+   * @returns {Promise<Object>} - Thumbnail JPEG buffer with metadata
+   */
+  async createThumbnailJPEGBuffer(options = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const startTime = process.hrtime.bigint();
+
+        // Unpack thumbnail if needed
+        await this.unpackThumbnail();
+
+        // Create thumbnail in memory
+        const thumbData = await this.createMemoryThumbnail();
+
+        if (!thumbData || !thumbData.data) {
+          throw new Error("Failed to create memory thumbnail");
+        }
+
+        let sharpInstance;
+
+        // Check if thumbnail is already JPEG
+        if (await this.isJPEGThumb()) {
+          // Thumbnail is already JPEG, return directly or reprocess if options specified
+          if (!options.quality && !options.maxSize) {
+            const result = {
+              success: true,
+              buffer: thumbData.data,
+              metadata: {
+                format: "JPEG",
+                dimensions: {
+                  width: thumbData.width,
+                  height: thumbData.height,
+                },
+                fileSize: {
+                  compressed: thumbData.data.length,
+                },
+                processing: {
+                  timeMs: "0.00",
+                  fromCache: true,
+                },
+              },
+            };
+            resolve(result);
+            return;
+          } else {
+            // Reprocess existing JPEG with new options
+            sharpInstance = sharp(thumbData.data);
+          }
+        } else {
+          // Convert RAW thumbnail data
+          const sharpConfig = {
+            raw: {
+              width: thumbData.width,
+              height: thumbData.height,
+              channels: thumbData.colors || 3,
+              premultiplied: false,
+            },
+          };
+
+          if (thumbData.bits === 16) {
+            sharpConfig.raw.depth = "ushort";
+          }
+
+          sharpInstance = sharp(thumbData.data, sharpConfig);
+        }
+
+        // Apply max size constraint if specified
+        if (options.maxSize) {
+          sharpInstance = sharpInstance.resize(
+            options.maxSize,
+            options.maxSize,
+            {
+              fit: "inside",
+              withoutEnlargement: true,
+            }
+          );
+        }
+
+        // Configure JPEG options
+        const jpegOptions = {
+          quality: Math.max(1, Math.min(100, options.quality || 85)),
+          progressive: false, // Thumbnails typically don't need progressive
+          mozjpeg: false, // Keep simple for speed
+        };
+
+        // Convert to JPEG buffer
+        const jpegBuffer = await sharpInstance
+          .jpeg(jpegOptions)
+          .toBuffer({ resolveWithObject: true });
+
+        const endTime = process.hrtime.bigint();
+        const processingTime = Number(endTime - startTime) / 1000000;
+
+        const result = {
+          success: true,
+          buffer: jpegBuffer.data,
+          metadata: {
+            format: "JPEG",
+            originalDimensions: {
+              width: thumbData.width,
+              height: thumbData.height,
+            },
+            outputDimensions: {
+              width: jpegBuffer.info.width,
+              height: jpegBuffer.info.height,
+            },
+            fileSize: {
+              original: thumbData.dataSize || thumbData.data.length,
+              compressed: jpegBuffer.data.length,
+              compressionRatio: (
+                (thumbData.dataSize || thumbData.data.length) /
+                jpegBuffer.data.length
+              ).toFixed(2),
+            },
+            processing: {
+              timeMs: processingTime.toFixed(2),
+            },
+            jpegOptions: jpegOptions,
+          },
+        };
+
+        resolve(result);
+      } catch (error) {
+        reject(
+          new Error(`Thumbnail JPEG buffer creation failed: ${error.message}`)
+        );
+      }
+    });
+  }
+
+  // ============== JPEG CONVERSION (NEW FEATURE) ==============
+
+  /**
+   * Convert RAW to JPEG with advanced options
+   * @param {string} outputPath - Output JPEG file path
+   * @param {Object} options - JPEG conversion options
+   * @param {number} [options.quality=85] - JPEG quality (1-100)
+   * @param {number} [options.width] - Target width (maintains aspect ratio if height not specified)
+   * @param {number} [options.height] - Target height (maintains aspect ratio if width not specified)
+   * @param {boolean} [options.progressive=false] - Use progressive JPEG
+   * @param {boolean} [options.mozjpeg=true] - Use mozjpeg encoder for better compression
+   * @param {number} [options.chromaSubsampling='4:2:0'] - Chroma subsampling ('4:4:4', '4:2:2', '4:2:0')
+   * @param {boolean} [options.trellisQuantisation=false] - Enable trellis quantisation
+   * @param {boolean} [options.optimizeScans=false] - Optimize scan order
+   * @param {number} [options.overshootDeringing=false] - Overshoot deringing
+   * @param {boolean} [options.optimizeCoding=true] - Optimize Huffman coding
+   * @param {string} [options.colorSpace='srgb'] - Output color space ('srgb', 'rec2020', 'p3', 'cmyk')
+   * @returns {Promise<Object>} - Conversion result with metadata
+   */
+  async convertToJPEG(outputPath, options = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        // Create JPEG buffer first
+        const result = await this.createJPEGBuffer(options);
+
+        // Write buffer to file
+        const fs = require("fs");
+        fs.writeFileSync(outputPath, result.buffer);
+
+        // Get output file stats
+        const stats = fs.statSync(outputPath);
+
+        // Return result in the same format as before
+        resolve({
+          success: true,
+          outputPath: outputPath,
+          metadata: {
+            ...result.metadata,
+            fileSize: {
+              ...result.metadata.fileSize,
+              compressed: stats.size,
+            },
+          },
+        });
       } catch (error) {
         reject(new Error(`JPEG conversion failed: ${error.message}`));
       }