@mapcatch/util 1.0.15-a → 2.0.0

package/src/photo-parser/exif/ifd1_tags.js

@@ -0,0 +1,22 @@
+export default {
+  0x0100: 'ImageWidth',
+  0x0101: 'ImageHeight',
+  0x0102: 'BitsPerSample',
+  0x0103: 'Compression',
+  0x0106: 'PhotometricInterpretation',
+  0x0111: 'StripOffsets',
+  0x0112: 'Orientation',
+  0x0115: 'SamplesPerPixel',
+  0x0116: 'RowsPerStrip',
+  0x0117: 'StripByteCounts',
+  0x011A: 'XResolution',
+  0x011B: 'YResolution',
+  0x011C: 'PlanarConfiguration',
+  0x0128: 'ResolutionUnit',
+  0x0201: 'JpegIFOffset',    // When image format is JPEG, this value show offset to JPEG data stored.(aka "ThumbnailOffset" or "JPEGInterchangeFormat")
+  0x0202: 'JpegIFByteCount', // When image format is JPEG, this value shows data size of JPEG image (aka "ThumbnailLength" or "JPEGInterchangeFormatLength")
+  0x0211: 'YCbCrCoefficients',
+  0x0212: 'YCbCrSubSampling',
+  0x0213: 'YCbCrPositioning',
+  0x0214: 'ReferenceBlackWhite'
+}

package/src/photo-parser/exif/index.js

@@ -0,0 +1,130 @@
+import {getData} from './parse_image'
+import {imageSize} from '../image-size'
+import util from './util'
+
+export const getPhotoMetadata = async (file) => {
+  let extent = getFileExtent(file)
+  let data = {}
+  if (extent === 'jpg' || extent === 'jpeg') {
+    try {
+      data = await _formatMetadata(file)
+    } catch(err) {
+      return await getImageSize(file)
+    }
+  } else {
+    data = await getImageSize(file)
+  }
+  data.filesize = getFileSize(file)
+  return data
+}
+
+async function _formatMetadata (file, index = 1) {
+  let buffer = await getFileBuffer(file, index)
+  return new Promise((resolve, reject) => {
+    getData(buffer, function (img, err) {
+      if (err) {
+        if (err.message === 'Offset is outside the bounds of the DataView' && index < 3) {// 如果前64kb没找到，则尝试搜索128k，最多搜索192k
+          return resolve(_formatMetadata(file, index + 1))
+        } else {
+          return reject(err)
+        }
+      }
+      let {exif, xmp} = getAllTags(img)
+      exif = JSON.parse(JSON.stringify(exif).replaceAll('\\u0000', '')) || {}
+      if (exif.PixelXDimension && exif.PixelYDimension && exif.PixelXDimension != 65535 && exif.PixelYDimension != 65535) {
+        resolve({
+          exif, xmp,
+          width: exif.PixelXDimension,
+          height: exif.PixelYDimension
+        })
+      } else {
+        getImageSize(file).then(size => {
+          resolve({
+            exif, xmp,
+            width: size.width,
+            height: size.height
+          })
+        })
+      }
+    })
+  })
+}
+
+async function getImageSize (file) {
+  try {
+    let buffer = await getFileBuffer(file)
+    let size = imageSize(buffer)
+    return {
+      width: size.width,
+      height: size.height
+    }
+  } catch (err) {
+    return {
+      width: 0,
+      height: 0
+    }
+  }  
+}
+
+function getAllTags (img) {
+  if (!util.imageHasData(img)) return {
+    exif: {},
+    xmp: {}
+  }
+  return {
+    exif: img.exifdata || {},
+    xmp: img.xmpdata || {}
+  }
+}
+
+function getFileExtent (file) {
+  if (typeof file === 'string') {
+    return file.split('.').pop().toLowerCase()
+  } else {
+    return file.name.split('.').pop().toLowerCase()
+  }
+}
+
+async function getFileBuffer (file, index) {
+  if ((typeof file) === 'string') {
+    const fs = require('fs')
+    if (!index) {
+      let buffer = fs.readFileSync(file)
+      return buffer.buffer
+    } else {
+      let fd = fs.openSync(file)
+      let buffer = Buffer.alloc(65536 * index)
+      await new Promise((resolve) => {
+        fs.read(fd, buffer, 0, buffer.length, 0, () => {
+          resolve()
+          fs.closeSync(fd)
+        })
+      })
+      return buffer.buffer
+    }
+  } else {
+    if (index) {
+      file = file.slice(0, 65536 * index)
+    }
+    return await new Promise((resolve, reject) => {
+      var fileReader = new FileReader()
+      fileReader.readAsArrayBuffer(file)
+      fileReader.onload = (e) => {
+        resolve(e.target.result)
+      }
+      fileReader.onerror = (error) => {
+        reject(error)
+      }
+    })
+    
+  }
+}
+
+function getFileSize(file) {
+  if (typeof file === 'string') {
+    let stat = fs.statSync(file)
+    data.filesize = stat.size
+  } else {
+    return file.size
+  }
+}

