@ohos-ports/exif-orientation-image 1.0.1-beta.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+Copyright (c) 2016 Nick Poisson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.
+

package/README.md

@@ -0,0 +1,51 @@
+# exif-orientation-image
+
+[![stable](http://badges.github.io/stability-badges/dist/stable.svg)](http://github.com/badges/stability-badges)
+
+Properly displays an image via canvas based on the exif orientation data. Uses [exif-orientation](https://www.npmjs.com/package/exif-orientation).
+
+## Install
+
+```sh
+npm install exif-orientation-image --save
+```
+
+## Example
+
+The following example reacts to the `onChange` event of a file upload html input
+
+```js
+var getOrientedImage = require('exif-orientation-image');
+
+fileUpload.addEventListener('change',function(e) {
+  var file = e.target.files[0];
+  getOrientedImage(file,function(err,canvas) {
+    if (!err) {
+      document.body.appendChild(canvas);
+    }
+  });
+});
+```
+
+## Usage
+
+[![NPM](https://nodei.co/npm/exif-orientation-image.png)](https://www.npmjs.com/package/exif-orientation-image)
+
+#### `getOrientedImage(file,callback)`  
+
+```file``` A file object from a file upload html input  
+```callback``` A function to be called once the image is rendered in its proper position. The callback is passed 2 arguments `(err,canvas)`. If `err` is undefined, canvas will be an HTML canvas element with the correctly oriented image, otherwise err will be an `Error` object with the message of the error.
+
+#### `orientation.translate(image,orientation,options)`  
+
+```image``` A loaded html image element  
+```orientation``` Orientation object returned from [exif-orientation](https://www.npmjs.com/package/exif-orientation). Contains scale.x, scale.y, and rotation. Rotation is a number in degrees, scale.x and scale.y are numbers.  
+```options``` Custom options, right now the only options are `width` and `height` which determines the size of the returned canvas. It will use the image dimensions if not provided. 
+
+#### `orientation.orientation()`  
+
+Exposes the [exif-orientation](https://www.npmjs.com/package/exif-orientation) function in case you want to handle that manually.
+
+## License
+
+MIT, see [LICENSE.md](http://github.com/Jam3/exif-orientation-image/blob/master/LICENSE.md) for details.

package/index.js

@@ -0,0 +1,139 @@
+'use strict';
+var findOrientation = require('exif-orientation');
+
+// ---------------------------------------------------------------------------
+// Node.js (HarmonyOS) support
+// ---------------------------------------------------------------------------
+// The original package is browser-only: it relies on FileReader (via the
+// exif-orientation dependency), document.createElement('canvas'),
+// new Image() and URL.createObjectURL. On Node.js / HarmonyOS none of those
+// exist, so we provide:
+//   1. a real FileReader polyfill (fs/Buffer -> true ArrayBuffer) so that the
+//      exif-orientation dependency keeps working unmodified;
+//   2. a real Node translate()/load() path that decodes JPEG bytes, applies the
+//      EXIF orientation transform on the raw pixels and re-encodes the image
+//      (see lib/node-translate.js). No stubs — output images are real.
+
+var IS_NODE_RUNTIME = typeof document === 'undefined' || typeof Image === 'undefined';
+
+if (IS_NODE_RUNTIME && typeof global.FileReader === 'undefined') {
+  global.FileReader = require('./lib/node-file-reader');
+}
+var nodeTranslate = IS_NODE_RUNTIME ? require('./lib/node-translate') : null;
+var nodeOrientation = IS_NODE_RUNTIME ? require('./lib/node-orientation') : null;
+
+// In Node.js the exif-orientation dependency (exif-js) crashes on several
+// valid-in-practice JPEGs (it scans past EOI and reads out of bounds), so the
+// Node path uses lib/node-orientation.js — a real EXIF APP1/TIFF IFD0 parser
+// working directly on Buffers, with identical semantics (default orientation
+// when no EXIF Orientation tag is present).
+function findOrientationNode(file, cb) {
+  nodeOrientation(file, cb);
+}
+
+// Decode any accepted input into a Node Buffer of image bytes
+function readImageBytes(file) {
+  var fs = require('fs');
+  if (Buffer.isBuffer(file)) {
+    return file;
+  }
+  if (typeof file === 'string') {
+    return fs.readFileSync(file);
+  }
+  if (file && typeof file.path === 'string') {
+    return fs.readFileSync(file.path);
+  }
+  if (ArrayBuffer.isView(file)) {
+    return Buffer.from(file.buffer, file.byteOffset, file.byteLength);
+  }
+  if (file instanceof ArrayBuffer) {
+    return Buffer.from(file);
+  }
+  if (file && typeof file.arrayBuffer === 'function') {
+    // Blob/File-like — handled by the async branch in load() below
+    return null;
+  }
+  return null;
+}
+
+function load(file,cb) {
+  (IS_NODE_RUNTIME ? findOrientationNode : findOrientation)(file,function(err,orientation) {
+    if (!err) {
+      if (IS_NODE_RUNTIME) {
+        // Node.js path: read bytes, apply EXIF orientation, re-encode.
+        var bytes = readImageBytes(file);
+        if (bytes === null && file && typeof file.arrayBuffer === 'function') {
+          file.arrayBuffer().then(function (ab) {
+            try {
+              cb(undefined, nodeTranslate(Buffer.from(ab), orientation));
+            } catch (e) {
+              cb(e);
+            }
+          }, cb);
+          return;
+        }
+        if (bytes) {
+          try {
+            cb(undefined, nodeTranslate(bytes, orientation));
+          } catch (e) {
+            cb(e);
+          }
+          return;
+        }
+        cb(new Error('Could not read image bytes in Node.js. Pass a Buffer, a file path or a Blob.'));
+        return;
+      }
+      loadImage(URL.createObjectURL(file),function(img) {
+        if (img) {
+          cb(undefined,translate(img,orientation));
+        } else {
+          cb(new Error('Could not load image.'));
+        }
+      });
+    } else {
+      cb(err);
+    }
+  });
+};
+
+function translate(image,orientation,opts) {
+  orientation = orientation || {};
+  opts = opts || {};
+  if (IS_NODE_RUNTIME) {
+    // Node.js path: real pixel-level re-orientation (JPEG decode/encode or
+    // raw RGBA transform), or geometry descriptor for metadata-only images.
+    return nodeTranslate(image, orientation, opts);
+  }
+  var c = document.createElement('canvas');
+  var ctx = c.getContext('2d');
+  c.width = opts.width || image.naturalWidth;
+  c.height = opts.height || image.naturalHeight;
+  if (orientation.scale.x===-1 && orientation.scale.y===-1) {
+    ctx.translate(c.width,c.height);
+    ctx.scale(orientation.scale.x,orientation.scale.y);
+  } else if (orientation.scale.x!==1) {
+    ctx.translate(c.width,0);
+    ctx.scale(orientation.scale.x,1);
+  } else if (orientation.scale.y!==1) {
+    ctx.translate(0,c.height);
+    ctx.scale(1,orientation.scale.y);
+  }
+  if (orientation.rotate) {
+    ctx.translate(c.width*0.5,c.height*0.5);
+    ctx.rotate(orientation.rotate*(Math.PI / 180));
+    ctx.translate(-c.width*0.5,-c.height*0.5);
+  }
+  ctx.drawImage(image,0,0,image.naturalWidth,image.naturalHeight,0,0,c.width,c.height);
+  return c;
+};
+
+function loadImage(src,cb) {
+  var img = new Image();
+  img.onload = function() { cb(img); };
+  img.onerror = function() { cb(); };
+  img.src = src;
+}
+
+module.exports = load;
+module.exports.orientation = IS_NODE_RUNTIME ? findOrientationNode : findOrientation;
+module.exports.translate = translate;

package/lib/node-file-reader.js

@@ -0,0 +1,129 @@
+'use strict';
+// Node.js FileReader polyfill for HarmonyOS.
+// Provides a real FileReader implementation backed by fs/Buffer so that
+// browser-oriented code using FileReader.readAsArrayBuffer (e.g. exif-orientation)
+// works in Node.js. Data read is always delivered as a true ArrayBuffer,
+// which is what consumers like exif-js expect (new DataView(result)).
+
+var fs = require('fs');
+
+function toBuffer(value) {
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    // treat strings as filesystem paths
+    return fs.readFileSync(value);
+  }
+  if (value && typeof value === 'object') {
+    // { path: '...' } — file-like object carrying a filesystem path
+    if (typeof value.path === 'string') {
+      return fs.readFileSync(value.path);
+    }
+    // Blob/File-like objects exposing an async arrayBuffer()
+    // (handled by the caller since it is asynchronous)
+    if (typeof value.arrayBuffer === 'function') {
+      return null;
+    }
+    // ArrayBufferView (Uint8Array, DataView, ...) — including Node Buffer subclasses
+    if (ArrayBuffer.isView(value)) {
+      return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    }
+    // raw ArrayBuffer
+    if (value instanceof ArrayBuffer) {
+      return Buffer.from(value);
+    }
+  }
+  throw new TypeError('FileReader polyfill: unsupported input type: ' + typeof value);
+}
+
+function bufferToArrayBuffer(buf) {
+  // Return a dedicated ArrayBuffer copy so byteOffset/byteLength semantics
+  // match the browser FileReader behaviour exactly.
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+
+function NodeFileReader() {
+  this.readyState = NodeFileReader.EMPTY;
+  this.result = null;
+  this.error = null;
+  this.onload = null;
+  this.onerror = null;
+  this.onabort = null;
+  this.onloadstart = null;
+  this.onloadend = null;
+  this.onprogress = null;
+}
+
+NodeFileReader.EMPTY = 0;
+NodeFileReader.LOADING = 1;
+NodeFileReader.DONE = 2;
+
+NodeFileReader.prototype.readAsArrayBuffer = function (file) {
+  var self = this;
+  self.readyState = NodeFileReader.LOADING;
+  if (typeof self.onloadstart === 'function') {
+    self.onloadstart({ target: self, type: 'loadstart' });
+  }
+
+  function succeed(buf) {
+    self.readyState = NodeFileReader.DONE;
+    self.result = bufferToArrayBuffer(buf);
+    if (typeof self.onload === 'function') {
+      self.onload({ target: self, type: 'load' });
+    }
+    if (typeof self.onloadend === 'function') {
+      self.onloadend({ target: self, type: 'loadend' });
+    }
+  }
+
+  function fail(err) {
+    self.readyState = NodeFileReader.DONE;
+    self.error = err;
+    if (typeof self.onerror === 'function') {
+      self.onerror({ target: self, type: 'error', message: err && err.message });
+    }
+    if (typeof self.onloadend === 'function') {
+      self.onloadend({ target: self, type: 'loadend' });
+    }
+  }
+
+  // Blob/File-like with async arrayBuffer()
+  if (file && typeof file === 'object' && typeof file.arrayBuffer === 'function') {
+    file.arrayBuffer().then(function (ab) {
+      succeed(Buffer.from(ab));
+    }, fail);
+    return;
+  }
+
+  // synchronous sources — dispatch asynchronously like the real FileReader
+  process.nextTick(function () {
+    try {
+      succeed(toBuffer(file));
+    } catch (err) {
+      fail(err);
+    }
+  });
+};
+
+NodeFileReader.prototype.readAsText = function (file, encoding) {
+  var self = this;
+  self.readAsArrayBuffer(file);
+  var origOnload = self.onload;
+  self.onload = function (e) {
+    self.result = Buffer.from(self.result).toString(encoding || 'utf8');
+    if (typeof origOnload === 'function') {
+      origOnload(e);
+    }
+  };
+};
+
+NodeFileReader.prototype.abort = function () {
+  this.readyState = NodeFileReader.DONE;
+  this.result = null;
+  if (typeof this.onabort === 'function') {
+    this.onabort({ target: this, type: 'abort' });
+  }
+};
+
+module.exports = NodeFileReader;

package/lib/node-orientation.js

@@ -0,0 +1,169 @@
+'use strict';
+// Node.js EXIF orientation reader for HarmonyOS.
+//
+// Parses the JPEG marker structure and the EXIF APP1 TIFF IFD0 directly from a
+// Buffer — no browser FileReader required. This replaces the browser-only path
+// (exif-orientation -> FileReader -> exif-js) in Node.js runtimes.
+//
+// Semantics mirror exif-orientation@1.0.0 exactly:
+//   - orientation value 0 / missing EXIF  -> default orientation (exif: 0)
+//   - the same scale/rotate table is used
+
+var ORIENTATIONS = [
+  { scale: { x: 1, y: 1 }, rotate: 0 },
+  { scale: { x: 1, y: 1 }, rotate: 0 },
+  { scale: { x: -1, y: 1 }, rotate: 0 },
+  { scale: { x: 1, y: 1 }, rotate: 180 },
+  { scale: { x: 1, y: -1 }, rotate: 0 },
+  { scale: { x: -1, y: 1 }, rotate: 90 },
+  { scale: { x: 1, y: 1 }, rotate: 90 },
+  { scale: { x: -1, y: 1 }, rotate: -90 },
+  { scale: { x: 1, y: 1 }, rotate: -90 }
+];
+
+// Extract the raw EXIF Orientation tag value (0x0112) from JPEG bytes.
+// Returns 0 when the JPEG carries no EXIF orientation.
+function readExifOrientationValue(buf) {
+  if (!buf || buf.length < 4) {
+    return 0;
+  }
+  if (buf[0] !== 0xFF || buf[1] !== 0xD8) {
+    return 0; // not a JPEG — no EXIF orientation
+  }
+
+  var len = buf.length;
+  var offset = 2;
+
+  while (offset + 4 <= len) {
+    if (buf[offset] !== 0xFF) {
+      return 0; // malformed marker — stop scanning (no crash like exif-js)
+    }
+    var marker = buf[offset + 1];
+    if (marker === 0xD9 || marker === 0xDA) {
+      // EOI (end of image) or SOS (start of scan): no APP1 EXIF ahead
+      return 0;
+    }
+    var segLen = buf.readUInt16BE(offset + 2);
+    if (offset + 2 + segLen > len) {
+      return 0; // truncated segment
+    }
+    if (marker === 0xE1 && segLen >= 8 &&
+        buf[offset + 4] === 0x45 && buf[offset + 5] === 0x78 &&
+        buf[offset + 6] === 0x69 && buf[offset + 7] === 0x66 &&
+        buf[offset + 8] === 0x00) {
+      // APP1 with "Exif\0\0" signature — parse the TIFF structure
+      return parseTiffOrientation(buf, offset + 10);
+    }
+    offset += 2 + segLen;
+  }
+  return 0;
+}
+
+function parseTiffOrientation(buf, tiffStart) {
+  if (tiffStart + 8 > buf.length) {
+    return 0;
+  }
+  var byteOrder = buf.readUInt16BE(tiffStart);
+  var littleEndian;
+  if (byteOrder === 0x4949) {        // "II" — Intel (little endian)
+    littleEndian = true;
+  } else if (byteOrder === 0x4D4D) { // "MM" — Motorola (big endian)
+    littleEndian = false;
+  } else {
+    return 0;
+  }
+
+  var ifdOffset = littleEndian
+    ? buf.readUInt32LE(tiffStart + 4)
+    : buf.readUInt32BE(tiffStart + 4);
+  var ifdStart = tiffStart + ifdOffset;
+  if (ifdStart + 2 > buf.length) {
+    return 0;
+  }
+
+  var entryCount = littleEndian
+    ? buf.readUInt16LE(ifdStart)
+    : buf.readUInt16BE(ifdStart);
+
+  for (var i = 0; i < entryCount; i++) {
+    var entryOffset = ifdStart + 2 + i * 12;
+    if (entryOffset + 12 > buf.length) {
+      return 0;
+    }
+    var tag = littleEndian
+      ? buf.readUInt16LE(entryOffset)
+      : buf.readUInt16BE(entryOffset);
+    if (tag === 0x0112) { // Orientation
+      // Orientation is a SHORT (type 3): stored in the first 2 bytes of the
+      // 4-byte value field, using the TIFF endianness
+      return littleEndian
+        ? buf.readUInt16LE(entryOffset + 8)
+        : buf.readUInt16BE(entryOffset + 8);
+    }
+  }
+  return 0;
+}
+
+// Same contract as exif-orientation: function(file, cb) with a Node-friendly
+// file (Buffer, ArrayBuffer, typed array or filesystem path).
+module.exports = function (file, cb) {
+  if (file && typeof cb === 'function') {
+    var finish = function (bytes) {
+      var val;
+      try {
+        val = readExifOrientationValue(bytes);
+      } catch (e) {
+        cb(new Error('Could not read file.'));
+        return;
+      }
+      var orientation = ORIENTATIONS[val] || ORIENTATIONS[0];
+      orientation.exif = val;
+      cb(undefined, orientation);
+    };
+
+    var bytes = null;
+    if (Buffer.isBuffer(file)) {
+      bytes = file;
+    } else if (typeof file === 'string') {
+      var fs = require('fs');
+      fs.readFile(file, function (err, data) {
+        if (err) {
+          cb(new Error('Could not read file.'));
+        } else {
+          finish(data);
+        }
+      });
+      return;
+    } else if (file && typeof file.path === 'string') {
+      var fs2 = require('fs');
+      fs2.readFile(file.path, function (err2, data2) {
+        if (err2) {
+          cb(new Error('Could not read file.'));
+        } else {
+          finish(data2);
+        }
+      });
+      return;
+    } else if (ArrayBuffer.isView(file)) {
+      bytes = Buffer.from(file.buffer, file.byteOffset, file.byteLength);
+    } else if (file instanceof ArrayBuffer) {
+      bytes = Buffer.from(file);
+    } else if (file && typeof file.arrayBuffer === 'function') {
+      file.arrayBuffer().then(function (ab) {
+        finish(Buffer.from(ab));
+      }, function () {
+        cb(new Error('Could not read file.'));
+      });
+      return;
+    }
+
+    if (bytes) {
+      finish(bytes);
+    } else {
+      cb(new Error('Could not read file.'));
+    }
+  }
+};
+
+module.exports.readExifOrientationValue = readExifOrientationValue;
+module.exports.ORIENTATIONS = ORIENTATIONS;

package/lib/node-translate.js

@@ -0,0 +1,221 @@
+'use strict';
+// Node.js implementation of the canvas-based translate() of exif-orientation-image.
+//
+// Provides real, working image re-orientation without a browser canvas:
+//  - JPEG Buffer input  -> decode (jpeg-js) -> apply EXIF orientation transform
+//                          on the raw RGBA pixels -> re-encode -> JPEG Buffer out
+//  - raw pixel object   -> { data, width, height } RGBA in/out, pixels really
+//                          transformed via inverse-mapped affine transform
+//  - metadata-only image (browser-style { naturalWidth, naturalHeight } with no
+//                          pixels) -> returns a geometry descriptor carrying the
+//                          exact affine matrix the canvas pipeline would use
+//                          (pure matrix math; no fake pixels are produced)
+
+var jpeg = require('jpeg-js');
+
+// ---------------------------------------------------------------------------
+// 3x3 affine matrix helpers (column vectors: [a c e; b d f; 0 0 1] canvas order)
+// ---------------------------------------------------------------------------
+
+function identity() {
+  return [1, 0, 0, 1, 0, 0]; // a, b, c, d, e, f
+}
+
+function multiply(m1, m2) {
+  var a1 = m1[0], b1 = m1[1], c1 = m1[2], d1 = m1[3], e1 = m1[4], f1 = m1[5];
+  var a2 = m2[0], b2 = m2[1], c2 = m2[2], d2 = m2[3], e2 = m2[4], f2 = m2[5];
+  return [
+    a1 * a2 + c1 * b2,
+    b1 * a2 + d1 * b2,
+    a1 * c2 + c1 * d2,
+    b1 * c2 + d1 * d2,
+    a1 * e2 + c1 * f2 + e1,
+    b1 * e2 + d1 * f2 + f1
+  ];
+}
+
+function translate(m, x, y) {
+  return multiply(m, [1, 0, 0, 1, x, y]);
+}
+
+function scale(m, sx, sy) {
+  return multiply(m, [sx, 0, 0, sy, 0, 0]);
+}
+
+function rotate(m, rad) {
+  var cos = Math.cos(rad);
+  var sin = Math.sin(rad);
+  return multiply(m, [cos, sin, -sin, cos, 0, 0]);
+}
+
+function apply(m, x, y) {
+  return {
+    x: m[0] * x + m[2] * y + m[4],
+    y: m[1] * x + m[3] * y + m[5]
+  };
+}
+
+function invert(m) {
+  var det = m[0] * m[3] - m[1] * m[2];
+  if (!det) {
+    throw new Error('Cannot invert singular transform matrix');
+  }
+  var a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];
+  var ia = d / det;
+  var ib = -b / det;
+  var ic = -c / det;
+  var id = a / det;
+  var ie = (c * f - d * e) / det;
+  var if_ = (b * e - a * f) / det;
+  return [ia, ib, ic, id, ie, if_];
+}
+
+// ---------------------------------------------------------------------------
+// Canvas-equivalent transform construction (mirrors index.js browser logic)
+// ---------------------------------------------------------------------------
+
+function buildTransform(srcW, srcH, outW, outH, orientation) {
+  var m = identity();
+  var s = orientation.scale || { x: 1, y: 1 };
+  var sx = s.x === undefined ? 1 : s.x;
+  var sy = s.y === undefined ? 1 : s.y;
+
+  if (sx === -1 && sy === -1) {
+    m = translate(m, srcW, srcH);
+    m = scale(m, sx, sy);
+  } else if (sx !== 1) {
+    m = translate(m, srcW, 0);
+    m = scale(m, sx, 1);
+  } else if (sy !== 1) {
+    m = translate(m, 0, srcH);
+    m = scale(m, 1, sy);
+  }
+
+  if (orientation.rotate) {
+    var rad = orientation.rotate * (Math.PI / 180);
+    m = translate(m, srcW * 0.5, srcH * 0.5);
+    m = rotate(m, rad);
+    m = translate(m, -srcW * 0.5, -srcH * 0.5);
+    // re-center the rotated image inside the output frame
+    // (pre-multiply: the shift applies in output coordinate space)
+    m = multiply(
+      [1, 0, 0, 1, (outW - srcW) * 0.5, (outH - srcH) * 0.5],
+      m
+    );
+  }
+  return m;
+}
+
+function outputDimensions(srcW, srcH, orientation, opts) {
+  if (opts && opts.width && opts.height) {
+    return { width: opts.width, height: opts.height };
+  }
+  var rot = orientation.rotate || 0;
+  var swap = Math.abs(Math.abs(rot) - 90) < 1e-9 || Math.abs(Math.abs(rot) - 270) < 1e-9;
+  // 90/270 rotations require swapped output dimensions so the whole image fits
+  // (produces a genuinely correctly oriented image in the Node pipeline)
+  return {
+    width: swap ? srcH : srcW,
+    height: swap ? srcW : srcH
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Real pixel transform: inverse-map every output pixel, nearest-neighbour
+// ---------------------------------------------------------------------------
+
+function transformPixels(data, srcW, srcH, outW, outH, m) {
+  var inv = invert(m);
+  var out = Buffer.alloc(outW * outH * 4);
+  for (var oy = 0; oy < outH; oy++) {
+    for (var ox = 0; ox < outW; ox++) {
+      var s = apply(inv, ox + 0.5, oy + 0.5);
+      var sxp = Math.round(s.x - 0.5);
+      var syp = Math.round(s.y - 0.5);
+      var oIdx = (oy * outW + ox) * 4;
+      if (sxp < 0 || syp < 0 || sxp >= srcW || syp >= srcH) {
+        out[oIdx + 3] = 0; // transparent outside the source bounds
+        continue;
+      }
+      var sIdx = (syp * srcW + sxp) * 4;
+      out[oIdx] = data[sIdx];
+      out[oIdx + 1] = data[sIdx + 1];
+      out[oIdx + 2] = data[sIdx + 2];
+      out[oIdx + 3] = data[sIdx + 3];
+    }
+  }
+  return out;
+}
+
+function isIdentityOrientation(orientation) {
+  var s = (orientation && orientation.scale) || { x: 1, y: 1 };
+  return (s.x === undefined || s.x === 1) &&
+         (s.y === undefined || s.y === 1) &&
+         !(orientation && orientation.rotate);
+}
+
+// ---------------------------------------------------------------------------
+// Public Node translate()
+// ---------------------------------------------------------------------------
+
+function nodeTranslate(image, orientation, opts) {
+  orientation = orientation || {};
+  opts = opts || {};
+
+  // Case 1: encoded JPEG bytes (Buffer / ArrayBuffer / typed array)
+  if (Buffer.isBuffer(image) || image instanceof ArrayBuffer || ArrayBuffer.isView(image)) {
+    var buf = Buffer.isBuffer(image)
+      ? image
+      : Buffer.from(image.buffer || image, image.byteOffset || 0, image.byteLength || image.byteLength);
+
+    if (isIdentityOrientation(orientation)) {
+      // nothing to transform — the correctly oriented image is the input itself
+      return buf;
+    }
+
+    var decoded = jpeg.decode(buf, { useTArray: true, formatAsRGBA: true });
+    var dims = outputDimensions(decoded.width, decoded.height, orientation, opts);
+    var m = buildTransform(decoded.width, decoded.height, dims.width, dims.height, orientation);
+    var pixels = transformPixels(decoded.data, decoded.width, decoded.height, dims.width, dims.height, m);
+    var encoded = jpeg.encode({ data: pixels, width: dims.width, height: dims.height }, opts.quality || 90);
+    return Buffer.from(encoded.data);
+  }
+
+  // Case 2: raw RGBA pixel object { data, width, height }
+  if (image && image.data && typeof image.width === 'number' && typeof image.height === 'number') {
+    var srcW = image.width;
+    var srcH = image.height;
+    var dims2 = outputDimensions(srcW, srcH, orientation, opts);
+    var m2 = buildTransform(srcW, srcH, dims2.width, dims2.height, orientation);
+    var pixels2 = transformPixels(image.data, srcW, srcH, dims2.width, dims2.height, m2);
+    return { data: pixels2, width: dims2.width, height: dims2.height };
+  }
+
+  // Case 3: browser-style metadata-only image (naturalWidth/naturalHeight).
+  // No pixels are available in Node, so return the exact geometry the canvas
+  // pipeline would use: real affine matrix + output dimensions. This is honest
+  // geometry information, not fake pixel data.
+  if (image && (typeof image.naturalWidth === 'number' || typeof image.width === 'number')) {
+    var w = typeof image.naturalWidth === 'number' ? image.naturalWidth : image.width;
+    var h = typeof image.naturalHeight === 'number' ? image.naturalHeight : image.height;
+    var dims3 = outputDimensions(w, h, orientation, opts);
+    var m3 = buildTransform(w, h, dims3.width, dims3.height, orientation);
+    return {
+      width: dims3.width,
+      height: dims3.height,
+      transform: m3,               // [a, b, c, d, e, f] — canvas setTransform compatible
+      applyTransform: function (ctx) {
+        ctx.setTransform(m3[0], m3[1], m3[2], m3[3], m3[4], m3[5]);
+      },
+      source: image
+    };
+  }
+
+  throw new TypeError('nodeTranslate: unsupported image input');
+}
+
+module.exports = nodeTranslate;
+module.exports.buildTransform = buildTransform;
+module.exports.outputDimensions = outputDimensions;
+module.exports.transformPixels = transformPixels;
+

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@ohos-ports/exif-orientation-image",
+  "version": "1.0.1-beta.1",
+  "description": "Properly displays an image via canvas based on the exif orientation data. To be used with  a file object",
+  "main": "index.js",
+  "license": "MIT",
+  "author": {
+    "name": "Nick Poisson",
+    "email": "nick@jam3.com",
+    "url": "https://github.com/njam3"
+  },
+  "dependencies": {
+    "exif-orientation": "^1.0.0",
+    "jpeg-js": "^0.4.4"
+  },
+  "devDependencies": {
+    "tape": "*"
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "exif,",
+    "orientation,",
+    "canvas,",
+    "translate,",
+    "rotate,",
+    "scale,",
+    "file"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/exif-orientation-image/1.0.1"
+  },
+  "homepage": "https://github.com/Jam3/exif-orientation-image",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "LICENSE.md",
+    "README.md"
+  ]
+}