hackedteam/rcs-console

package jp.shichiseki.exif {
    import flash.utils.ByteArray;
    /**
     * The IFDEntry class is an entry in an IFD. The IFDEntry class contains type, name, id
     * and data of the entry.
     */
    public class IFDEntry {
        private static const TAG_TYPES:Object = {
            1: {name:"BYTE", size:1, reader: readByteHandler},
            2: {name:"ASCII", size:1, reader: readStringHandler},
            3: {name:"SHORT", size:2, reader: readShortHandler},
            4: {name:"LONG", size:4, reader: readLongHandler},
            5: {name:"RATIONAL", size:8, reader: readRationalHandler},
            7: {name:"UNDEFINED", size:1, reader: readByteHandler},
            9: {name:"SLONG", size:4, reader: readSLongHandler},
            10: {name:"SRATIONAL", size:8, reader: readSRationalHandler}
        };

        private var _tagID:uint;

        /**
         * Indicates the tagID of this entry.
         */
        public function get tagID():uint { return _tagID; }

        private var _tag:XMLList;
        /**
         *Indicates the tag of this entry.
         */
        public function get tag():XMLList { return _tag; }

        private var _tagName:String;
        /**
         * Indicates the tag name of this entry.
         */
        public function get tagName():String { return tag.@field_name.toString() || _tagName }

        private var _typeID:uint;
        /**
         * Indicates the type ID of this entry.
         */
        public function get typeID():uint { return _typeID; }

        private var _type:Object;
        /**
         * Indicates the type of this entry.
         */
        public function get type():Object { return _type; }

        private var _data:Object;
        /**
         * Indicates the data of this entry.
         */
        public function get data():Object { return _data; }
        private var _numData:uint;

        /**
         * Constructor.
         */
        public function IFDEntry(stream:ByteArray, tagSet:XML, offset:uint) {
            var nextPosition:uint;

            _tagID = stream.readUnsignedShort();
            _tag = tagSet.tag.(parseInt(@id, 16) == tagID);
            _tagName = "0x" + _tagID.toString(16);
            if (!tag.@field_name.toString())
                _tagName = "UnknownTag_" + _tagName;
            _typeID = stream.readUnsignedShort();
            _type = TAG_TYPES[_typeID];
            _numData = stream.readUnsignedInt();
            nextPosition = stream.position + 4;

            if (!type) {
                trace("unrecognizable tag id=" + tagID + " type=" + typeID);
                _data = null;
            } else {
                if (_numData * type.size > 4)
                    stream.position = stream.readUnsignedInt() + offset;
                readContent(stream);
            }
                
            stream.position = nextPosition;
        }

        private function readContent(stream:ByteArray):void {
            if (_typeID == 2) {
                _data = readStringHandler(stream, _numData);
            } else if (_numData == 1) {
                _data = type.reader(stream);
            } else {
                _data = new Array();
                for (var i:uint = 0; i < _numData; i++) {
                    _data.push(type.reader(stream));
                }
            }
        }
    
        private static function readStringHandler(stream:ByteArray, length:uint):String {
      return stream.readUTFBytes(length);
    }

    private static function readByteHandler(stream:ByteArray):uint {
      return stream.readUnsignedByte();
    }

    private static function readShortHandler(stream:ByteArray):uint {
      return stream.readUnsignedShort();
    }

    private static function readLongHandler(stream:ByteArray):uint {
      return stream.readUnsignedInt();
    }

    private static function readSLongHandler(stream:ByteArray):int {
      return stream.readInt();
    }

    private static function readRationalHandler(stream:ByteArray):Number {
      var denominator:uint = stream.readUnsignedInt();
      var numerator:uint = stream.readUnsignedInt();
      return Number(denominator) / Number(numerator);
    }

    private static function readSRationalHandler(stream:ByteArray):Number {
      var denominator:int = stream.readInt();
      var numerator:int = stream.readInt();
      return Number(denominator) / Number(numerator);
    }
    }
}