package/src/photo-parser/exif/parse_image.js

@@ -0,0 +1,290 @@
+import util from './util'
+import TiffTags from './tiff_tags'
+import ExifTags from './tags'
+import StringValues from './string_values'
+import GPSTags from './gps_tags'
+import { DOMParser } from '@xmldom/xmldom'
+
+export const getData = function (img, callback) {
+  if (!util.imageHasData(img)) {
+    getImageData(img, callback)
+  } else {
+    if (callback) {
+      callback(img)
+    }
+  }
+  return true
+}
+
+function getImageData (img, callback) {
+  try {
+    var data = findEXIFinJPEG(img)
+    img.exifdata = data.exif
+    img.xmpdata = data.xmp
+    if (callback) {
+      callback(img)
+    }
+  } catch (err) {
+    img.exifdata = {}
+    img.xmpdata = {}
+    callback(img, err)
+  }
+}
+
+function findEXIFinJPEG (file) {
+  var dataView = new DataView(file)
+  let exif, xmp
+
+  var offset = 2,
+    length = file.byteLength,
+    dom = new DOMParser(),
+    marker
+
+  while (offset < length) {
+    if (dataView.getUint8(offset) != 0xFF) {
+      break
+    }
+
+    marker = dataView.getUint8(offset + 1)
+
+    // we could implement handling for other markers here,
+    // but we're only looking for 0xFFE1 for EXIF data
+
+    if (marker == 225) {
+      if (util.getStringFromDB(dataView, offset + 4, 4) == 'http') { // 这个是‘xmp’
+        var startOffset = offset + 3
+        var sectionLength = dataView.getUint16(offset + 2) - 1
+        var xmpString = util.getStringFromDB(dataView, startOffset, sectionLength)
+        var xmpEndIndex = xmpString.indexOf('xmpmeta>') + 8
+        xmpString = xmpString.substring(xmpString.indexOf('<x:xmpmeta'), xmpEndIndex)
+  
+        var indexOfXmp = xmpString.indexOf('x:xmpmeta') + 10
+        //Many custom written programs embed xmp/xml without any namespace. Following are some of them.
+        //Without these namespaces, XML is thought to be invalid by parsers
+        xmpString = xmpString.slice(0, indexOfXmp)
+          + 'xmlns:Iptc4xmpCore="http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/" '
+          + 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
+          + 'xmlns:tiff="http://ns.adobe.com/tiff/1.0/" '
+          + 'xmlns:plus="http://schemas.android.com/apk/lib/com.google.android.gms.plus" '
+          + 'xmlns:ext="http://www.gettyimages.com/xsltExtension/1.0" '
+          + 'xmlns:exif="http://ns.adobe.com/exif/1.0/" '
+          + 'xmlns:stEvt="http://ns.adobe.com/xap/1.0/sType/ResourceEvent#" '
+          + 'xmlns:stRef="http://ns.adobe.com/xap/1.0/sType/ResourceRef#" '
+          + 'xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" '
+          + 'xmlns:xapGImg="http://ns.adobe.com/xap/1.0/g/img/" '
+          + 'xmlns:Iptc4xmpExt="http://iptc.org/std/Iptc4xmpExt/2008-02-29/" '
+          + xmpString.slice(indexOfXmp)
+        
+        var domDocument = dom.parseFromString(xmpString, 'text/xml')
+        xmp = util.xml2Object(domDocument)
+      } else { // 这个是exif
+        exif = readEXIFData(dataView, offset + 4, dataView.getUint16(offset + 2) - 2)
+      }
+    }
+    if (xmp && exif) {
+      break
+    }
+    offset += 2 + dataView.getUint16(offset + 2)
+  }
+  return {exif: exif || {}, xmp: xmp || {}}
+
+}
+
+
+function readEXIFData (file, start) {
+  if (util.getStringFromDB(file, start, 4) != 'Exif') {
+    return false
+  }
+
+  var bigEnd,
+    tags, tag,
+    exifData, gpsData,
+    tiffOffset = start + 6
+
+  // test for TIFF validity and endianness
+  if (file.getUint16(tiffOffset) == 0x4949) {
+    bigEnd = false
+  } else if (file.getUint16(tiffOffset) == 0x4D4D) {
+    bigEnd = true
+  } else {
+    return false
+  }
+
+  if (file.getUint16(tiffOffset + 2, !bigEnd) != 0x002A) {
+    return false
+  }
+
+  var firstIFDOffset = file.getUint32(tiffOffset + 4, !bigEnd)
+
+  if (firstIFDOffset < 0x00000008) {
+    return false
+  }
+
+  tags = readTags(file, tiffOffset, tiffOffset + firstIFDOffset, TiffTags, bigEnd)
+
+  if (tags.ExifIFDPointer) {
+    exifData = readTags(file, tiffOffset, tiffOffset + tags.ExifIFDPointer, ExifTags, bigEnd)
+    for (tag in exifData) {
+      switch (tag) {
+        case 'LightSource':
+        case 'Flash':
+        case 'MeteringMode':
+        case 'ExposureProgram':
+        case 'SensingMethod':
+        case 'SceneCaptureType':
+        case 'SceneType':
+        case 'CustomRendered':
+        case 'WhiteBalance':
+        case 'GainControl':
+        case 'Contrast':
+        case 'Saturation':
+        case 'Sharpness':
+        case 'SubjectDistanceRange':
+        case 'FileSource':
+          exifData[tag] = StringValues[tag][exifData[tag]]
+          break
+
+        case 'ExifVersion':
+        case 'FlashpixVersion':
+          exifData[tag] = String.fromCharCode(exifData[tag][0], exifData[tag][1], exifData[tag][2], exifData[tag][3])
+          break
+
+        case 'ComponentsConfiguration':
+          exifData[tag] =
+            StringValues.Components[exifData[tag][0]] +
+            StringValues.Components[exifData[tag][1]] +
+            StringValues.Components[exifData[tag][2]] +
+            StringValues.Components[exifData[tag][3]]
+          break
+      }
+      tags[tag] = exifData[tag]
+    }
+  }
+
+  if (tags.GPSInfoIFDPointer) {
+    gpsData = readTags(file, tiffOffset, tiffOffset + tags.GPSInfoIFDPointer, GPSTags, bigEnd)
+    for (tag in gpsData) {
+      switch (tag) {
+        case 'GPSVersionID':
+          gpsData[tag] = gpsData[tag][0] +
+            '.' + gpsData[tag][1] +
+            '.' + gpsData[tag][2] +
+            '.' + gpsData[tag][3]
+          break
+      }
+      tags[tag] = gpsData[tag]
+    }
+  }
+
+  // extract thumbnail
+  //tags['thumbnail'] = readThumbnailImage(file, tiffOffset, firstIFDOffset, bigEnd);
+
+  return tags
+}
+
+function readTags (file, tiffStart, dirStart, strings, bigEnd) {
+  var entries = file.getUint16(dirStart, !bigEnd),
+    tags = {},
+    entryOffset, tag,
+    i
+
+  for (i = 0; i < entries; i++) {
+    entryOffset = dirStart + i * 12 + 2
+    tag = strings[file.getUint16(entryOffset, !bigEnd)]
+    tags[tag] = readTagValue(file, entryOffset, tiffStart, dirStart, bigEnd)
+  }
+  return tags
+}
+
+function readTagValue (file, entryOffset, tiffStart, dirStart, bigEnd) {
+  var type = file.getUint16(entryOffset + 2, !bigEnd),
+    numValues = file.getUint32(entryOffset + 4, !bigEnd),
+    valueOffset = file.getUint32(entryOffset + 8, !bigEnd) + tiffStart,
+    offset,
+    vals, val, n,
+    numerator, denominator
+
+  switch (type) {
+    case 1: // byte, 8-bit unsigned int
+    case 7: // undefined, 8-bit byte, value depending on field
+      if (numValues == 1) {
+        return file.getUint8(entryOffset + 8, !bigEnd)
+      } else {
+        offset = numValues > 4 ? valueOffset : (entryOffset + 8)
+        vals = []
+        for (n = 0; n < numValues; n++) {
+          vals[n] = file.getUint8(offset + n)
+        }
+        return vals
+      }
+
+    case 2: // ascii, 8-bit byte
+      offset = numValues > 4 ? valueOffset : (entryOffset + 8)
+      return util.getStringFromDB(file, offset, numValues - 1)
+
+    case 3: // short, 16 bit int
+      if (numValues == 1) {
+        return file.getUint16(entryOffset + 8, !bigEnd)
+      } else {
+        offset = numValues > 2 ? valueOffset : (entryOffset + 8)
+        vals = []
+        for (n = 0; n < numValues; n++) {
+          vals[n] = file.getUint16(offset + 2 * n, !bigEnd)
+        }
+        return vals
+      }
+
+    case 4: // long, 32 bit int
+      if (numValues == 1) {
+        return file.getUint32(entryOffset + 8, !bigEnd)
+      } else {
+        vals = []
+        for (n = 0; n < numValues; n++) {
+          vals[n] = file.getUint32(valueOffset + 4 * n, !bigEnd)
+        }
+        return vals
+      }
+
+    case 5:    // rational = two long values, first is numerator, second is denominator
+      if (numValues == 1) {
+        numerator = file.getUint32(valueOffset, !bigEnd)
+        denominator = file.getUint32(valueOffset + 4, !bigEnd)
+        val = new Number(numerator / denominator)
+        val.numerator = numerator
+        val.denominator = denominator
+        return val
+      } else {
+        vals = []
+        for (n = 0; n < numValues; n++) {
+          numerator = file.getUint32(valueOffset + 8 * n, !bigEnd)
+          denominator = file.getUint32(valueOffset + 4 + 8 * n, !bigEnd)
+          vals[n] = new Number(numerator / denominator)
+          vals[n].numerator = numerator
+          vals[n].denominator = denominator
+        }
+        return vals
+      }
+
+    case 9: // slong, 32 bit signed int
+      if (numValues == 1) {
+        return file.getInt32(entryOffset + 8, !bigEnd)
+      } else {
+        vals = []
+        for (n = 0; n < numValues; n++) {
+          vals[n] = file.getInt32(valueOffset + 4 * n, !bigEnd)
+        }
+        return vals
+      }
+
+    case 10: // signed rational, two slongs, first is numerator, second is denominator
+      if (numValues == 1) {
+        return file.getInt32(valueOffset, !bigEnd) / file.getInt32(valueOffset + 4, !bigEnd)
+      } else {
+        vals = []
+        for (n = 0; n < numValues; n++) {
+          vals[n] = file.getInt32(valueOffset + 8 * n, !bigEnd) / file.getInt32(valueOffset + 4 + 8 * n, !bigEnd)
+        }
+        return vals
+      }
+  }
+}

