diff options
Diffstat (limited to 'resources/src/mediawiki.libs/mediawiki.libs.jpegmeta.js')
| -rw-r--r-- | resources/src/mediawiki.libs/mediawiki.libs.jpegmeta.js | 737 |
1 files changed, 737 insertions, 0 deletions
diff --git a/resources/src/mediawiki.libs/mediawiki.libs.jpegmeta.js b/resources/src/mediawiki.libs/mediawiki.libs.jpegmeta.js new file mode 100644 index 00000000..b3ed88c8 --- /dev/null +++ b/resources/src/mediawiki.libs/mediawiki.libs.jpegmeta.js @@ -0,0 +1,737 @@ +/** + * This is JsJpegMeta v1.0 + * From: https://code.google.com/p/jsjpegmeta/downloads/list + * From: https://github.com/bennoleslie/jsjpegmeta/blob/v1.0.0/jpegmeta.js + * + * Ported to MediaWiki ResourceLoader by Bryan Tong Minh + * Changes: + * - Add closure. + * - Add this.JpegMeta assignment to expose it as global. + * - Add mw.libs.jpegmeta wrapper. + */ + +( function () { + /* + Copyright (c) 2009 Ben Leslie + + 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. + */ + + /* + This JavaScript library is used to parse meta-data from files + with mime-type image/jpeg. + + Include it with something like: + + <script type="text/javascript" src="jpegmeta.js"></script> + + This adds a single 'module' object called 'JpegMeta' to the global + namespace. + + Public Functions + ---------------- + JpegMeta.parseNum - parse unsigned integers from binary data + JpegMeta.parseSnum - parse signed integers from binary data + + Public Classes + -------------- + JpegMeta.Rational - A rational number class + JpegMeta.JfifSegment + JpegMeta.ExifSegment + JpegMeta.JpegFile - Primary class for Javascript parsing + */ + + var JpegMeta = {}; + // MediaWiki: Expose as global + this.JpegMeta = JpegMeta; + + /* + parse an unsigned number of size bytes at offset in some binary string data. + If endian + is "<" parse the data as little endian, if endian + is ">" parse as big-endian. + */ + JpegMeta.parseNum = function parseNum(endian, data, offset, size) { + var i; + var ret; + var big_endian = (endian === ">"); + if (offset === undefined) offset = 0; + if (size === undefined) size = data.length - offset; + for (big_endian ? i = offset : i = offset + size - 1; + big_endian ? i < offset + size : i >= offset; + big_endian ? i++ : i--) { + ret <<= 8; + ret += data.charCodeAt(i); + } + return ret; + }; + + /* + parse an signed number of size bytes at offset in some binary string data. + If endian + is "<" parse the data as little endian, if endian + is ">" parse as big-endian. + */ + JpegMeta.parseSnum = function parseSnum(endian, data, offset, size) { + var i; + var ret; + var neg; + var big_endian = (endian === ">"); + if (offset === undefined) offset = 0; + if (size === undefined) size = data.length - offset; + for (big_endian ? i = offset : i = offset + size - 1; + big_endian ? i < offset + size : i >= offset; + big_endian ? i++ : i--) { + if (neg === undefined) { + /* Negative if top bit is set */ + neg = (data.charCodeAt(i) & 0x80) === 0x80; + } + ret <<= 8; + /* If it is negative we invert the bits */ + ret += neg ? ~data.charCodeAt(i) & 0xff: data.charCodeAt(i); + } + if (neg) { + /* If it is negative we do two's complement */ + ret += 1; + ret *= -1; + } + return ret; + }; + + /* Rational number class */ + JpegMeta.Rational = function Rational(num, den) + { + this.num = num; + this.den = den || 1; + return this; + }; + + /* Rational number methods */ + JpegMeta.Rational.prototype.toString = function toString() { + if (this.num === 0) { + return "" + this.num; + } + if (this.den === 1) { + return "" + this.num; + } + if (this.num === 1) { + return this.num + " / " + this.den; + } + return this.num / this.den; // + "/" + this.den; + }; + + JpegMeta.Rational.prototype.asFloat = function asFloat() { + return this.num / this.den; + }; + + /* MetaGroup class */ + JpegMeta.MetaGroup = function MetaGroup(fieldName, description) { + this.fieldName = fieldName; + this.description = description; + this.metaProps = {}; + return this; + }; + + JpegMeta.MetaGroup.prototype._addProperty = function _addProperty(fieldName, description, value) { + var property = new JpegMeta.MetaProp(fieldName, description, value); + this[property.fieldName] = property; + this.metaProps[property.fieldName] = property; + }; + + JpegMeta.MetaGroup.prototype.toString = function toString() { + return "[MetaGroup " + this.description + "]"; + }; + + /* MetaProp class */ + JpegMeta.MetaProp = function MetaProp(fieldName, description, value) { + this.fieldName = fieldName; + this.description = description; + this.value = value; + return this; + }; + + JpegMeta.MetaProp.prototype.toString = function toString() { + return "" + this.value; + }; + + /* JpegFile class */ + JpegMeta.JpegFile = function JpegFile(binary_data, filename) { + /* Change this to EOI if we want to parse. */ + var break_segment = this._SOS; + + this.metaGroups = {}; + this._binary_data = binary_data; + this.filename = filename; + + /* Go through and parse. */ + var pos = 0; + var pos_start_of_segment = 0; + var delim; + var mark; + var _mark; + var segsize; + var headersize; + var mark_code; + var mark_fn; + + /* Check to see if this looks like a JPEG file */ + if (this._binary_data.slice(0, 2) !== this._SOI_MARKER) { + throw new Error("Doesn't look like a JPEG file. First two bytes are " + + this._binary_data.charCodeAt(0) + "," + + this._binary_data.charCodeAt(1) + "."); + } + + pos += 2; + + while (pos < this._binary_data.length) { + delim = this._binary_data.charCodeAt(pos++); + mark = this._binary_data.charCodeAt(pos++); + + pos_start_of_segment = pos; + + if (delim != this._DELIM) { + break; + } + + if (mark === break_segment) { + break; + } + + headersize = JpegMeta.parseNum(">", this._binary_data, pos, 2); + + /* Find the end */ + pos += headersize; + while (pos < this._binary_data.length) { + delim = this._binary_data.charCodeAt(pos++); + if (delim == this._DELIM) { + _mark = this._binary_data.charCodeAt(pos++); + if (_mark != 0x0) { + pos -= 2; + break; + } + } + } + + segsize = pos - pos_start_of_segment; + + if (this._markers[mark]) { + mark_code = this._markers[mark][0]; + mark_fn = this._markers[mark][1]; + } else { + mark_code = "UNKN"; + mark_fn = undefined; + } + + if (mark_fn) { + this[mark_fn](mark, pos_start_of_segment + 2); + } + + } + + if (this.general === undefined) { + throw Error("Invalid JPEG file."); + } + + return this; + }; + + this.JpegMeta.JpegFile.prototype.toString = function () { + return "[JpegFile " + this.filename + " " + + this.general.type + " " + + this.general.pixelWidth + "x" + + this.general.pixelHeight + + " Depth: " + this.general.depth + "]"; + }; + + /* Some useful constants */ + this.JpegMeta.JpegFile.prototype._SOI_MARKER = '\xff\xd8'; + this.JpegMeta.JpegFile.prototype._DELIM = 0xff; + this.JpegMeta.JpegFile.prototype._EOI = 0xd9; + this.JpegMeta.JpegFile.prototype._SOS = 0xda; + + this.JpegMeta.JpegFile.prototype._sofHandler = function _sofHandler (mark, pos) { + if (this.general !== undefined) { + throw Error("Unexpected multiple-frame image"); + } + + this._addMetaGroup("general", "General"); + this.general._addProperty("depth", "Depth", JpegMeta.parseNum(">", this._binary_data, pos, 1)); + this.general._addProperty("pixelHeight", "Pixel Height", JpegMeta.parseNum(">", this._binary_data, pos + 1, 2)); + this.general._addProperty("pixelWidth", "Pixel Width",JpegMeta.parseNum(">", this._binary_data, pos + 3, 2)); + this.general._addProperty("type", "Type", this._markers[mark][2]); + }; + + /* JFIF idents */ + this.JpegMeta.JpegFile.prototype._JFIF_IDENT = "JFIF\x00"; + this.JpegMeta.JpegFile.prototype._JFXX_IDENT = "JFXX\x00"; + + /* Exif idents */ + this.JpegMeta.JpegFile.prototype._EXIF_IDENT = "Exif\x00"; + + /* TIFF types */ + this.JpegMeta.JpegFile.prototype._types = { + /* The format is identifier : ["type name", type_size_in_bytes ] */ + 1 : ["BYTE", 1], + 2 : ["ASCII", 1], + 3 : ["SHORT", 2], + 4 : ["LONG", 4], + 5 : ["RATIONAL", 8], + 6 : ["SBYTE", 1], + 7 : ["UNDEFINED", 1], + 8 : ["SSHORT", 2], + 9 : ["SLONG", 4], + 10 : ["SRATIONAL", 8], + 11 : ["FLOAT", 4], + 12 : ["DOUBLE", 8] + }; + + this.JpegMeta.JpegFile.prototype._tifftags = { + /* A. Tags relating to image data structure */ + 256 : ["Image width", "ImageWidth"], + 257 : ["Image height", "ImageLength"], + 258 : ["Number of bits per component", "BitsPerSample"], + 259 : ["Compression scheme", "Compression", + {1 : "uncompressed", 6 : "JPEG compression" }], + 262 : ["Pixel composition", "PhotmetricInerpretation", + {2 : "RGB", 6 : "YCbCr"}], + 274 : ["Orientation of image", "Orientation", + /* FIXME: Check the mirror-image / reverse encoding and rotation */ + {1 : "Normal", 2 : "Reverse?", + 3 : "Upside-down", 4 : "Upside-down Reverse", + 5 : "90 degree CW", 6 : "90 degree CW reverse", + 7 : "90 degree CCW", 8 : "90 degree CCW reverse"}], + 277 : ["Number of components", "SamplesPerPixel"], + 284 : ["Image data arrangement", "PlanarConfiguration", + {1 : "chunky format", 2 : "planar format"}], + 530 : ["Subsampling ratio of Y to C", "YCbCrSubSampling"], + 531 : ["Y and C positioning", "YCbCrPositioning", + {1 : "centered", 2 : "co-sited"}], + 282 : ["X Resolution", "XResolution"], + 283 : ["Y Resolution", "YResolution"], + 296 : ["Resolution Unit", "ResolutionUnit", + {2 : "inches", 3 : "centimeters"}], + /* B. Tags realting to recording offset */ + 273 : ["Image data location", "StripOffsets"], + 278 : ["Number of rows per strip", "RowsPerStrip"], + 279 : ["Bytes per compressed strip", "StripByteCounts"], + 513 : ["Offset to JPEG SOI", "JPEGInterchangeFormat"], + 514 : ["Bytes of JPEG Data", "JPEGInterchangeFormatLength"], + /* C. Tags relating to image data characteristics */ + 301 : ["Transfer function", "TransferFunction"], + 318 : ["White point chromaticity", "WhitePoint"], + 319 : ["Chromaticities of primaries", "PrimaryChromaticities"], + 529 : ["Color space transformation matrix coefficients", "YCbCrCoefficients"], + 532 : ["Pair of black and white reference values", "ReferenceBlackWhite"], + /* D. Other tags */ + 306 : ["Date and time", "DateTime"], + 270 : ["Image title", "ImageDescription"], + 271 : ["Make", "Make"], + 272 : ["Model", "Model"], + 305 : ["Software", "Software"], + 315 : ["Person who created the image", "Artist"], + 316 : ["Host Computer", "HostComputer"], + 33432 : ["Copyright holder", "Copyright"], + + 34665 : ["Exif tag", "ExifIfdPointer"], + 34853 : ["GPS tag", "GPSInfoIfdPointer"] + }; + + this.JpegMeta.JpegFile.prototype._exiftags = { + /* Tag Support Levels (2) - 0th IFX Exif Private Tags */ + /* A. Tags Relating to Version */ + 36864 : ["Exif Version", "ExifVersion"], + 40960 : ["FlashPix Version", "FlashpixVersion"], + + /* B. Tag Relating to Image Data Characteristics */ + 40961 : ["Color Space", "ColorSpace"], + + /* C. Tags Relating to Image Configuration */ + 37121 : ["Meaning of each component", "ComponentsConfiguration"], + 37122 : ["Compressed Bits Per Pixel", "CompressedBitsPerPixel"], + 40962 : ["Pixel X Dimension", "PixelXDimension"], + 40963 : ["Pixel Y Dimension", "PixelYDimension"], + + /* D. Tags Relating to User Information */ + 37500 : ["Manufacturer notes", "MakerNote"], + 37510 : ["User comments", "UserComment"], + + /* E. Tag Relating to Related File Information */ + 40964 : ["Related audio file", "RelatedSoundFile"], + + /* F. Tags Relating to Date and Time */ + 36867 : ["Date Time Original", "DateTimeOriginal"], + 36868 : ["Date Time Digitized", "DateTimeDigitized"], + 37520 : ["DateTime subseconds", "SubSecTime"], + 37521 : ["DateTimeOriginal subseconds", "SubSecTimeOriginal"], + 37522 : ["DateTimeDigitized subseconds", "SubSecTimeDigitized"], + + /* G. Tags Relating to Picture-Taking Conditions */ + 33434 : ["Exposure time", "ExposureTime"], + 33437 : ["FNumber", "FNumber"], + 34850 : ["Exposure program", "ExposureProgram"], + 34852 : ["Spectral sensitivity", "SpectralSensitivity"], + 34855 : ["ISO Speed Ratings", "ISOSpeedRatings"], + 34856 : ["Optoelectric coefficient", "OECF"], + 37377 : ["Shutter Speed", "ShutterSpeedValue"], + 37378 : ["Aperture Value", "ApertureValue"], + 37379 : ["Brightness", "BrightnessValue"], + 37380 : ["Exposure Bias Value", "ExposureBiasValue"], + 37381 : ["Max Aperture Value", "MaxApertureValue"], + 37382 : ["Subject Distance", "SubjectDistance"], + 37383 : ["Metering Mode", "MeteringMode"], + 37384 : ["Light Source", "LightSource"], + 37385 : ["Flash", "Flash"], + 37386 : ["Focal Length", "FocalLength"], + 37396 : ["Subject Area", "SubjectArea"], + 41483 : ["Flash Energy", "FlashEnergy"], + 41484 : ["Spatial Frequency Response", "SpatialFrequencyResponse"], + 41486 : ["Focal Plane X Resolution", "FocalPlaneXResolution"], + 41487 : ["Focal Plane Y Resolution", "FocalPlaneYResolution"], + 41488 : ["Focal Plane Resolution Unit", "FocalPlaneResolutionUnit"], + 41492 : ["Subject Location", "SubjectLocation"], + 41493 : ["Exposure Index", "ExposureIndex"], + 41495 : ["Sensing Method", "SensingMethod"], + 41728 : ["File Source", "FileSource"], + 41729 : ["Scene Type", "SceneType"], + 41730 : ["CFA Pattern", "CFAPattern"], + 41985 : ["Custom Rendered", "CustomRendered"], + 41986 : ["Exposure Mode", "Exposure Mode"], + 41987 : ["White Balance", "WhiteBalance"], + 41988 : ["Digital Zoom Ratio", "DigitalZoomRatio"], + 41990 : ["Scene Capture Type", "SceneCaptureType"], + 41991 : ["Gain Control", "GainControl"], + 41992 : ["Contrast", "Contrast"], + 41993 : ["Saturation", "Saturation"], + 41994 : ["Sharpness", "Sharpness"], + 41995 : ["Device settings description", "DeviceSettingDescription"], + 41996 : ["Subject distance range", "SubjectDistanceRange"], + + /* H. Other Tags */ + 42016 : ["Unique image ID", "ImageUniqueID"], + + 40965 : ["Interoperability tag", "InteroperabilityIFDPointer"] + }; + + this.JpegMeta.JpegFile.prototype._gpstags = { + /* A. Tags Relating to GPS */ + 0 : ["GPS tag version", "GPSVersionID"], + 1 : ["North or South Latitude", "GPSLatitudeRef"], + 2 : ["Latitude", "GPSLatitude"], + 3 : ["East or West Longitude", "GPSLongitudeRef"], + 4 : ["Longitude", "GPSLongitude"], + 5 : ["Altitude reference", "GPSAltitudeRef"], + 6 : ["Altitude", "GPSAltitude"], + 7 : ["GPS time (atomic clock)", "GPSTimeStamp"], + 8 : ["GPS satellites usedd for measurement", "GPSSatellites"], + 9 : ["GPS receiver status", "GPSStatus"], + 10 : ["GPS mesaurement mode", "GPSMeasureMode"], + 11 : ["Measurement precision", "GPSDOP"], + 12 : ["Speed unit", "GPSSpeedRef"], + 13 : ["Speed of GPS receiver", "GPSSpeed"], + 14 : ["Reference for direction of movement", "GPSTrackRef"], + 15 : ["Direction of movement", "GPSTrack"], + 16 : ["Reference for direction of image", "GPSImgDirectionRef"], + 17 : ["Direction of image", "GPSImgDirection"], + 18 : ["Geodetic survey data used", "GPSMapDatum"], + 19 : ["Reference for latitude of destination", "GPSDestLatitudeRef"], + 20 : ["Latitude of destination", "GPSDestLatitude"], + 21 : ["Reference for longitude of destination", "GPSDestLongitudeRef"], + 22 : ["Longitude of destination", "GPSDestLongitude"], + 23 : ["Reference for bearing of destination", "GPSDestBearingRef"], + 24 : ["Bearing of destination", "GPSDestBearing"], + 25 : ["Reference for distance to destination", "GPSDestDistanceRef"], + 26 : ["Distance to destination", "GPSDestDistance"], + 27 : ["Name of GPS processing method", "GPSProcessingMethod"], + 28 : ["Name of GPS area", "GPSAreaInformation"], + 29 : ["GPS Date", "GPSDateStamp"], + 30 : ["GPS differential correction", "GPSDifferential"] + }; + + this.JpegMeta.JpegFile.prototype._markers = { + /* Start Of Frame markers, non-differential, Huffman coding */ + 0xc0: ["SOF0", "_sofHandler", "Baseline DCT"], + 0xc1: ["SOF1", "_sofHandler", "Extended sequential DCT"], + 0xc2: ["SOF2", "_sofHandler", "Progressive DCT"], + 0xc3: ["SOF3", "_sofHandler", "Lossless (sequential)"], + + /* Start Of Frame markers, differential, Huffman coding */ + 0xc5: ["SOF5", "_sofHandler", "Differential sequential DCT"], + 0xc6: ["SOF6", "_sofHandler", "Differential progressive DCT"], + 0xc7: ["SOF7", "_sofHandler", "Differential lossless (sequential)"], + + /* Start Of Frame markers, non-differential, arithmetic coding */ + 0xc8: ["JPG", null, "Reserved for JPEG extensions"], + 0xc9: ["SOF9", "_sofHandler", "Extended sequential DCT"], + 0xca: ["SOF10", "_sofHandler", "Progressive DCT"], + 0xcb: ["SOF11", "_sofHandler", "Lossless (sequential)"], + + /* Start Of Frame markers, differential, arithmetic coding */ + 0xcd: ["SOF13", "_sofHandler", "Differential sequential DCT"], + 0xce: ["SOF14", "_sofHandler", "Differential progressive DCT"], + 0xcf: ["SOF15", "_sofHandler", "Differential lossless (sequential)"], + + /* Huffman table specification */ + 0xc4: ["DHT", null, "Define Huffman table(s)"], + 0xcc: ["DAC", null, "Define arithmetic coding conditioning(s)"], + + /* Restart interval termination" */ + 0xd0: ["RST0", null, "Restart with modulo 8 count “0”"], + 0xd1: ["RST1", null, "Restart with modulo 8 count “1”"], + 0xd2: ["RST2", null, "Restart with modulo 8 count “2”"], + 0xd3: ["RST3", null, "Restart with modulo 8 count “3”"], + 0xd4: ["RST4", null, "Restart with modulo 8 count “4”"], + 0xd5: ["RST5", null, "Restart with modulo 8 count “5”"], + 0xd6: ["RST6", null, "Restart with modulo 8 count “6”"], + 0xd7: ["RST7", null, "Restart with modulo 8 count “7”"], + + /* Other markers */ + 0xd8: ["SOI", null, "Start of image"], + 0xd9: ["EOI", null, "End of image"], + 0xda: ["SOS", null, "Start of scan"], + 0xdb: ["DQT", null, "Define quantization table(s)"], + 0xdc: ["DNL", null, "Define number of lines"], + 0xdd: ["DRI", null, "Define restart interval"], + 0xde: ["DHP", null, "Define hierarchical progression"], + 0xdf: ["EXP", null, "Expand reference component(s)"], + 0xe0: ["APP0", "_app0Handler", "Reserved for application segments"], + 0xe1: ["APP1", "_app1Handler"], + 0xe2: ["APP2", null], + 0xe3: ["APP3", null], + 0xe4: ["APP4", null], + 0xe5: ["APP5", null], + 0xe6: ["APP6", null], + 0xe7: ["APP7", null], + 0xe8: ["APP8", null], + 0xe9: ["APP9", null], + 0xea: ["APP10", null], + 0xeb: ["APP11", null], + 0xec: ["APP12", null], + 0xed: ["APP13", null], + 0xee: ["APP14", null], + 0xef: ["APP15", null], + 0xf0: ["JPG0", null], /* Reserved for JPEG extensions */ + 0xf1: ["JPG1", null], + 0xf2: ["JPG2", null], + 0xf3: ["JPG3", null], + 0xf4: ["JPG4", null], + 0xf5: ["JPG5", null], + 0xf6: ["JPG6", null], + 0xf7: ["JPG7", null], + 0xf8: ["JPG8", null], + 0xf9: ["JPG9", null], + 0xfa: ["JPG10", null], + 0xfb: ["JPG11", null], + 0xfc: ["JPG12", null], + 0xfd: ["JPG13", null], + 0xfe: ["COM", null], /* Comment */ + + /* Reserved markers */ + 0x01: ["JPG13", null] /* For temporary private use in arithmetic coding */ + /* 02 -> bf are reserverd */ + }; + + /* Private methods */ + this.JpegMeta.JpegFile.prototype._addMetaGroup = function _addMetaGroup(name, description) { + var group = new JpegMeta.MetaGroup(name, description); + this[group.fieldName] = group; + this.metaGroups[group.fieldName] = group; + return group; + }; + + this.JpegMeta.JpegFile.prototype._parseIfd = function _parseIfd(endian, _binary_data, base, ifd_offset, tags, name, description) { + var num_fields = JpegMeta.parseNum(endian, _binary_data, base + ifd_offset, 2); + /* Per tag variables */ + var i, j; + var tag_base; + var tag_field; + var type, type_field, type_size; + var num_values; + var value_offset; + var value; + var _val; + var num; + var den; + + var group; + + group = this._addMetaGroup(name, description); + + for (var i = 0; i < num_fields; i++) { + /* parse the field */ + tag_base = base + ifd_offset + 2 + (i * 12); + tag_field = JpegMeta.parseNum(endian, _binary_data, tag_base, 2); + type_field = JpegMeta.parseNum(endian, _binary_data, tag_base + 2, 2); + num_values = JpegMeta.parseNum(endian, _binary_data, tag_base + 4, 4); + value_offset = JpegMeta.parseNum(endian, _binary_data, tag_base + 8, 4); + if (this._types[type_field] === undefined) { + continue; + } + type = this._types[type_field][0]; + type_size = this._types[type_field][1]; + + if (type_size * num_values <= 4) { + /* Data is in-line */ + value_offset = tag_base + 8; + } else { + value_offset = base + value_offset; + } + + /* Read the value */ + if (type == "UNDEFINED") { + value = _binary_data.slice(value_offset, value_offset + num_values); + } else if (type == "ASCII") { + value = _binary_data.slice(value_offset, value_offset + num_values); + value = value.split('\x00')[0]; + /* strip trail nul */ + } else { + value = new Array(); + for (j = 0; j < num_values; j++, value_offset += type_size) { + if (type == "BYTE" || type == "SHORT" || type == "LONG") { + value.push(JpegMeta.parseNum(endian, _binary_data, value_offset, type_size)); + } + if (type == "SBYTE" || type == "SSHORT" || type == "SLONG") { + value.push(JpegMeta.parseSnum(endian, _binary_data, value_offset, type_size)); + } + if (type == "RATIONAL") { + num = JpegMeta.parseNum(endian, _binary_data, value_offset, 4); + den = JpegMeta.parseNum(endian, _binary_data, value_offset + 4, 4); + value.push(new JpegMeta.Rational(num, den)); + } + if (type == "SRATIONAL") { + num = JpegMeta.parseSnum(endian, _binary_data, value_offset, 4); + den = JpegMeta.parseSnum(endian, _binary_data, value_offset + 4, 4); + value.push(new JpegMeta.Rational(num, den)); + } + value.push(); + } + if (num_values === 1) { + value = value[0]; + } + } + if (tags[tag_field] !== undefined) { + group._addProperty(tags[tag_field][1], tags[tag_field][0], value); + } + } + }; + + this.JpegMeta.JpegFile.prototype._jfifHandler = function _jfifHandler(mark, pos) { + if (this.jfif !== undefined) { + throw Error("Multiple JFIF segments found"); + } + this._addMetaGroup("jfif", "JFIF"); + this.jfif._addProperty("version_major", "Version Major", this._binary_data.charCodeAt(pos + 5)); + this.jfif._addProperty("version_minor", "Version Minor", this._binary_data.charCodeAt(pos + 6)); + this.jfif._addProperty("version", "JFIF Version", this.jfif.version_major.value + "." + this.jfif.version_minor.value); + this.jfif._addProperty("units", "Density Unit", this._binary_data.charCodeAt(pos + 7)); + this.jfif._addProperty("Xdensity", "X density", JpegMeta.parseNum(">", this._binary_data, pos + 8, 2)); + this.jfif._addProperty("Ydensity", "Y Density", JpegMeta.parseNum(">", this._binary_data, pos + 10, 2)); + this.jfif._addProperty("Xthumbnail", "X Thumbnail", JpegMeta.parseNum(">", this._binary_data, pos + 12, 1)); + this.jfif._addProperty("Ythumbnail", "Y Thumbnail", JpegMeta.parseNum(">", this._binary_data, pos + 13, 1)); + }; + + /* Handle app0 segments */ + this.JpegMeta.JpegFile.prototype._app0Handler = function app0Handler(mark, pos) { + var ident = this._binary_data.slice(pos, pos + 5); + if (ident == this._JFIF_IDENT) { + this._jfifHandler(mark, pos); + } else if (ident == this._JFXX_IDENT) { + /* Don't handle JFXX Ident yet */ + } else { + /* Don't know about other idents */ + } + }; + + /* Handle app1 segments */ + this.JpegMeta.JpegFile.prototype._app1Handler = function _app1Handler(mark, pos) { + var ident = this._binary_data.slice(pos, pos + 5); + if (ident == this._EXIF_IDENT) { + this._exifHandler(mark, pos + 6); + } else { + /* Don't know about other idents */ + } + }; + + /* Handle exif segments */ + JpegMeta.JpegFile.prototype._exifHandler = function _exifHandler(mark, pos) { + if (this.exif !== undefined) { + throw new Error("Multiple JFIF segments found"); + } + + /* Parse this TIFF header */ + var endian; + var magic_field; + var ifd_offset; + var primary_ifd, exif_ifd, gps_ifd; + var endian_field = this._binary_data.slice(pos, pos + 2); + + /* Trivia: This 'I' is for Intel, the 'M' is for Motorola */ + if (endian_field === "II") { + endian = "<"; + } else if (endian_field === "MM") { + endian = ">"; + } else { + throw new Error("Malformed TIFF meta-data. Unknown endianess: " + endian_field); + } + + magic_field = JpegMeta.parseNum(endian, this._binary_data, pos + 2, 2); + + if (magic_field !== 42) { + throw new Error("Malformed TIFF meta-data. Bad magic: " + magic_field); + } + + ifd_offset = JpegMeta.parseNum(endian, this._binary_data, pos + 4, 4); + + /* Parse 0th IFD */ + this._parseIfd(endian, this._binary_data, pos, ifd_offset, this._tifftags, "tiff", "TIFF"); + + if (this.tiff.ExifIfdPointer) { + this._parseIfd(endian, this._binary_data, pos, this.tiff.ExifIfdPointer.value, this._exiftags, "exif", "Exif"); + } + + if (this.tiff.GPSInfoIfdPointer) { + this._parseIfd(endian, this._binary_data, pos, this.tiff.GPSInfoIfdPointer.value, this._gpstags, "gps", "GPS"); + if (this.gps.GPSLatitude) { + var latitude; + latitude = this.gps.GPSLatitude.value[0].asFloat() + + (1 / 60) * this.gps.GPSLatitude.value[1].asFloat() + + (1 / 3600) * this.gps.GPSLatitude.value[2].asFloat(); + if (this.gps.GPSLatitudeRef.value === "S") { + latitude = -latitude; + } + this.gps._addProperty("latitude", "Dec. Latitude", latitude); + } + if (this.gps.GPSLongitude) { + var longitude; + longitude = this.gps.GPSLongitude.value[0].asFloat() + + (1 / 60) * this.gps.GPSLongitude.value[1].asFloat() + + (1 / 3600) * this.gps.GPSLongitude.value[2].asFloat(); + if (this.gps.GPSLongitudeRef.value === "W") { + longitude = -longitude; + } + this.gps._addProperty("longitude", "Dec. Longitude", longitude); + } + } + }; + + // MediaWiki: Add mw.libs wrapper + mw.libs.jpegmeta = function( fileReaderResult, fileName ) { + return new JpegMeta.JpegFile( fileReaderResult, fileName ); + }; + +}() ); |