package/src/photo-parser/exif/string_values.js

@@ -0,0 +1,137 @@
+export default {
+  ExposureProgram: {
+    0: 'Not defined',
+    1: 'Manual',
+    2: 'Normal program',
+    3: 'Aperture priority',
+    4: 'Shutter priority',
+    5: 'Creative program',
+    6: 'Action program',
+    7: 'Portrait mode',
+    8: 'Landscape mode'
+  },
+  MeteringMode: {
+    0: 'Unknown',
+    1: 'Average',
+    2: 'CenterWeightedAverage',
+    3: 'Spot',
+    4: 'MultiSpot',
+    5: 'Pattern',
+    6: 'Partial',
+    255: 'Other'
+  },
+  LightSource: {
+    0: 'Unknown',
+    1: 'Daylight',
+    2: 'Fluorescent',
+    3: 'Tungsten (incandescent light)',
+    4: 'Flash',
+    9: 'Fine weather',
+    10: 'Cloudy weather',
+    11: 'Shade',
+    12: 'Daylight fluorescent (D 5700 - 7100K)',
+    13: 'Day white fluorescent (N 4600 - 5400K)',
+    14: 'Cool white fluorescent (W 3900 - 4500K)',
+    15: 'White fluorescent (WW 3200 - 3700K)',
+    17: 'Standard light A',
+    18: 'Standard light B',
+    19: 'Standard light C',
+    20: 'D55',
+    21: 'D65',
+    22: 'D75',
+    23: 'D50',
+    24: 'ISO studio tungsten',
+    255: 'Other'
+  },
+  Flash: {
+    0x0000: 'Flash did not fire',
+    0x0001: 'Flash fired',
+    0x0005: 'Strobe return light not detected',
+    0x0007: 'Strobe return light detected',
+    0x0009: 'Flash fired, compulsory flash mode',
+    0x000D: 'Flash fired, compulsory flash mode, return light not detected',
+    0x000F: 'Flash fired, compulsory flash mode, return light detected',
+    0x0010: 'Flash did not fire, compulsory flash mode',
+    0x0018: 'Flash did not fire, auto mode',
+    0x0019: 'Flash fired, auto mode',
+    0x001D: 'Flash fired, auto mode, return light not detected',
+    0x001F: 'Flash fired, auto mode, return light detected',
+    0x0020: 'No flash function',
+    0x0041: 'Flash fired, red-eye reduction mode',
+    0x0045: 'Flash fired, red-eye reduction mode, return light not detected',
+    0x0047: 'Flash fired, red-eye reduction mode, return light detected',
+    0x0049: 'Flash fired, compulsory flash mode, red-eye reduction mode',
+    0x004D: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected',
+    0x004F: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light detected',
+    0x0059: 'Flash fired, auto mode, red-eye reduction mode',
+    0x005D: 'Flash fired, auto mode, return light not detected, red-eye reduction mode',
+    0x005F: 'Flash fired, auto mode, return light detected, red-eye reduction mode'
+  },
+  SensingMethod: {
+    1: 'Not defined',
+    2: 'One-chip color area sensor',
+    3: 'Two-chip color area sensor',
+    4: 'Three-chip color area sensor',
+    5: 'Color sequential area sensor',
+    7: 'Trilinear sensor',
+    8: 'Color sequential linear sensor'
+  },
+  SceneCaptureType: {
+    0: 'Standard',
+    1: 'Landscape',
+    2: 'Portrait',
+    3: 'Night scene'
+  },
+  SceneType: {
+    1: 'Directly photographed'
+  },
+  CustomRendered: {
+    0: 'Normal process',
+    1: 'Custom process'
+  },
+  WhiteBalance: {
+    0: 'Auto white balance',
+    1: 'Manual white balance'
+  },
+  GainControl: {
+    0: 'None',
+    1: 'Low gain up',
+    2: 'High gain up',
+    3: 'Low gain down',
+    4: 'High gain down'
+  },
+  Contrast: {
+    0: 'Normal',
+    1: 'Soft',
+    2: 'Hard'
+  },
+  Saturation: {
+    0: 'Normal',
+    1: 'Low saturation',
+    2: 'High saturation'
+  },
+  Sharpness: {
+    0: 'Normal',
+    1: 'Soft',
+    2: 'Hard'
+  },
+  SubjectDistanceRange: {
+    0: 'Unknown',
+    1: 'Macro',
+    2: 'Close view',
+    3: 'Distant view'
+  },
+  FileSource: {
+    3: 'DSC'
+  },
+
+  Components: {
+    0: '',
+    1: 'Y',
+    2: 'Cb',
+    3: 'Cr',
+    4: 'R',
+    5: 'G',
+    6: 'B'
+  }
+}

package/src/photo-parser/exif/tags.js

@@ -0,0 +1,75 @@
+export default {
+
+  // version tags
+  0x9000: 'ExifVersion',             // EXIF version
+  0xA000: 'FlashpixVersion',         // Flashpix format version
+
+  // colorspace tags
+  0xA001: 'ColorSpace',              // Color space information tag
+
+  // image configuration
+  0xA002: 'PixelXDimension',         // Valid width of meaningful image
+  0xA003: 'PixelYDimension',         // Valid height of meaningful image
+  0x9101: 'ComponentsConfiguration', // Information about channels
+  0x9102: 'CompressedBitsPerPixel',  // Compressed bits per pixel
+
+  // user information
+  //0x927C: "MakerNote",               // Any desired information written by the manufacturer
+  //0x9286: "UserComment",             // Comments by user
+
+  // related file
+  0xA004: 'RelatedSoundFile',        // Name of related sound file
+
+  // date and time
+  0x9003: 'DateTimeOriginal',        // Date and time when the original image was generated
+  0x9004: 'DateTimeDigitized',       // Date and time when the image was stored digitally
+  0x9290: 'SubsecTime',              // Fractions of seconds for DateTime
+  0x9291: 'SubsecTimeOriginal',      // Fractions of seconds for DateTimeOriginal
+  0x9292: 'SubsecTimeDigitized',     // Fractions of seconds for DateTimeDigitized
+
+  // picture-taking conditions
+  0x829A: 'ExposureTime',            // Exposure time (in seconds)
+  0x829D: 'FNumber',                 // F number
+  0x8822: 'ExposureProgram',         // Exposure program
+  0x8824: 'SpectralSensitivity',     // Spectral sensitivity
+  0x8827: 'ISOSpeedRatings',         // ISO speed rating
+  0x8828: 'OECF',                    // Optoelectric conversion factor
+  0x9201: 'ShutterSpeedValue',       // Shutter speed
+  0x9202: 'ApertureValue',           // Lens aperture
+  0x9203: 'BrightnessValue',         // Value of brightness
+  0x9204: 'ExposureBias',            // Exposure bias
+  0x9205: 'MaxApertureValue',        // Smallest F number of lens
+  0x9206: 'SubjectDistance',         // Distance to subject in meters
+  0x9207: 'MeteringMode',            // Metering mode
+  0x9208: 'LightSource',             // Kind of light source
+  0x9209: 'Flash',                   // Flash status
+  0x9214: 'SubjectArea',             // Location and area of main subject
+  0x920A: 'FocalLength',             // Focal length of the lens in mm
+  0xA20B: 'FlashEnergy',             // Strobe energy in BCPS
+  0xA20C: 'SpatialFrequencyResponse',    //
+  0xA20E: 'FocalPlaneXResolution',   // Number of pixels in width direction per FocalPlaneResolutionUnit
+  0xA20F: 'FocalPlaneYResolution',   // Number of pixels in height direction per FocalPlaneResolutionUnit
+  0xA210: 'FocalPlaneResolutionUnit',    // Unit for measuring FocalPlaneXResolution and FocalPlaneYResolution
+  0xA214: 'SubjectLocation',         // Location of subject in image
+  0xA215: 'ExposureIndex',           // Exposure index selected on camera
+  0xA217: 'SensingMethod',           // Image sensor type
+  0xA300: 'FileSource',              // Image source (3 == DSC)
+  0xA301: 'SceneType',               // Scene type (1 == directly photographed)
+  0xA302: 'CFAPattern',              // Color filter array geometric pattern
+  0xA401: 'CustomRendered',          // Special processing
+  0xA402: 'ExposureMode',            // Exposure mode
+  0xA403: 'WhiteBalance',            // 1 = auto white balance, 2 = manual
+  0xA404: 'DigitalZoomRation',       // Digital zoom ratio
+  0xA405: 'FocalLengthIn35mmFilm',   // Equivalent foacl length assuming 35mm film camera (in mm)
+  0xA406: 'SceneCaptureType',        // Type of scene
+  0xA407: 'GainControl',             // Degree of overall image gain adjustment
+  0xA408: 'Contrast',                // Direction of contrast processing applied by camera
+  0xA409: 'Saturation',              // Direction of saturation processing applied by camera
+  0xA40A: 'Sharpness',               // Direction of sharpness processing applied by camera
+  0xA40B: 'DeviceSettingDescription',    //
+  0xA40C: 'SubjectDistanceRange',    // Distance to subject
+
+  // other tags
+  0xA005: 'InteroperabilityIFDPointer',
+  0xA420: 'ImageUniqueID'            // Identifier assigned uniquely to each image
+}

package/src/photo-parser/exif/tiff_tags.js

@@ -0,0 +1,35 @@
+export default {
+  0x0100: 'ImageWidth',
+  0x0101: 'ImageHeight',
+  0x8769: 'ExifIFDPointer',
+  0x8825: 'GPSInfoIFDPointer',
+  0xA005: 'InteroperabilityIFDPointer',
+  0x0102: 'BitsPerSample',
+  0x0103: 'Compression',
+  0x0106: 'PhotometricInterpretation',
+  0x0112: 'Orientation',
+  0x0115: 'SamplesPerPixel',
+  0x011C: 'PlanarConfiguration',
+  0x0212: 'YCbCrSubSampling',
+  0x0213: 'YCbCrPositioning',
+  0x011A: 'XResolution',
+  0x011B: 'YResolution',
+  0x0128: 'ResolutionUnit',
+  0x0111: 'StripOffsets',
+  0x0116: 'RowsPerStrip',
+  0x0117: 'StripByteCounts',
+  0x0201: 'JPEGInterchangeFormat',
+  0x0202: 'JPEGInterchangeFormatLength',
+  0x012D: 'TransferFunction',
+  0x013E: 'WhitePoint',
+  0x013F: 'PrimaryChromaticities',
+  0x0211: 'YCbCrCoefficients',
+  0x0214: 'ReferenceBlackWhite',
+  0x0132: 'DateTime',
+  0x010E: 'ImageDescription',
+  0x010F: 'Make',
+  0x0110: 'Model',
+  0x0131: 'Software',
+  0x013B: 'Artist',
+  0x8298: 'Copyright'
+}