乐健体育 v3.9.1版本的 MD5 值为：87ae8a64955cdd0e43f3559ee8984d75
以下内容为反编译后的 ExifInterface.java 源代码，内容仅作参考
package io.dcloud.common.util;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.location.Location;
import android.media.MediaDataSource;
import android.media.MediaMetadataRetriever;
import android.os.Build;
import android.system.Os;
import android.system.OsConstants;
import android.util.Log;
import android.util.Pair;
import androidx.constraintlayout.core.motion.utils.TypedValues;
import androidx.media.AudioAttributesCompat;
import androidx.work.WorkRequest;
import com.facebook.imageutils.TiffUtil;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.util.MimeTypes;
import com.google.android.material.datepicker.UtcDates;
import com.google.android.material.shadow.ShadowDrawableWrapper;
import com.google.common.base.Ascii;
import com.google.common.primitives.UnsignedInts;
import com.legym.sport.impl.record.ExerciseRecorder;
import com.taobao.weex.common.Constants;
import com.taobao.weex.el.parse.Operators;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.CRC32;
import org.apache.commons.io.IOUtils;
public class ExifInterface {
public static final short ALTITUDE_ABOVE_SEA_LEVEL = 0;
public static final short ALTITUDE_BELOW_SEA_LEVEL = 1;
public static final Charset ASCII;
public static final short BYTE_ALIGN_II = 18761;
public static final short BYTE_ALIGN_MM = 19789;
public static final int COLOR_SPACE_S_RGB = 1;
public static final int COLOR_SPACE_UNCALIBRATED = 65535;
public static final short CONTRAST_HARD = 2;
public static final short CONTRAST_NORMAL = 0;
public static final short CONTRAST_SOFT = 1;
public static final int DATA_DEFLATE_ZIP = 8;
public static final int DATA_HUFFMAN_COMPRESSED = 2;
public static final int DATA_JPEG = 6;
public static final int DATA_JPEG_COMPRESSED = 7;
public static final int DATA_LOSSY_JPEG = 34892;
public static final int DATA_PACK_BITS_COMPRESSED = 32773;
public static final int DATA_UNCOMPRESSED = 1;
private static final Pattern DATETIME_PRIMARY_FORMAT_PATTERN;
private static final Pattern DATETIME_SECONDARY_FORMAT_PATTERN;
private static final int DATETIME_VALUE_STRING_LENGTH = 19;
private static final ExifTag[] EXIF_POINTER_TAGS;
public static final ExifTag[][] EXIF_TAGS;
public static final short EXPOSURE_MODE_AUTO = 0;
public static final short EXPOSURE_MODE_AUTO_BRACKET = 2;
public static final short EXPOSURE_MODE_MANUAL = 1;
public static final short EXPOSURE_PROGRAM_ACTION = 6;
public static final short EXPOSURE_PROGRAM_APERTURE_PRIORITY = 3;
public static final short EXPOSURE_PROGRAM_CREATIVE = 5;
public static final short EXPOSURE_PROGRAM_LANDSCAPE_MODE = 8;
public static final short EXPOSURE_PROGRAM_MANUAL = 1;
public static final short EXPOSURE_PROGRAM_NORMAL = 2;
public static final short EXPOSURE_PROGRAM_NOT_DEFINED = 0;
public static final short EXPOSURE_PROGRAM_PORTRAIT_MODE = 7;
public static final short EXPOSURE_PROGRAM_SHUTTER_PRIORITY = 4;
public static final short FILE_SOURCE_DSC = 3;
public static final short FILE_SOURCE_OTHER = 0;
public static final short FILE_SOURCE_REFLEX_SCANNER = 2;
public static final short FILE_SOURCE_TRANSPARENT_SCANNER = 1;
public static final short FLAG_FLASH_FIRED = 1;
public static final short FLAG_FLASH_MODE_AUTO = 24;
public static final short FLAG_FLASH_MODE_COMPULSORY_FIRING = 8;
public static final short FLAG_FLASH_MODE_COMPULSORY_SUPPRESSION = 16;
public static final short FLAG_FLASH_NO_FLASH_FUNCTION = 32;
public static final short FLAG_FLASH_RED_EYE_SUPPORTED = 64;
public static final short FLAG_FLASH_RETURN_LIGHT_DETECTED = 6;
public static final short FLAG_FLASH_RETURN_LIGHT_NOT_DETECTED = 4;
public static final short FORMAT_CHUNKY = 1;
public static final short FORMAT_PLANAR = 2;
public static final short GAIN_CONTROL_HIGH_GAIN_DOWN = 4;
public static final short GAIN_CONTROL_HIGH_GAIN_UP = 2;
public static final short GAIN_CONTROL_LOW_GAIN_DOWN = 3;
public static final short GAIN_CONTROL_LOW_GAIN_UP = 1;
public static final short GAIN_CONTROL_NONE = 0;
public static final String GPS_DIRECTION_MAGNETIC = "M";
public static final String GPS_DIRECTION_TRUE = "T";
public static final String GPS_DISTANCE_KILOMETERS = "K";
public static final String GPS_DISTANCE_MILES = "M";
public static final String GPS_DISTANCE_NAUTICAL_MILES = "N";
public static final String GPS_MEASUREMENT_2D = "2";
public static final String GPS_MEASUREMENT_3D = "3";
public static final short GPS_MEASUREMENT_DIFFERENTIAL_CORRECTED = 1;
public static final String GPS_MEASUREMENT_INTERRUPTED = "V";
public static final String GPS_MEASUREMENT_IN_PROGRESS = "A";
public static final short GPS_MEASUREMENT_NO_DIFFERENTIAL = 0;
public static final String GPS_SPEED_KILOMETERS_PER_HOUR = "K";
public static final String GPS_SPEED_KNOTS = "N";
public static final String GPS_SPEED_MILES_PER_HOUR = "M";
private static final Pattern GPS_TIMESTAMP_PATTERN;
public static final byte[] IDENTIFIER_EXIF_APP1;
private static final byte[] IDENTIFIER_XMP_APP1;
private static final ExifTag[] IFD_EXIF_TAGS;
private static final int IFD_FORMAT_BYTE = 1;
private static final int IFD_FORMAT_DOUBLE = 12;
private static final int IFD_FORMAT_IFD = 13;
private static final int IFD_FORMAT_SBYTE = 6;
private static final int IFD_FORMAT_SINGLE = 11;
private static final int IFD_FORMAT_SLONG = 9;
private static final int IFD_FORMAT_SRATIONAL = 10;
private static final int IFD_FORMAT_SSHORT = 8;
private static final int IFD_FORMAT_STRING = 2;
private static final int IFD_FORMAT_ULONG = 4;
private static final int IFD_FORMAT_UNDEFINED = 7;
private static final int IFD_FORMAT_URATIONAL = 5;
private static final int IFD_FORMAT_USHORT = 3;
private static final ExifTag[] IFD_GPS_TAGS;
private static final ExifTag[] IFD_INTEROPERABILITY_TAGS;
private static final int IFD_OFFSET = 8;
private static final ExifTag[] IFD_THUMBNAIL_TAGS;
private static final ExifTag[] IFD_TIFF_TAGS;
private static final int IFD_TYPE_EXIF = 1;
private static final int IFD_TYPE_GPS = 2;
private static final int IFD_TYPE_INTEROPERABILITY = 3;
private static final int IFD_TYPE_ORF_CAMERA_SETTINGS = 7;
private static final int IFD_TYPE_ORF_IMAGE_PROCESSING = 8;
private static final int IFD_TYPE_ORF_MAKER_NOTE = 6;
private static final int IFD_TYPE_PEF = 9;
public static final int IFD_TYPE_PREVIEW = 5;
public static final int IFD_TYPE_PRIMARY = 0;
public static final int IFD_TYPE_THUMBNAIL = 4;
private static final int IMAGE_TYPE_ARW = 1;
private static final int IMAGE_TYPE_CR2 = 2;
private static final int IMAGE_TYPE_DNG = 3;
private static final int IMAGE_TYPE_HEIF = 12;
private static final int IMAGE_TYPE_JPEG = 4;
private static final int IMAGE_TYPE_NEF = 5;
private static final int IMAGE_TYPE_NRW = 6;
private static final int IMAGE_TYPE_ORF = 7;
private static final int IMAGE_TYPE_PEF = 8;
private static final int IMAGE_TYPE_PNG = 13;
private static final int IMAGE_TYPE_RAF = 9;
private static final int IMAGE_TYPE_RW2 = 10;
private static final int IMAGE_TYPE_SRW = 11;
private static final int IMAGE_TYPE_UNKNOWN = 0;
private static final int IMAGE_TYPE_WEBP = 14;
private static final ExifTag JPEG_INTERCHANGE_FORMAT_LENGTH_TAG;
private static final ExifTag JPEG_INTERCHANGE_FORMAT_TAG;
public static final String LATITUDE_NORTH = "N";
public static final String LATITUDE_SOUTH = "S";
public static final short LIGHT_SOURCE_CLOUDY_WEATHER = 10;
public static final short LIGHT_SOURCE_COOL_WHITE_FLUORESCENT = 14;
public static final short LIGHT_SOURCE_D50 = 23;
public static final short LIGHT_SOURCE_D55 = 20;
public static final short LIGHT_SOURCE_D65 = 21;
public static final short LIGHT_SOURCE_D75 = 22;
public static final short LIGHT_SOURCE_DAYLIGHT = 1;
public static final short LIGHT_SOURCE_DAYLIGHT_FLUORESCENT = 12;
public static final short LIGHT_SOURCE_DAY_WHITE_FLUORESCENT = 13;
public static final short LIGHT_SOURCE_FINE_WEATHER = 9;
public static final short LIGHT_SOURCE_FLASH = 4;
public static final short LIGHT_SOURCE_FLUORESCENT = 2;
public static final short LIGHT_SOURCE_ISO_STUDIO_TUNGSTEN = 24;
public static final short LIGHT_SOURCE_OTHER = 255;
public static final short LIGHT_SOURCE_SHADE = 11;
public static final short LIGHT_SOURCE_STANDARD_LIGHT_A = 17;
public static final short LIGHT_SOURCE_STANDARD_LIGHT_B = 18;
public static final short LIGHT_SOURCE_STANDARD_LIGHT_C = 19;
public static final short LIGHT_SOURCE_TUNGSTEN = 3;
public static final short LIGHT_SOURCE_UNKNOWN = 0;
public static final short LIGHT_SOURCE_WARM_WHITE_FLUORESCENT = 16;
public static final short LIGHT_SOURCE_WHITE_FLUORESCENT = 15;
public static final String LONGITUDE_EAST = "E";
public static final String LONGITUDE_WEST = "W";
public static final byte MARKER = -1;
public static final byte MARKER_APP1 = -31;
private static final byte MARKER_COM = -2;
public static final byte MARKER_EOI = -39;
private static final byte MARKER_SOF0 = -64;
private static final byte MARKER_SOF1 = -63;
private static final byte MARKER_SOF10 = -54;
private static final byte MARKER_SOF11 = -53;
private static final byte MARKER_SOF13 = -51;
private static final byte MARKER_SOF14 = -50;
private static final byte MARKER_SOF15 = -49;
private static final byte MARKER_SOF2 = -62;
private static final byte MARKER_SOF3 = -61;
private static final byte MARKER_SOF5 = -59;
private static final byte MARKER_SOF6 = -58;
private static final byte MARKER_SOF7 = -57;
private static final byte MARKER_SOF9 = -55;
private static final byte MARKER_SOS = -38;
private static final int MAX_THUMBNAIL_SIZE = 512;
public static final short METERING_MODE_AVERAGE = 1;
public static final short METERING_MODE_CENTER_WEIGHT_AVERAGE = 2;
public static final short METERING_MODE_MULTI_SPOT = 4;
public static final short METERING_MODE_OTHER = 255;
public static final short METERING_MODE_PARTIAL = 6;
public static final short METERING_MODE_PATTERN = 5;
public static final short METERING_MODE_SPOT = 3;
public static final short METERING_MODE_UNKNOWN = 0;
private static final Pattern NON_ZERO_TIME_PATTERN;
private static final ExifTag[] ORF_CAMERA_SETTINGS_TAGS;
private static final ExifTag[] ORF_IMAGE_PROCESSING_TAGS;
private static final int ORF_MAKER_NOTE_HEADER_1_SIZE = 8;
private static final int ORF_MAKER_NOTE_HEADER_2_SIZE = 12;
private static final ExifTag[] ORF_MAKER_NOTE_TAGS;
private static final short ORF_SIGNATURE_1 = 20306;
private static final short ORF_SIGNATURE_2 = 21330;
public static final int ORIENTATION_FLIP_HORIZONTAL = 2;
public static final int ORIENTATION_FLIP_VERTICAL = 4;
public static final int ORIENTATION_NORMAL = 1;
public static final int ORIENTATION_ROTATE_180 = 3;
public static final int ORIENTATION_ROTATE_270 = 8;
public static final int ORIENTATION_ROTATE_90 = 6;
public static final int ORIENTATION_TRANSPOSE = 5;
public static final int ORIENTATION_TRANSVERSE = 7;
public static final int ORIENTATION_UNDEFINED = 0;
public static final int ORIGINAL_RESOLUTION_IMAGE = 0;
private static final int PEF_MAKER_NOTE_SKIP_SIZE = 6;
private static final String PEF_SIGNATURE = "PENTAX";
private static final ExifTag[] PEF_TAGS;
public static final int PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO = 1;
public static final int PHOTOMETRIC_INTERPRETATION_RGB = 2;
public static final int PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO = 0;
public static final int PHOTOMETRIC_INTERPRETATION_YCBCR = 6;
private static final int PNG_CHUNK_CRC_BYTE_LENGTH = 4;
private static final int PNG_CHUNK_TYPE_BYTE_LENGTH = 4;
private static final int RAF_OFFSET_TO_JPEG_IMAGE_OFFSET = 84;
private static final String RAF_SIGNATURE = "FUJIFILMCCD-RAW";
public static final int REDUCED_RESOLUTION_IMAGE = 1;
public static final short RENDERED_PROCESS_CUSTOM = 1;
public static final short RENDERED_PROCESS_NORMAL = 0;
public static final short RESOLUTION_UNIT_CENTIMETERS = 3;
public static final short RESOLUTION_UNIT_INCHES = 2;
private static final short RW2_SIGNATURE = 85;
public static final short SATURATION_HIGH = 0;
public static final short SATURATION_LOW = 0;
public static final short SATURATION_NORMAL = 0;
public static final short SCENE_CAPTURE_TYPE_LANDSCAPE = 1;
public static final short SCENE_CAPTURE_TYPE_NIGHT = 3;
public static final short SCENE_CAPTURE_TYPE_PORTRAIT = 2;
public static final short SCENE_CAPTURE_TYPE_STANDARD = 0;
public static final short SCENE_TYPE_DIRECTLY_PHOTOGRAPHED = 1;
public static final short SENSITIVITY_TYPE_ISO_SPEED = 3;
public static final short SENSITIVITY_TYPE_REI = 2;
public static final short SENSITIVITY_TYPE_REI_AND_ISO = 6;
public static final short SENSITIVITY_TYPE_SOS = 1;
public static final short SENSITIVITY_TYPE_SOS_AND_ISO = 5;
public static final short SENSITIVITY_TYPE_SOS_AND_REI = 4;
public static final short SENSITIVITY_TYPE_SOS_AND_REI_AND_ISO = 7;
public static final short SENSITIVITY_TYPE_UNKNOWN = 0;
public static final short SENSOR_TYPE_COLOR_SEQUENTIAL = 5;
public static final short SENSOR_TYPE_COLOR_SEQUENTIAL_LINEAR = 8;
public static final short SENSOR_TYPE_NOT_DEFINED = 1;
public static final short SENSOR_TYPE_ONE_CHIP = 2;
public static final short SENSOR_TYPE_THREE_CHIP = 4;
public static final short SENSOR_TYPE_TRILINEAR = 7;
public static final short SENSOR_TYPE_TWO_CHIP = 3;
public static final short SHARPNESS_HARD = 2;
public static final short SHARPNESS_NORMAL = 0;
public static final short SHARPNESS_SOFT = 1;
private static final int SIGNATURE_CHECK_SIZE = 5000;
public static final byte START_CODE = 42;
public static final int STREAM_TYPE_EXIF_DATA_ONLY = 1;
public static final int STREAM_TYPE_FULL_IMAGE_DATA = 0;
public static final short SUBJECT_DISTANCE_RANGE_CLOSE_VIEW = 2;
public static final short SUBJECT_DISTANCE_RANGE_DISTANT_VIEW = 3;
public static final short SUBJECT_DISTANCE_RANGE_MACRO = 1;
public static final short SUBJECT_DISTANCE_RANGE_UNKNOWN = 0;
public static final String TAG_APERTURE_VALUE = "ApertureValue";
public static final String TAG_ARTIST = "Artist";
public static final String TAG_BITS_PER_SAMPLE = "BitsPerSample";
public static final String TAG_BODY_SERIAL_NUMBER = "BodySerialNumber";
public static final String TAG_BRIGHTNESS_VALUE = "BrightnessValue";
@Deprecated
public static final String TAG_CAMARA_OWNER_NAME = "CameraOwnerName";
public static final String TAG_CAMERA_OWNER_NAME = "CameraOwnerName";
public static final String TAG_CFA_PATTERN = "CFAPattern";
public static final String TAG_COLOR_SPACE = "ColorSpace";
public static final String TAG_COMPONENTS_CONFIGURATION = "ComponentsConfiguration";
public static final String TAG_COMPRESSED_BITS_PER_PIXEL = "CompressedBitsPerPixel";
public static final String TAG_COMPRESSION = "Compression";
public static final String TAG_CONTRAST = "Contrast";
public static final String TAG_COPYRIGHT = "Copyright";
public static final String TAG_CUSTOM_RENDERED = "CustomRendered";
public static final String TAG_DATETIME = "DateTime";
public static final String TAG_DATETIME_DIGITIZED = "DateTimeDigitized";
public static final String TAG_DATETIME_ORIGINAL = "DateTimeOriginal";
public static final String TAG_DEFAULT_CROP_SIZE = "DefaultCropSize";
public static final String TAG_DEVICE_SETTING_DESCRIPTION = "DeviceSettingDescription";
public static final String TAG_DIGITAL_ZOOM_RATIO = "DigitalZoomRatio";
public static final String TAG_DNG_VERSION = "DNGVersion";
private static final String TAG_EXIF_IFD_POINTER = "ExifIFDPointer";
public static final String TAG_EXIF_VERSION = "ExifVersion";
public static final String TAG_EXPOSURE_BIAS_VALUE = "ExposureBiasValue";
public static final String TAG_EXPOSURE_INDEX = "ExposureIndex";
public static final String TAG_EXPOSURE_MODE = "ExposureMode";
public static final String TAG_EXPOSURE_PROGRAM = "ExposureProgram";
public static final String TAG_EXPOSURE_TIME = "ExposureTime";
public static final String TAG_FILE_SOURCE = "FileSource";
public static final String TAG_FLASH = "Flash";
public static final String TAG_FLASHPIX_VERSION = "FlashpixVersion";
public static final String TAG_FLASH_ENERGY = "FlashEnergy";
public static final String TAG_FOCAL_LENGTH = "FocalLength";
public static final String TAG_FOCAL_LENGTH_IN_35MM_FILM = "FocalLengthIn35mmFilm";
public static final String TAG_FOCAL_PLANE_RESOLUTION_UNIT = "FocalPlaneResolutionUnit";
public static final String TAG_FOCAL_PLANE_X_RESOLUTION = "FocalPlaneXResolution";
public static final String TAG_FOCAL_PLANE_Y_RESOLUTION = "FocalPlaneYResolution";
public static final String TAG_F_NUMBER = "FNumber";
public static final String TAG_GAIN_CONTROL = "GainControl";
public static final String TAG_GAMMA = "Gamma";
public static final String TAG_GPS_ALTITUDE = "GPSAltitude";
public static final String TAG_GPS_ALTITUDE_REF = "GPSAltitudeRef";
public static final String TAG_GPS_AREA_INFORMATION = "GPSAreaInformation";
public static final String TAG_GPS_DATESTAMP = "GPSDateStamp";
public static final String TAG_GPS_DEST_BEARING = "GPSDestBearing";
public static final String TAG_GPS_DEST_BEARING_REF = "GPSDestBearingRef";
public static final String TAG_GPS_DEST_DISTANCE = "GPSDestDistance";
public static final String TAG_GPS_DEST_DISTANCE_REF = "GPSDestDistanceRef";
public static final String TAG_GPS_DEST_LATITUDE = "GPSDestLatitude";
public static final String TAG_GPS_DEST_LATITUDE_REF = "GPSDestLatitudeRef";
public static final String TAG_GPS_DEST_LONGITUDE = "GPSDestLongitude";
public static final String TAG_GPS_DEST_LONGITUDE_REF = "GPSDestLongitudeRef";
public static final String TAG_GPS_DIFFERENTIAL = "GPSDifferential";
public static final String TAG_GPS_DOP = "GPSDOP";
public static final String TAG_GPS_H_POSITIONING_ERROR = "GPSHPositioningError";
public static final String TAG_GPS_IMG_DIRECTION = "GPSImgDirection";
public static final String TAG_GPS_IMG_DIRECTION_REF = "GPSImgDirectionRef";
private static final String TAG_GPS_INFO_IFD_POINTER = "GPSInfoIFDPointer";
public static final String TAG_GPS_LATITUDE = "GPSLatitude";
public static final String TAG_GPS_LATITUDE_REF = "GPSLatitudeRef";
public static final String TAG_GPS_LONGITUDE = "GPSLongitude";
public static final String TAG_GPS_LONGITUDE_REF = "GPSLongitudeRef";
public static final String TAG_GPS_MAP_DATUM = "GPSMapDatum";
public static final String TAG_GPS_MEASURE_MODE = "GPSMeasureMode";
public static final String TAG_GPS_PROCESSING_METHOD = "GPSProcessingMethod";
public static final String TAG_GPS_SATELLITES = "GPSSatellites";
public static final String TAG_GPS_SPEED = "GPSSpeed";
public static final String TAG_GPS_SPEED_REF = "GPSSpeedRef";
public static final String TAG_GPS_STATUS = "GPSStatus";
public static final String TAG_GPS_TIMESTAMP = "GPSTimeStamp";
public static final String TAG_GPS_TRACK = "GPSTrack";
public static final String TAG_GPS_TRACK_REF = "GPSTrackRef";
public static final String TAG_GPS_VERSION_ID = "GPSVersionID";
public static final String TAG_IMAGE_DESCRIPTION = "ImageDescription";
public static final String TAG_IMAGE_LENGTH = "ImageLength";
public static final String TAG_IMAGE_UNIQUE_ID = "ImageUniqueID";
public static final String TAG_IMAGE_WIDTH = "ImageWidth";
private static final String TAG_INTEROPERABILITY_IFD_POINTER = "InteroperabilityIFDPointer";
public static final String TAG_INTEROPERABILITY_INDEX = "InteroperabilityIndex";
public static final String TAG_ISO_SPEED = "ISOSpeed";
public static final String TAG_ISO_SPEED_LATITUDE_YYY = "ISOSpeedLatitudeyyy";
public static final String TAG_ISO_SPEED_LATITUDE_ZZZ = "ISOSpeedLatitudezzz";
@Deprecated
public static final String TAG_ISO_SPEED_RATINGS = "ISOSpeedRatings";
public static final String TAG_JPEG_INTERCHANGE_FORMAT = "JPEGInterchangeFormat";
public static final String TAG_JPEG_INTERCHANGE_FORMAT_LENGTH = "JPEGInterchangeFormatLength";
public static final String TAG_LENS_MAKE = "LensMake";
public static final String TAG_LENS_MODEL = "LensModel";
public static final String TAG_LENS_SERIAL_NUMBER = "LensSerialNumber";
public static final String TAG_LENS_SPECIFICATION = "LensSpecification";
public static final String TAG_LIGHT_SOURCE = "LightSource";
public static final String TAG_MAKE = "Make";
public static final String TAG_MAKER_NOTE = "MakerNote";
public static final String TAG_MAX_APERTURE_VALUE = "MaxApertureValue";
public static final String TAG_METERING_MODE = "MeteringMode";
public static final String TAG_MODEL = "Model";
public static final String TAG_NEW_SUBFILE_TYPE = "NewSubfileType";
public static final String TAG_OECF = "OECF";
public static final String TAG_OFFSET_TIME = "OffsetTime";
public static final String TAG_OFFSET_TIME_DIGITIZED = "OffsetTimeDigitized";
public static final String TAG_OFFSET_TIME_ORIGINAL = "OffsetTimeOriginal";
public static final String TAG_ORF_ASPECT_FRAME = "AspectFrame";
private static final String TAG_ORF_CAMERA_SETTINGS_IFD_POINTER = "CameraSettingsIFDPointer";
private static final String TAG_ORF_IMAGE_PROCESSING_IFD_POINTER = "ImageProcessingIFDPointer";
public static final String TAG_ORF_PREVIEW_IMAGE_LENGTH = "PreviewImageLength";
public static final String TAG_ORF_PREVIEW_IMAGE_START = "PreviewImageStart";
public static final String TAG_ORF_THUMBNAIL_IMAGE = "ThumbnailImage";
public static final String TAG_ORIENTATION = "Orientation";
public static final String TAG_PHOTOGRAPHIC_SENSITIVITY = "PhotographicSensitivity";
public static final String TAG_PHOTOMETRIC_INTERPRETATION = "PhotometricInterpretation";
public static final String TAG_PIXEL_X_DIMENSION = "PixelXDimension";
public static final String TAG_PIXEL_Y_DIMENSION = "PixelYDimension";
public static final String TAG_PLANAR_CONFIGURATION = "PlanarConfiguration";
public static final String TAG_PRIMARY_CHROMATICITIES = "PrimaryChromaticities";
private static final ExifTag TAG_RAF_IMAGE_SIZE;
public static final String TAG_RECOMMENDED_EXPOSURE_INDEX = "RecommendedExposureIndex";
public static final String TAG_REFERENCE_BLACK_WHITE = "ReferenceBlackWhite";
public static final String TAG_RELATED_SOUND_FILE = "RelatedSoundFile";
public static final String TAG_RESOLUTION_UNIT = "ResolutionUnit";
public static final String TAG_ROWS_PER_STRIP = "RowsPerStrip";
public static final String TAG_RW2_ISO = "ISO";
public static final String TAG_RW2_JPG_FROM_RAW = "JpgFromRaw";
public static final String TAG_RW2_SENSOR_BOTTOM_BORDER = "SensorBottomBorder";
public static final String TAG_RW2_SENSOR_LEFT_BORDER = "SensorLeftBorder";
public static final String TAG_RW2_SENSOR_RIGHT_BORDER = "SensorRightBorder";
public static final String TAG_RW2_SENSOR_TOP_BORDER = "SensorTopBorder";
public static final String TAG_SAMPLES_PER_PIXEL = "SamplesPerPixel";
public static final String TAG_SATURATION = "Saturation";
public static final String TAG_SCENE_CAPTURE_TYPE = "SceneCaptureType";
public static final String TAG_SCENE_TYPE = "SceneType";
public static final String TAG_SENSING_METHOD = "SensingMethod";
public static final String TAG_SENSITIVITY_TYPE = "SensitivityType";
public static final String TAG_SHARPNESS = "Sharpness";
public static final String TAG_SHUTTER_SPEED_VALUE = "ShutterSpeedValue";
public static final String TAG_SOFTWARE = "Software";
public static final String TAG_SPATIAL_FREQUENCY_RESPONSE = "SpatialFrequencyResponse";
public static final String TAG_SPECTRAL_SENSITIVITY = "SpectralSensitivity";
public static final String TAG_STANDARD_OUTPUT_SENSITIVITY = "StandardOutputSensitivity";
public static final String TAG_STRIP_BYTE_COUNTS = "StripByteCounts";
public static final String TAG_STRIP_OFFSETS = "StripOffsets";
public static final String TAG_SUBFILE_TYPE = "SubfileType";
public static final String TAG_SUBJECT_AREA = "SubjectArea";
public static final String TAG_SUBJECT_DISTANCE = "SubjectDistance";
public static final String TAG_SUBJECT_DISTANCE_RANGE = "SubjectDistanceRange";
public static final String TAG_SUBJECT_LOCATION = "SubjectLocation";
public static final String TAG_SUBSEC_TIME = "SubSecTime";
public static final String TAG_SUBSEC_TIME_DIGITIZED = "SubSecTimeDigitized";
public static final String TAG_SUBSEC_TIME_ORIGINAL = "SubSecTimeOriginal";
private static final String TAG_SUB_IFD_POINTER = "SubIFDPointer";
public static final String TAG_THUMBNAIL_IMAGE_LENGTH = "ThumbnailImageLength";
public static final String TAG_THUMBNAIL_IMAGE_WIDTH = "ThumbnailImageWidth";
public static final String TAG_THUMBNAIL_ORIENTATION = "ThumbnailOrientation";
public static final String TAG_TRANSFER_FUNCTION = "TransferFunction";
public static final String TAG_USER_COMMENT = "UserComment";
public static final String TAG_WHITE_BALANCE = "WhiteBalance";
public static final String TAG_WHITE_POINT = "WhitePoint";
public static final String TAG_XMP = "Xmp";
public static final String TAG_X_RESOLUTION = "XResolution";
public static final String TAG_Y_CB_CR_COEFFICIENTS = "YCbCrCoefficients";
public static final String TAG_Y_CB_CR_POSITIONING = "YCbCrPositioning";
public static final String TAG_Y_CB_CR_SUB_SAMPLING = "YCbCrSubSampling";
public static final String TAG_Y_RESOLUTION = "YResolution";
private static final int WEBP_CHUNK_SIZE_BYTE_LENGTH = 4;
private static final int WEBP_CHUNK_TYPE_BYTE_LENGTH = 4;
private static final int WEBP_CHUNK_TYPE_VP8X_DEFAULT_LENGTH = 10;
private static final int WEBP_FILE_SIZE_BYTE_LENGTH = 4;
private static final byte WEBP_VP8L_SIGNATURE = 47;
@Deprecated
public static final int WHITEBALANCE_AUTO = 0;
@Deprecated
public static final int WHITEBALANCE_MANUAL = 1;
public static final short WHITE_BALANCE_AUTO = 0;
public static final short WHITE_BALANCE_MANUAL = 1;
public static final short Y_CB_CR_POSITIONING_CENTERED = 1;
public static final short Y_CB_CR_POSITIONING_CO_SITED = 2;
private static final HashMap<Integer, Integer> sExifPointerTagMap;
private static final HashMap<Integer, ExifTag>[] sExifTagMapsForReading;
private static final HashMap<String, ExifTag>[] sExifTagMapsForWriting;
private static SimpleDateFormat sFormatterPrimary;
private static SimpleDateFormat sFormatterSecondary;
private static final HashSet<String> sTagSetForCompatibility;
private boolean mAreThumbnailStripsConsecutive;
private AssetManager.AssetInputStream mAssetInputStream;
private final HashMap<String, ExifAttribute>[] mAttributes;
private Set<Integer> mAttributesOffsets;
private ByteOrder mExifByteOrder;
private String mFilename;
private boolean mHasThumbnail;
private boolean mHasThumbnailStrips;
private boolean mIsExifDataOnly;
private int mMimeType;
private boolean mModified;
private int mOffsetToExifData;
private int mOrfMakerNoteOffset;
private int mOrfThumbnailLength;
private int mOrfThumbnailOffset;
private FileDescriptor mSeekableFileDescriptor;
private byte[] mThumbnailBytes;
private int mThumbnailCompression;
private int mThumbnailLength;
private int mThumbnailOffset;
private boolean mXmpIsFromSeparateMarker;
private static final String TAG = "ExifInterface";
private static final boolean DEBUG = Log.isLoggable(TAG, 3);
private static final List<Integer> ROTATION_ORDER = Arrays.asList(1, 6, 3, 8);
private static final List<Integer> FLIPPED_ROTATION_ORDER = Arrays.asList(2, 7, 4, 5);
public static final int[] BITS_PER_SAMPLE_RGB = {8, 8, 8};
public static final int[] BITS_PER_SAMPLE_GREYSCALE_1 = {4};
public static final int[] BITS_PER_SAMPLE_GREYSCALE_2 = {8};
private static final byte MARKER_SOI = -40;
public static final byte[] JPEG_SIGNATURE = {-1, MARKER_SOI, -1};
private static final byte[] HEIF_TYPE_FTYP = {102, 116, 121, 112};
private static final byte[] HEIF_BRAND_MIF1 = {109, 105, 102, 49};
private static final byte[] HEIF_BRAND_HEIC = {104, 101, 105, 99};
private static final byte[] ORF_MAKER_NOTE_HEADER_1 = {79, 76, 89, 77, 80, 0};
private static final byte[] ORF_MAKER_NOTE_HEADER_2 = {79, 76, 89, 77, 80, 85, 83, 0, 73, 73};
private static final byte[] PNG_SIGNATURE = {-119, 80, 78, 71, Ascii.CR, 10, Ascii.SUB, 10};
private static final byte[] PNG_CHUNK_TYPE_EXIF = {101, 88, 73, 102};
private static final byte[] PNG_CHUNK_TYPE_IHDR = {73, 72, 68, 82};
private static final byte[] PNG_CHUNK_TYPE_IEND = {73, 69, 78, 68};
private static final byte[] WEBP_SIGNATURE_1 = {82, 73, 70, 70};
private static final byte[] WEBP_SIGNATURE_2 = {87, 69, 66, 80};
private static final byte[] WEBP_CHUNK_TYPE_EXIF = {69, 88, 73, 70};
private static final byte[] WEBP_VP8_SIGNATURE = {-99, 1, 42};
private static final byte[] WEBP_CHUNK_TYPE_VP8X = "VP8X".getBytes(Charset.defaultCharset());
private static final byte[] WEBP_CHUNK_TYPE_VP8L = "VP8L".getBytes(Charset.defaultCharset());
private static final byte[] WEBP_CHUNK_TYPE_VP8 = "VP8 ".getBytes(Charset.defaultCharset());
private static final byte[] WEBP_CHUNK_TYPE_ANIM = "ANIM".getBytes(Charset.defaultCharset());
private static final byte[] WEBP_CHUNK_TYPE_ANMF = "ANMF".getBytes(Charset.defaultCharset());
public static final String[] IFD_FORMAT_NAMES = {"", "BYTE", "STRING", "USHORT", "ULONG", "URATIONAL", "SBYTE", "UNDEFINED", "SSHORT", "SLONG", "SRATIONAL", ExerciseRecorder.EXE_FROM_SINGLE, "DOUBLE", "IFD"};
public static final int[] IFD_FORMAT_BYTES_PER_FORMAT = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 1};
public static final byte[] EXIF_ASCII_PREFIX = {65, 83, 67, 73, 73, 0, 0, 0};
public static class ByteOrderedDataInputStream extends InputStream implements DataInput {
private ByteOrder mByteOrder;
private DataInputStream mDataInputStream;
public final int mLength;
public int mPosition;
private static final ByteOrder LITTLE_ENDIAN = ByteOrder.LITTLE_ENDIAN;
private static final ByteOrder BIG_ENDIAN = ByteOrder.BIG_ENDIAN;
public ByteOrderedDataInputStream(InputStream inputStream) throws IOException {
this(inputStream, ByteOrder.BIG_ENDIAN);
}
@Override
public int available() throws IOException {
return this.mDataInputStream.available();
}
public int getLength() {
return this.mLength;
}
@Override
public synchronized void mark(int i2) {
this.mDataInputStream.mark(i2);
}
public int peek() {
return this.mPosition;
}
@Override
public int read() throws IOException {
this.mPosition++;
return this.mDataInputStream.read();
}
@Override
public boolean readBoolean() throws IOException {
this.mPosition++;
return this.mDataInputStream.readBoolean();
}
@Override
public byte readByte() throws IOException {
int i2 = this.mPosition + 1;
this.mPosition = i2;
if (i2 <= this.mLength) {
int read = this.mDataInputStream.read();
if (read >= 0) {
return (byte) read;
}
throw new EOFException();
}
throw new EOFException();
}
@Override
public char readChar() throws IOException {
this.mPosition += 2;
return this.mDataInputStream.readChar();
}
@Override
public double readDouble() throws IOException {
return Double.longBitsToDouble(readLong());
}
@Override
public float readFloat() throws IOException {
return Float.intBitsToFloat(readInt());
}
@Override
public void readFully(byte[] bArr, int i2, int i3) throws IOException {
int i4 = this.mPosition + i3;
this.mPosition = i4;
if (i4 <= this.mLength) {
if (this.mDataInputStream.read(bArr, i2, i3) != i3) {
throw new IOException("Couldn't read up to the length of buffer");
}
return;
}
throw new EOFException();
}
@Override
public int readInt() throws IOException {
int i2 = this.mPosition + 4;
this.mPosition = i2;
if (i2 <= this.mLength) {
int read = this.mDataInputStream.read();
int read2 = this.mDataInputStream.read();
int read3 = this.mDataInputStream.read();
int read4 = this.mDataInputStream.read();
if ((read | read2 | read3 | read4) >= 0) {
ByteOrder byteOrder = this.mByteOrder;
if (byteOrder == LITTLE_ENDIAN) {
return (read4 << 24) + (read3 << 16) + (read2 << 8) + read;
}
if (byteOrder == BIG_ENDIAN) {
return (read << 24) + (read2 << 16) + (read3 << 8) + read4;
}
throw new IOException("Invalid byte order: " + this.mByteOrder);
}
throw new EOFException();
}
throw new EOFException();
}
@Override
public String readLine() throws IOException {
Log.d(ExifInterface.TAG, "Currently unsupported");
return null;
}
@Override
public long readLong() throws IOException {
int i2 = this.mPosition + 8;
this.mPosition = i2;
if (i2 <= this.mLength) {
int read = this.mDataInputStream.read();
int read2 = this.mDataInputStream.read();
int read3 = this.mDataInputStream.read();
int read4 = this.mDataInputStream.read();
int read5 = this.mDataInputStream.read();
int read6 = this.mDataInputStream.read();
int read7 = this.mDataInputStream.read();
int read8 = this.mDataInputStream.read();
if ((read | read2 | read3 | read4 | read5 | read6 | read7 | read8) >= 0) {
ByteOrder byteOrder = this.mByteOrder;
if (byteOrder == LITTLE_ENDIAN) {
return (read8 << 56) + (read7 << 48) + (read6 << 40) + (read5 << 32) + (read4 << 24) + (read3 << 16) + (read2 << 8) + read;
}
if (byteOrder == BIG_ENDIAN) {
return (read << 56) + (read2 << 48) + (read3 << 40) + (read4 << 32) + (read5 << 24) + (read6 << 16) + (read7 << 8) + read8;
}
throw new IOException("Invalid byte order: " + this.mByteOrder);
}
throw new EOFException();
}
throw new EOFException();
}
@Override
public short readShort() throws IOException {
int i2 = this.mPosition + 2;
this.mPosition = i2;
if (i2 <= this.mLength) {
int read = this.mDataInputStream.read();
int read2 = this.mDataInputStream.read();
if ((read | read2) >= 0) {
ByteOrder byteOrder = this.mByteOrder;
if (byteOrder == LITTLE_ENDIAN) {
return (short) ((read2 << 8) + read);
}
if (byteOrder == BIG_ENDIAN) {
return (short) ((read << 8) + read2);
}
throw new IOException("Invalid byte order: " + this.mByteOrder);
}
throw new EOFException();
}
throw new EOFException();
}
@Override
public String readUTF() throws IOException {
this.mPosition += 2;
return this.mDataInputStream.readUTF();
}
@Override
public int readUnsignedByte() throws IOException {
this.mPosition++;
return this.mDataInputStream.readUnsignedByte();
}
public long readUnsignedInt() throws IOException {
return readInt() & UnsignedInts.INT_MASK;
}
@Override
public int readUnsignedShort() throws IOException {
int i2 = this.mPosition + 2;
this.mPosition = i2;
if (i2 <= this.mLength) {
int read = this.mDataInputStream.read();
int read2 = this.mDataInputStream.read();
if ((read | read2) >= 0) {
ByteOrder byteOrder = this.mByteOrder;
if (byteOrder == LITTLE_ENDIAN) {
return (read2 << 8) + read;
}
if (byteOrder == BIG_ENDIAN) {
return (read << 8) + read2;
}
throw new IOException("Invalid byte order: " + this.mByteOrder);
}
throw new EOFException();
}
throw new EOFException();
}
public void seek(long j2) throws IOException {
long j3 = this.mPosition;
if (j3 > j2) {
this.mPosition = 0;
this.mDataInputStream.reset();
this.mDataInputStream.mark(this.mLength);
} else {
j2 -= j3;
}
int i2 = (int) j2;
if (skipBytes(i2) != i2) {
throw new IOException("Couldn't seek up to the byteCount");
}
}
public void setByteOrder(ByteOrder byteOrder) {
this.mByteOrder = byteOrder;
}
@Override
public int skipBytes(int i2) throws IOException {
int min = Math.min(i2, this.mLength - this.mPosition);
int i3 = 0;
while (i3 < min) {
i3 += this.mDataInputStream.skipBytes(min - i3);
}
this.mPosition += i3;
return i3;
}
public ByteOrderedDataInputStream(InputStream inputStream, ByteOrder byteOrder) throws IOException {
this.mByteOrder = ByteOrder.BIG_ENDIAN;
DataInputStream dataInputStream = new DataInputStream(inputStream);
this.mDataInputStream = dataInputStream;
int available = dataInputStream.available();
this.mLength = available;
this.mPosition = 0;
this.mDataInputStream.mark(available);
this.mByteOrder = byteOrder;
}
@Override
public int read(byte[] bArr, int i2, int i3) throws IOException {
int read = this.mDataInputStream.read(bArr, i2, i3);
this.mPosition += read;
return read;
}
@Override
public void readFully(byte[] bArr) throws IOException {
int length = this.mPosition + bArr.length;
this.mPosition = length;
if (length <= this.mLength) {
if (this.mDataInputStream.read(bArr, 0, bArr.length) != bArr.length) {
throw new IOException("Couldn't read up to the length of buffer");
}
return;
}
throw new EOFException();
}
public ByteOrderedDataInputStream(byte[] bArr) throws IOException {
this(new ByteArrayInputStream(bArr));
}
}
public static class ByteOrderedDataOutputStream extends FilterOutputStream {
private ByteOrder mByteOrder;
public final OutputStream mOutputStream;
public ByteOrderedDataOutputStream(OutputStream outputStream, ByteOrder byteOrder) {
super(outputStream);
this.mOutputStream = outputStream;
this.mByteOrder = byteOrder;
}
public void setByteOrder(ByteOrder byteOrder) {
this.mByteOrder = byteOrder;
}
@Override
public void write(byte[] bArr) throws IOException {
this.mOutputStream.write(bArr);
}
public void writeByte(int i2) throws IOException {
this.mOutputStream.write(i2);
}
public void writeInt(int i2) throws IOException {
ByteOrder byteOrder = this.mByteOrder;
if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
this.mOutputStream.write((i2 >>> 0) & 255);
this.mOutputStream.write((i2 >>> 8) & 255);
this.mOutputStream.write((i2 >>> 16) & 255);
this.mOutputStream.write((i2 >>> 24) & 255);
} else if (byteOrder == ByteOrder.BIG_ENDIAN) {
this.mOutputStream.write((i2 >>> 24) & 255);
this.mOutputStream.write((i2 >>> 16) & 255);
this.mOutputStream.write((i2 >>> 8) & 255);
this.mOutputStream.write((i2 >>> 0) & 255);
}
}
public void writeShort(short s) throws IOException {
ByteOrder byteOrder = this.mByteOrder;
if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
this.mOutputStream.write((s >>> 0) & 255);
this.mOutputStream.write((s >>> 8) & 255);
} else if (byteOrder == ByteOrder.BIG_ENDIAN) {
this.mOutputStream.write((s >>> 8) & 255);
this.mOutputStream.write((s >>> 0) & 255);
}
}
public void writeUnsignedInt(long j2) throws IOException {
writeInt((int) j2);
}
public void writeUnsignedShort(int i2) throws IOException {
writeShort((short) i2);
}
@Override
public void write(byte[] bArr, int i2, int i3) throws IOException {
this.mOutputStream.write(bArr, i2, i3);
}
}
public static class ExifAttribute {
public static final long BYTES_OFFSET_UNKNOWN = -1;
public final byte[] bytes;
public final long bytesOffset;
public final int format;
public final int numberOfComponents;
public ExifAttribute(int i2, int i3, byte[] bArr) {
this(i2, i3, -1L, bArr);
}
public static ExifAttribute createByte(String str) {
if (str.length() == 1 && str.charAt(0) >= '0' && str.charAt(0) <= '1') {
return new ExifAttribute(1, 1, new byte[]{(byte) (str.charAt(0) - '0')});
}
byte[] bytes = str.getBytes(ExifInterface.ASCII);
return new ExifAttribute(1, bytes.length, bytes);
}
public static ExifAttribute createDouble(double[] dArr, ByteOrder byteOrder) {
ByteBuffer wrap = ByteBuffer.wrap(new byte[ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[12] * dArr.length]);
wrap.order(byteOrder);
for (double d2 : dArr) {
wrap.putDouble(d2);
}
return new ExifAttribute(12, dArr.length, wrap.array());
}
public static ExifAttribute createSLong(int[] iArr, ByteOrder byteOrder) {
ByteBuffer wrap = ByteBuffer.wrap(new byte[ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[9] * iArr.length]);
wrap.order(byteOrder);
for (int i2 : iArr) {
wrap.putInt(i2);
}
return new ExifAttribute(9, iArr.length, wrap.array());
}
public static ExifAttribute createSRational(Rational[] rationalArr, ByteOrder byteOrder) {
ByteBuffer wrap = ByteBuffer.wrap(new byte[ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[10] * rationalArr.length]);
wrap.order(byteOrder);
for (Rational rational : rationalArr) {
wrap.putInt((int) rational.numerator);
wrap.putInt((int) rational.denominator);
}
return new ExifAttribute(10, rationalArr.length, wrap.array());
}
public static ExifAttribute createString(String str) {
byte[] bytes = (str + (char) 0).getBytes(ExifInterface.ASCII);
return new ExifAttribute(2, bytes.length, bytes);
}
public static ExifAttribute createULong(long[] jArr, ByteOrder byteOrder) {
ByteBuffer wrap = ByteBuffer.wrap(new byte[ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[4] * jArr.length]);
wrap.order(byteOrder);
for (long j2 : jArr) {
wrap.putInt((int) j2);
}
return new ExifAttribute(4, jArr.length, wrap.array());
}
public static ExifAttribute createURational(Rational[] rationalArr, ByteOrder byteOrder) {
ByteBuffer wrap = ByteBuffer.wrap(new byte[ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[5] * rationalArr.length]);
wrap.order(byteOrder);
for (Rational rational : rationalArr) {
wrap.putInt((int) rational.numerator);
wrap.putInt((int) rational.denominator);
}
return new ExifAttribute(5, rationalArr.length, wrap.array());
}
public static ExifAttribute createUShort(int[] iArr, ByteOrder byteOrder) {
ByteBuffer wrap = ByteBuffer.wrap(new byte[ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[3] * iArr.length]);
wrap.order(byteOrder);
for (int i2 : iArr) {
wrap.putShort((short) i2);
}
return new ExifAttribute(3, iArr.length, wrap.array());
}
public double getDoubleValue(ByteOrder byteOrder) {
Object value = getValue(byteOrder);
if (value != null) {
if (value instanceof String) {
return Double.parseDouble((String) value);
}
if (value instanceof long[]) {
long[] jArr = (long[]) value;
if (jArr.length == 1) {
return jArr[0];
}
throw new NumberFormatException("There are more than one component");
} else if (value instanceof int[]) {
int[] iArr = (int[]) value;
if (iArr.length == 1) {
return iArr[0];
}
throw new NumberFormatException("There are more than one component");
} else if (value instanceof double[]) {
double[] dArr = (double[]) value;
if (dArr.length == 1) {
return dArr[0];
}
throw new NumberFormatException("There are more than one component");
} else if (value instanceof Rational[]) {
Rational[] rationalArr = (Rational[]) value;
if (rationalArr.length == 1) {
return rationalArr[0].calculate();
}
throw new NumberFormatException("There are more than one component");
} else {
throw new NumberFormatException("Couldn't find a double value");
}
}
throw new NumberFormatException("NULL can't be converted to a double value");
}
public int getIntValue(ByteOrder byteOrder) {
Object value = getValue(byteOrder);
if (value != null) {
if (value instanceof String) {
return Integer.parseInt((String) value);
}
if (value instanceof long[]) {
long[] jArr = (long[]) value;
if (jArr.length == 1) {
return (int) jArr[0];
}
throw new NumberFormatException("There are more than one component");
} else if (value instanceof int[]) {
int[] iArr = (int[]) value;
if (iArr.length == 1) {
return iArr[0];
}
throw new NumberFormatException("There are more than one component");
} else {
throw new NumberFormatException("Couldn't find a integer value");
}
}
throw new NumberFormatException("NULL can't be converted to a integer value");
}
public String getStringValue(ByteOrder byteOrder) {
Object value = getValue(byteOrder);
if (value == null) {
return null;
}
if (value instanceof String) {
return (String) value;
}
StringBuilder sb = new StringBuilder();
int i2 = 0;
if (value instanceof long[]) {
long[] jArr = (long[]) value;
while (i2 < jArr.length) {
sb.append(jArr[i2]);
i2++;
if (i2 != jArr.length) {
sb.append(",");
}
}
return sb.toString();
} else if (value instanceof int[]) {
int[] iArr = (int[]) value;
while (i2 < iArr.length) {
sb.append(iArr[i2]);
i2++;
if (i2 != iArr.length) {
sb.append(",");
}
}
return sb.toString();
} else if (value instanceof double[]) {
double[] dArr = (double[]) value;
while (i2 < dArr.length) {
sb.append(dArr[i2]);
i2++;
if (i2 != dArr.length) {
sb.append(",");
}
}
return sb.toString();
} else if (value instanceof Rational[]) {
Rational[] rationalArr = (Rational[]) value;
while (i2 < rationalArr.length) {
sb.append(rationalArr[i2].numerator);
sb.append(IOUtils.DIR_SEPARATOR_UNIX);
sb.append(rationalArr[i2].denominator);
i2++;
if (i2 != rationalArr.length) {
sb.append(",");
}
}
return sb.toString();
} else {
return null;
}
}
public Object getValue(ByteOrder byteOrder) {
ByteOrderedDataInputStream byteOrderedDataInputStream;
InputStream inputStream;
byte b;
byte[] bArr;
InputStream inputStream2 = null;
try {
try {
byteOrderedDataInputStream = new ByteOrderedDataInputStream(this.bytes);
try {
byteOrderedDataInputStream.setByteOrder(byteOrder);
boolean z = true;
int i2 = 0;
switch (this.format) {
case 1:
case 6:
byte[] bArr2 = this.bytes;
if (bArr2.length == 1 && bArr2[0] >= 0 && bArr2[0] <= 1) {
String str = new String(new char[]{(char) (this.bytes[0] + 48)});
try {
byteOrderedDataInputStream.close();
} catch (IOException e2) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e2);
}
return str;
}
String str2 = new String(this.bytes, ExifInterface.ASCII);
try {
byteOrderedDataInputStream.close();
} catch (IOException e3) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e3);
}
return str2;
case 2:
case 7:
if (this.numberOfComponents >= ExifInterface.EXIF_ASCII_PREFIX.length) {
int i3 = 0;
while (true) {
bArr = ExifInterface.EXIF_ASCII_PREFIX;
if (i3 < bArr.length) {
if (this.bytes[i3] != bArr[i3]) {
z = false;
} else {
i3++;
}
}
}
if (z) {
i2 = bArr.length;
}
}
StringBuilder sb = new StringBuilder();
while (i2 < this.numberOfComponents && (b = this.bytes[i2]) != 0) {
if (b >= 32) {
sb.append((char) b);
} else {
sb.append(Operators.CONDITION_IF);
}
i2++;
}
String sb2 = sb.toString();
try {
byteOrderedDataInputStream.close();
} catch (IOException e4) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e4);
}
return sb2;
case 3:
int[] iArr = new int[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
iArr[i2] = byteOrderedDataInputStream.readUnsignedShort();
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e5) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e5);
}
return iArr;
case 4:
long[] jArr = new long[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
jArr[i2] = byteOrderedDataInputStream.readUnsignedInt();
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e6) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e6);
}
return jArr;
case 5:
Rational[] rationalArr = new Rational[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
rationalArr[i2] = new Rational(byteOrderedDataInputStream.readUnsignedInt(), byteOrderedDataInputStream.readUnsignedInt());
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e7) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e7);
}
return rationalArr;
case 8:
int[] iArr2 = new int[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
iArr2[i2] = byteOrderedDataInputStream.readShort();
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e8) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e8);
}
return iArr2;
case 9:
int[] iArr3 = new int[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
iArr3[i2] = byteOrderedDataInputStream.readInt();
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e9) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e9);
}
return iArr3;
case 10:
Rational[] rationalArr2 = new Rational[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
rationalArr2[i2] = new Rational(byteOrderedDataInputStream.readInt(), byteOrderedDataInputStream.readInt());
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e10) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e10);
}
return rationalArr2;
case 11:
double[] dArr = new double[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
dArr[i2] = byteOrderedDataInputStream.readFloat();
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e11) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e11);
}
return dArr;
case 12:
double[] dArr2 = new double[this.numberOfComponents];
while (i2 < this.numberOfComponents) {
dArr2[i2] = byteOrderedDataInputStream.readDouble();
i2++;
}
try {
byteOrderedDataInputStream.close();
} catch (IOException e12) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e12);
}
return dArr2;
default:
try {
byteOrderedDataInputStream.close();
} catch (IOException e13) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e13);
}
return null;
}
} catch (IOException e14) {
e = e14;
Log.w(ExifInterface.TAG, "IOException occurred during reading a value", e);
if (byteOrderedDataInputStream != null) {
try {
byteOrderedDataInputStream.close();
} catch (IOException e15) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e15);
}
}
return null;
}
} catch (Throwable th) {
th = th;
inputStream2 = inputStream;
if (inputStream2 != null) {
try {
inputStream2.close();
} catch (IOException e16) {
Log.e(ExifInterface.TAG, "IOException occurred while closing InputStream", e16);
}
}
throw th;
}
} catch (IOException e17) {
e = e17;
byteOrderedDataInputStream = null;
} catch (Throwable th2) {
th = th2;
if (inputStream2 != null) {
}
throw th;
}
}
public int size() {
return ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[this.format] * this.numberOfComponents;
}
public String toString() {
return Operators.BRACKET_START_STR + ExifInterface.IFD_FORMAT_NAMES[this.format] + ", data length:" + this.bytes.length + Operators.BRACKET_END_STR;
}
public ExifAttribute(int i2, int i3, long j2, byte[] bArr) {
this.format = i2;
this.numberOfComponents = i3;
this.bytesOffset = j2;
this.bytes = bArr;
}
public static ExifAttribute createDouble(double d2, ByteOrder byteOrder) {
return createDouble(new double[]{d2}, byteOrder);
}
public static ExifAttribute createSLong(int i2, ByteOrder byteOrder) {
return createSLong(new int[]{i2}, byteOrder);
}
public static ExifAttribute createULong(long j2, ByteOrder byteOrder) {
return createULong(new long[]{j2}, byteOrder);
}
public static ExifAttribute createUShort(int i2, ByteOrder byteOrder) {
return createUShort(new int[]{i2}, byteOrder);
}
public static ExifAttribute createSRational(Rational rational, ByteOrder byteOrder) {
return createSRational(new Rational[]{rational}, byteOrder);
}
public static ExifAttribute createURational(Rational rational, ByteOrder byteOrder) {
return createURational(new Rational[]{rational}, byteOrder);
}
}
@Retention(RetentionPolicy.SOURCE)
public @interface ExifStreamType {
}
@Retention(RetentionPolicy.SOURCE)
public @interface IfdType {
}
public static class Rational {
public final long denominator;
public final long numerator;
public Rational(double d2) {
this((long) (d2 * 10000.0d), WorkRequest.MIN_BACKOFF_MILLIS);
}
public double calculate() {
return this.numerator / this.denominator;
}
public String toString() {
return this.numerator + Operators.DIV + this.denominator;
}
public Rational(long j2, long j3) {
if (j3 == 0) {
this.numerator = 0L;
this.denominator = 1L;
return;
}
this.numerator = j2;
this.denominator = j3;
}
}
static {
ExifTag[] exifTagArr;
ExifTag[] exifTagArr2 = {new ExifTag("NewSubfileType", 254, 4), new ExifTag("SubfileType", 255, 4), new ExifTag("ImageWidth", 256, 3, 4), new ExifTag("ImageLength", 257, 3, 4), new ExifTag("BitsPerSample", 258, 3), new ExifTag("Compression", 259, 3), new ExifTag("PhotometricInterpretation", 262, 3), new ExifTag("ImageDescription", 270, 2), new ExifTag("Make", 271, 2), new ExifTag("Model", 272, 2), new ExifTag("StripOffsets", AudioAttributesCompat.FLAG_ALL_PUBLIC, 3, 4), new ExifTag("Orientation", TiffUtil.TIFF_TAG_ORIENTATION, 3), new ExifTag("SamplesPerPixel", 277, 3), new ExifTag("RowsPerStrip", 278, 3, 4), new ExifTag("StripByteCounts", 279, 3, 4), new ExifTag("XResolution", 282, 5), new ExifTag("YResolution", 283, 5), new ExifTag("PlanarConfiguration", 284, 3), new ExifTag("ResolutionUnit", 296, 3), new ExifTag("TransferFunction", 301, 3), new ExifTag("Software", 305, 2), new ExifTag("DateTime", 306, 2), new ExifTag("Artist", 315, 2), new ExifTag("WhitePoint", TypedValues.AttributesType.TYPE_PIVOT_TARGET, 5), new ExifTag("PrimaryChromaticities", 319, 5), new ExifTag("SubIFDPointer", 330, 4), new ExifTag("JPEGInterchangeFormat", 513, 4), new ExifTag("JPEGInterchangeFormatLength", 514, 4), new ExifTag("YCbCrCoefficients", 529, 5), new ExifTag("YCbCrSubSampling", 530, 3), new ExifTag("YCbCrPositioning", 531, 3), new ExifTag("ReferenceBlackWhite", 532, 5), new ExifTag("Copyright", 33432, 2), new ExifTag("ExifIFDPointer", 34665, 4), new ExifTag("GPSInfoIFDPointer", 34853, 4), new ExifTag("SensorTopBorder", 4, 4), new ExifTag("SensorLeftBorder", 5, 4), new ExifTag("SensorBottomBorder", 6, 4), new ExifTag("SensorRightBorder", 7, 4), new ExifTag("ISO", 23, 3), new ExifTag("JpgFromRaw", 46, 7), new ExifTag("Xmp", 700, 1)};
IFD_TIFF_TAGS = exifTagArr2;
ExifTag[] exifTagArr3 = {new ExifTag("ExposureTime", 33434, 5), new ExifTag("FNumber", 33437, 5), new ExifTag("ExposureProgram", 34850, 3), new ExifTag("SpectralSensitivity", 34852, 2), new ExifTag("PhotographicSensitivity", 34855, 3), new ExifTag("OECF", 34856, 7), new ExifTag("SensitivityType", 34864, 3), new ExifTag("StandardOutputSensitivity", 34865, 4), new ExifTag("RecommendedExposureIndex", 34866, 4), new ExifTag("ISOSpeed", 34867, 4), new ExifTag("ISOSpeedLatitudeyyy", 34868, 4), new ExifTag("ISOSpeedLatitudezzz", 34869, 4), new ExifTag("ExifVersion", 36864, 2), new ExifTag("DateTimeOriginal", 36867, 2), new ExifTag("DateTimeDigitized", 36868, 2), new ExifTag("OffsetTime", 36880, 2), new ExifTag("OffsetTimeOriginal", 36881, 2), new ExifTag("OffsetTimeDigitized", 36882, 2), new ExifTag("ComponentsConfiguration", 37121, 7), new ExifTag("CompressedBitsPerPixel", 37122, 5), new ExifTag("ShutterSpeedValue", 37377, 10), new ExifTag("ApertureValue", 37378, 5), new ExifTag("BrightnessValue", 37379, 10), new ExifTag("ExposureBiasValue", 37380, 10), new ExifTag("MaxApertureValue", 37381, 5), new ExifTag("SubjectDistance", 37382, 5), new ExifTag("MeteringMode", 37383, 3), new ExifTag("LightSource", 37384, 3), new ExifTag("Flash", 37385, 3), new ExifTag("FocalLength", 37386, 5), new ExifTag("SubjectArea", 37396, 3), new ExifTag("MakerNote", 37500, 7), new ExifTag("UserComment", 37510, 7), new ExifTag("SubSecTime", 37520, 2), new ExifTag("SubSecTimeOriginal", 37521, 2), new ExifTag("SubSecTimeDigitized", 37522, 2), new ExifTag("FlashpixVersion", 40960, 7), new ExifTag("ColorSpace", 40961, 3), new ExifTag("PixelXDimension", 40962, 3, 4), new ExifTag("PixelYDimension", 40963, 3, 4), new ExifTag("RelatedSoundFile", 40964, 2), new ExifTag("InteroperabilityIFDPointer", 40965, 4), new ExifTag("FlashEnergy", 41483, 5), new ExifTag("SpatialFrequencyResponse", 41484, 7), new ExifTag("FocalPlaneXResolution", 41486, 5), new ExifTag("FocalPlaneYResolution", 41487, 5), new ExifTag("FocalPlaneResolutionUnit", 41488, 3), new ExifTag("SubjectLocation", 41492, 3), new ExifTag("ExposureIndex", 41493, 5), new ExifTag("SensingMethod", 41495, 3), new ExifTag("FileSource", 41728, 7), new ExifTag("SceneType", 41729, 7), new ExifTag("CFAPattern", 41730, 7), new ExifTag("CustomRendered", 41985, 3), new ExifTag("ExposureMode", 41986, 3), new ExifTag("WhiteBalance", 41987, 3), new ExifTag("DigitalZoomRatio", 41988, 5), new ExifTag("FocalLengthIn35mmFilm", 41989, 3), new ExifTag("SceneCaptureType", 41990, 3), new ExifTag("GainControl", 41991, 3), new ExifTag("Contrast", 41992, 3), new ExifTag("Saturation", 41993, 3), new ExifTag("Sharpness", 41994, 3), new ExifTag("DeviceSettingDescription", 41995, 7), new ExifTag("SubjectDistanceRange", 41996, 3), new ExifTag("ImageUniqueID", 42016, 2), new ExifTag("CameraOwnerName", 42032, 2), new ExifTag("BodySerialNumber", 42033, 2), new ExifTag("LensSpecification", 42034, 5), new ExifTag("LensMake", 42035, 2), new ExifTag("LensModel", 42036, 2), new ExifTag("Gamma", 42240, 5), new ExifTag("DNGVersion", 50706, 1), new ExifTag("DefaultCropSize", 50720, 3, 4)};
IFD_EXIF_TAGS = exifTagArr3;
ExifTag[] exifTagArr4 = {new ExifTag("GPSVersionID", 0, 1), new ExifTag("GPSLatitudeRef", 1, 2), new ExifTag("GPSLatitude", 2, 5, 10), new ExifTag("GPSLongitudeRef", 3, 2), new ExifTag("GPSLongitude", 4, 5, 10), new ExifTag("GPSAltitudeRef", 5, 1), new ExifTag("GPSAltitude", 6, 5), new ExifTag("GPSTimeStamp", 7, 5), new ExifTag("GPSSatellites", 8, 2), new ExifTag("GPSStatus", 9, 2), new ExifTag("GPSMeasureMode", 10, 2), new ExifTag("GPSDOP", 11, 5), new ExifTag("GPSSpeedRef", 12, 2), new ExifTag("GPSSpeed", 13, 5), new ExifTag("GPSTrackRef", 14, 2), new ExifTag("GPSTrack", 15, 5), new ExifTag("GPSImgDirectionRef", 16, 2), new ExifTag("GPSImgDirection", 17, 5), new ExifTag("GPSMapDatum", 18, 2), new ExifTag("GPSDestLatitudeRef", 19, 2), new ExifTag("GPSDestLatitude", 20, 5), new ExifTag("GPSDestLongitudeRef", 21, 2), new ExifTag("GPSDestLongitude", 22, 5), new ExifTag("GPSDestBearingRef", 23, 2), new ExifTag("GPSDestBearing", 24, 5), new ExifTag("GPSDestDistanceRef", 25, 2), new ExifTag("GPSDestDistance", 26, 5), new ExifTag("GPSProcessingMethod", 27, 7), new ExifTag("GPSAreaInformation", 28, 7), new ExifTag("GPSDateStamp", 29, 2), new ExifTag("GPSDifferential", 30, 3), new ExifTag("GPSHPositioningError", 31, 5)};
IFD_GPS_TAGS = exifTagArr4;
ExifTag[] exifTagArr5 = {new ExifTag("InteroperabilityIndex", 1, 2)};
IFD_INTEROPERABILITY_TAGS = exifTagArr5;
ExifTag[] exifTagArr6 = {new ExifTag("NewSubfileType", 254, 4), new ExifTag("SubfileType", 255, 4), new ExifTag("ThumbnailImageWidth", 256, 3, 4), new ExifTag("ThumbnailImageLength", 257, 3, 4), new ExifTag("BitsPerSample", 258, 3), new ExifTag("Compression", 259, 3), new ExifTag("PhotometricInterpretation", 262, 3), new ExifTag("ImageDescription", 270, 2), new ExifTag("Make", 271, 2), new ExifTag("Model", 272, 2), new ExifTag("StripOffsets", AudioAttributesCompat.FLAG_ALL_PUBLIC, 3, 4), new ExifTag("ThumbnailOrientation", TiffUtil.TIFF_TAG_ORIENTATION, 3), new ExifTag("SamplesPerPixel", 277, 3), new ExifTag("RowsPerStrip", 278, 3, 4), new ExifTag("StripByteCounts", 279, 3, 4), new ExifTag("XResolution", 282, 5), new ExifTag("YResolution", 283, 5), new ExifTag("PlanarConfiguration", 284, 3), new ExifTag("ResolutionUnit", 296, 3), new ExifTag("TransferFunction", 301, 3), new ExifTag("Software", 305, 2), new ExifTag("DateTime", 306, 2), new ExifTag("Artist", 315, 2), new ExifTag("WhitePoint", TypedValues.AttributesType.TYPE_PIVOT_TARGET, 5), new ExifTag("PrimaryChromaticities", 319, 5), new ExifTag("SubIFDPointer", 330, 4), new ExifTag("JPEGInterchangeFormat", 513, 4), new ExifTag("JPEGInterchangeFormatLength", 514, 4), new ExifTag("YCbCrCoefficients", 529, 5), new ExifTag("YCbCrSubSampling", 530, 3), new ExifTag("YCbCrPositioning", 531, 3), new ExifTag("ReferenceBlackWhite", 532, 5), new ExifTag("Copyright", 33432, 2), new ExifTag("ExifIFDPointer", 34665, 4), new ExifTag("GPSInfoIFDPointer", 34853, 4), new ExifTag("DNGVersion", 50706, 1), new ExifTag("DefaultCropSize", 50720, 3, 4)};
IFD_THUMBNAIL_TAGS = exifTagArr6;
TAG_RAF_IMAGE_SIZE = new ExifTag("StripOffsets", AudioAttributesCompat.FLAG_ALL_PUBLIC, 3);
ExifTag[] exifTagArr7 = {new ExifTag("ThumbnailImage", 256, 7), new ExifTag(TAG_ORF_CAMERA_SETTINGS_IFD_POINTER, 8224, 4), new ExifTag(TAG_ORF_IMAGE_PROCESSING_IFD_POINTER, 8256, 4)};
ORF_MAKER_NOTE_TAGS = exifTagArr7;
ExifTag[] exifTagArr8 = {new ExifTag("PreviewImageStart", 257, 4), new ExifTag("PreviewImageLength", 258, 4)};
ORF_CAMERA_SETTINGS_TAGS = exifTagArr8;
ExifTag[] exifTagArr9 = {new ExifTag("AspectFrame", 4371, 3)};
ORF_IMAGE_PROCESSING_TAGS = exifTagArr9;
ExifTag[] exifTagArr10 = {new ExifTag("ColorSpace", 55, 3)};
PEF_TAGS = exifTagArr10;
EXIF_TAGS = new ExifTag[][]{exifTagArr2, exifTagArr3, exifTagArr4, exifTagArr5, exifTagArr6, exifTagArr2, exifTagArr7, exifTagArr8, exifTagArr9, exifTagArr10};
EXIF_POINTER_TAGS = new ExifTag[]{new ExifTag("SubIFDPointer", 330, 4), new ExifTag("ExifIFDPointer", 34665, 4), new ExifTag("GPSInfoIFDPointer", 34853, 4), new ExifTag("InteroperabilityIFDPointer", 40965, 4), new ExifTag(TAG_ORF_CAMERA_SETTINGS_IFD_POINTER, 8224, 1), new ExifTag(TAG_ORF_IMAGE_PROCESSING_IFD_POINTER, 8256, 1)};
JPEG_INTERCHANGE_FORMAT_TAG = new ExifTag("JPEGInterchangeFormat", 513, 4);
JPEG_INTERCHANGE_FORMAT_LENGTH_TAG = new ExifTag("JPEGInterchangeFormatLength", 514, 4);
sExifTagMapsForReading = new HashMap[10];
sExifTagMapsForWriting = new HashMap[10];
sTagSetForCompatibility = new HashSet<>(Arrays.asList("FNumber", "DigitalZoomRatio", "ExposureTime", "SubjectDistance", "GPSTimeStamp"));
sExifPointerTagMap = new HashMap<>();
Charset forName = Charset.forName(C.ASCII_NAME);
ASCII = forName;
IDENTIFIER_EXIF_APP1 = "Exif\u0000\u0000".getBytes(forName);
IDENTIFIER_XMP_APP1 = "http://ns.adobe.com/xap/1.0/\u0000".getBytes(forName);
Locale locale = Locale.US;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss", locale);
sFormatterPrimary = simpleDateFormat;
simpleDateFormat.setTimeZone(TimeZone.getTimeZone(UtcDates.UTC));
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", locale);
sFormatterSecondary = simpleDateFormat2;
simpleDateFormat2.setTimeZone(TimeZone.getTimeZone(UtcDates.UTC));
int i2 = 0;
while (true) {
ExifTag[][] exifTagArr11 = EXIF_TAGS;
if (i2 < exifTagArr11.length) {
sExifTagMapsForReading[i2] = new HashMap<>();
sExifTagMapsForWriting[i2] = new HashMap<>();
for (ExifTag exifTag : exifTagArr11[i2]) {
sExifTagMapsForReading[i2].put(Integer.valueOf(exifTag.number), exifTag);
sExifTagMapsForWriting[i2].put(exifTag.name, exifTag);
}
i2++;
} else {
HashMap<Integer, Integer> hashMap = sExifPointerTagMap;
ExifTag[] exifTagArr12 = EXIF_POINTER_TAGS;
hashMap.put(Integer.valueOf(exifTagArr12[0].number), 5);
hashMap.put(Integer.valueOf(exifTagArr12[1].number), 1);
hashMap.put(Integer.valueOf(exifTagArr12[2].number), 2);
hashMap.put(Integer.valueOf(exifTagArr12[3].number), 3);
hashMap.put(Integer.valueOf(exifTagArr12[4].number), 7);
hashMap.put(Integer.valueOf(exifTagArr12[5].number), 8);
NON_ZERO_TIME_PATTERN = Pattern.compile(".*[1-9].*");
GPS_TIMESTAMP_PATTERN = Pattern.compile("^(\\d{2}):(\\d{2}):(\\d{2})$");
DATETIME_PRIMARY_FORMAT_PATTERN = Pattern.compile("^(\\d{4}):(\\d{2}):(\\d{2})\\s(\\d{2}):(\\d{2}):(\\d{2})$");
DATETIME_SECONDARY_FORMAT_PATTERN = Pattern.compile("^(\\d{4})-(\\d{2})-(\\d{2})\\s(\\d{2}):(\\d{2}):(\\d{2})$");
return;
}
}
}
public ExifInterface(File file) throws IOException {
ExifTag[][] exifTagArr = EXIF_TAGS;
this.mAttributes = new HashMap[exifTagArr.length];
this.mAttributesOffsets = new HashSet(exifTagArr.length);
this.mExifByteOrder = ByteOrder.BIG_ENDIAN;
Objects.requireNonNull(file, "file cannot be null");
initForFilename(file.getAbsolutePath());
}
private void addDefaultValuesForCompatibility() {
String attribute = getAttribute("DateTimeOriginal");
if (attribute != null && getAttribute("DateTime") == null) {
this.mAttributes[0].put("DateTime", ExifAttribute.createString(attribute));
}
if (getAttribute("ImageWidth") == null) {
this.mAttributes[0].put("ImageWidth", ExifAttribute.createULong(0L, this.mExifByteOrder));
}
if (getAttribute("ImageLength") == null) {
this.mAttributes[0].put("ImageLength", ExifAttribute.createULong(0L, this.mExifByteOrder));
}
if (getAttribute("Orientation") == null) {
this.mAttributes[0].put("Orientation", ExifAttribute.createULong(0L, this.mExifByteOrder));
}
if (getAttribute("LightSource") == null) {
this.mAttributes[1].put("LightSource", ExifAttribute.createULong(0L, this.mExifByteOrder));
}
}
private static String byteArrayToHexString(byte[] bArr) {
StringBuilder sb = new StringBuilder(bArr.length * 2);
for (int i2 = 0; i2 < bArr.length; i2++) {
sb.append(String.format("%02x", Byte.valueOf(bArr[i2])));
}
return sb.toString();
}
private static void closeFileDescriptor(FileDescriptor fileDescriptor) {
if (Build.VERSION.SDK_INT >= 21) {
try {
Os.close(fileDescriptor);
return;
} catch (Exception unused) {
Log.e(TAG, "Error closing fd.");
return;
}
}
Log.e(TAG, "closeFileDescriptor is called in API < 21, which must be wrong.");
}
private static void closeQuietly(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
} catch (RuntimeException e2) {
throw e2;
} catch (Exception unused) {
}
}
}
private String convertDecimalDegree(double d2) {
long j2 = (long) d2;
double d3 = d2 - j2;
long j3 = (long) (d3 * 60.0d);
long round = Math.round((d3 - (j3 / 60.0d)) * 3600.0d * 1.0E7d);
return j2 + "/1," + j3 + "/1," + round + "/10000000";
}
private static double convertRationalLatLonToDouble(String str, String str2) {
try {
String[] split = str.split(",", -1);
String[] split2 = split[0].split(Operators.DIV, -1);
String[] split3 = split[1].split(Operators.DIV, -1);
String[] split4 = split[2].split(Operators.DIV, -1);
double parseDouble = (Double.parseDouble(split2[0].trim()) / Double.parseDouble(split2[1].trim())) + ((Double.parseDouble(split3[0].trim()) / Double.parseDouble(split3[1].trim())) / 60.0d) + ((Double.parseDouble(split4[0].trim()) / Double.parseDouble(split4[1].trim())) / 3600.0d);
if (!str2.equals("S") && !str2.equals("W")) {
if (!str2.equals("N") && !str2.equals("E")) {
throw new IllegalArgumentException();
}
return parseDouble;
}
return -parseDouble;
} catch (ArrayIndexOutOfBoundsException | NumberFormatException unused) {
throw new IllegalArgumentException();
}
}
private static long[] convertToLongArray(Object obj) {
if (obj instanceof int[]) {
int[] iArr = (int[]) obj;
long[] jArr = new long[iArr.length];
for (int i2 = 0; i2 < iArr.length; i2++) {
jArr[i2] = iArr[i2];
}
return jArr;
} else if (obj instanceof long[]) {
return (long[]) obj;
} else {
return null;
}
}
private static int copy(InputStream inputStream, OutputStream outputStream) throws IOException {
byte[] bArr = new byte[8192];
int i2 = 0;
while (true) {
int read = inputStream.read(bArr);
if (read == -1) {
return i2;
}
i2 += read;
outputStream.write(bArr, 0, read);
}
}
private void copyChunksUpToGivenChunkType(ByteOrderedDataInputStream byteOrderedDataInputStream, ByteOrderedDataOutputStream byteOrderedDataOutputStream, byte[] bArr, byte[] bArr2) throws IOException {
Charset charset;
String str;
while (true) {
byte[] bArr3 = new byte[4];
if (byteOrderedDataInputStream.read(bArr3) != 4) {
StringBuilder sb = new StringBuilder();
sb.append("Encountered invalid length while copying WebP chunks up tochunk type ");
sb.append(new String(bArr, ASCII));
if (bArr2 == null) {
str = "";
} else {
str = " or " + new String(bArr2, charset);
}
sb.append(str);
throw new IOException(sb.toString());
}
copyWebPChunk(byteOrderedDataInputStream, byteOrderedDataOutputStream, bArr3);
if (Arrays.equals(bArr3, bArr)) {
return;
}
if (bArr2 != null && Arrays.equals(bArr3, bArr2)) {
return;
}
}
}
private void copyWebPChunk(ByteOrderedDataInputStream byteOrderedDataInputStream, ByteOrderedDataOutputStream byteOrderedDataOutputStream, byte[] bArr) throws IOException {
int readInt = byteOrderedDataInputStream.readInt();
byteOrderedDataOutputStream.write(bArr);
byteOrderedDataOutputStream.writeInt(readInt);
if (readInt % 2 == 1) {
readInt++;
}
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream, readInt);
}
private ExifAttribute getExifAttribute(String str) {
Objects.requireNonNull(str, "tag shouldn't be null");
if ("ISOSpeedRatings".equals(str)) {
if (DEBUG) {
Log.d(TAG, "getExifAttribute: Replacing TAG_ISO_SPEED_RATINGS with TAG_PHOTOGRAPHIC_SENSITIVITY.");
}
str = "PhotographicSensitivity";
}
for (int i2 = 0; i2 < EXIF_TAGS.length; i2++) {
ExifAttribute exifAttribute = this.mAttributes[i2].get(str);
if (exifAttribute != null) {
return exifAttribute;
}
}
return null;
}
private void getHeifAttributes(final ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
String str;
String str2;
String extractMetadata;
String extractMetadata2;
int parseInt;
MediaMetadataRetriever mediaMetadataRetriever = new MediaMetadataRetriever();
try {
if (Build.VERSION.SDK_INT >= 23) {
mediaMetadataRetriever.setDataSource(new MediaDataSource() {
public long mPosition;
@Override
public void close() throws IOException {
}
@Override
public long getSize() throws IOException {
return -1L;
}
@Override
public int readAt(long j2, byte[] bArr, int i2, int i3) throws IOException {
if (i3 == 0) {
return 0;
}
if (j2 < 0) {
return -1;
}
try {
long j3 = this.mPosition;
if (j3 != j2) {
if (j3 >= 0 && j2 >= j3 + byteOrderedDataInputStream.available()) {
return -1;
}
byteOrderedDataInputStream.seek(j2);
this.mPosition = j2;
}
if (i3 > byteOrderedDataInputStream.available()) {
i3 = byteOrderedDataInputStream.available();
}
int read = byteOrderedDataInputStream.read(bArr, i2, i3);
if (read >= 0) {
this.mPosition += read;
return read;
}
} catch (IOException unused) {
}
this.mPosition = -1L;
return -1;
}
});
} else {
FileDescriptor fileDescriptor = this.mSeekableFileDescriptor;
if (fileDescriptor != null) {
mediaMetadataRetriever.setDataSource(fileDescriptor);
} else {
String str3 = this.mFilename;
if (str3 == null) {
return;
}
mediaMetadataRetriever.setDataSource(str3);
}
}
String extractMetadata3 = mediaMetadataRetriever.extractMetadata(33);
String extractMetadata4 = mediaMetadataRetriever.extractMetadata(34);
String extractMetadata5 = mediaMetadataRetriever.extractMetadata(26);
String extractMetadata6 = mediaMetadataRetriever.extractMetadata(17);
String str4 = null;
if ("yes".equals(extractMetadata5)) {
extractMetadata = mediaMetadataRetriever.extractMetadata(29);
str2 = mediaMetadataRetriever.extractMetadata(30);
extractMetadata2 = mediaMetadataRetriever.extractMetadata(31);
} else if ("yes".equals(extractMetadata6)) {
extractMetadata = mediaMetadataRetriever.extractMetadata(18);
str2 = mediaMetadataRetriever.extractMetadata(19);
extractMetadata2 = mediaMetadataRetriever.extractMetadata(24);
} else {
str = null;
str2 = null;
if (str4 != null) {
this.mAttributes[0].put("ImageWidth", ExifAttribute.createUShort(Integer.parseInt(str4), this.mExifByteOrder));
}
if (str2 != null) {
this.mAttributes[0].put("ImageLength", ExifAttribute.createUShort(Integer.parseInt(str2), this.mExifByteOrder));
}
if (str != null) {
int i2 = 1;
int parseInt2 = Integer.parseInt(str);
if (parseInt2 == 90) {
i2 = 6;
} else if (parseInt2 == 180) {
i2 = 3;
} else if (parseInt2 == 270) {
i2 = 8;
}
this.mAttributes[0].put("Orientation", ExifAttribute.createUShort(i2, this.mExifByteOrder));
}
if (extractMetadata3 != null && extractMetadata4 != null) {
int parseInt3 = Integer.parseInt(extractMetadata3);
parseInt = Integer.parseInt(extractMetadata4);
if (parseInt <= 6) {
byteOrderedDataInputStream.seek(parseInt3);
byte[] bArr = new byte[6];
if (byteOrderedDataInputStream.read(bArr) == 6) {
int i3 = parseInt3 + 6;
int i4 = parseInt - 6;
if (Arrays.equals(bArr, IDENTIFIER_EXIF_APP1)) {
byte[] bArr2 = new byte[i4];
if (byteOrderedDataInputStream.read(bArr2) == i4) {
this.mOffsetToExifData = i3;
readExifSegment(bArr2, 0);
} else {
throw new IOException("Can't read exif");
}
} else {
throw new IOException("Invalid identifier");
}
} else {
throw new IOException("Can't read identifier");
}
} else {
throw new IOException("Invalid exif length");
}
}
if (DEBUG) {
Log.d(TAG, "Heif meta: " + str4 + Constants.Name.X + str2 + ", rotation " + str);
}
}
str4 = extractMetadata;
str = extractMetadata2;
if (str4 != null) {
}
if (str2 != null) {
}
if (str != null) {
}
if (extractMetadata3 != null) {
int parseInt32 = Integer.parseInt(extractMetadata3);
parseInt = Integer.parseInt(extractMetadata4);
if (parseInt <= 6) {
}
}
if (DEBUG) {
}
} finally {
mediaMetadataRetriever.release();
}
}
private void getJpegAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream, int i2, int i3) throws IOException {
byte readByte;
byte readByte2;
String str;
boolean z = DEBUG;
String str2 = TAG;
if (z) {
Log.d(TAG, "getJpegAttributes starting with: " + byteOrderedDataInputStream);
}
int i4 = 0;
byteOrderedDataInputStream.mark(0);
byteOrderedDataInputStream.setByteOrder(ByteOrder.BIG_ENDIAN);
if (byteOrderedDataInputStream.readByte() == -1) {
if (byteOrderedDataInputStream.readByte() != -40) {
throw new IOException("Invalid marker: " + Integer.toHexString(readByte & 255));
}
int i5 = 2;
int i6 = 2;
while (true) {
if (byteOrderedDataInputStream.readByte() == -1) {
int i7 = i6 + 1;
byte readByte3 = byteOrderedDataInputStream.readByte();
boolean z2 = DEBUG;
if (z2) {
Log.d(str2, "Found JPEG segment indicator: " + Integer.toHexString(readByte3 & 255));
}
int i8 = i7 + 1;
if (readByte3 != -39 && readByte3 != -38) {
int readUnsignedShort = byteOrderedDataInputStream.readUnsignedShort() - i5;
int i9 = i8 + i5;
if (z2) {
Log.d(str2, "JPEG segment: " + Integer.toHexString(readByte3 & 255) + " (length: " + (readUnsignedShort + 2) + Operators.BRACKET_END_STR);
}
if (readUnsignedShort < 0) {
throw new IOException("Invalid length");
}
if (readByte3 != -31) {
if (readByte3 != -2) {
switch (readByte3) {
default:
switch (readByte3) {
default:
switch (readByte3) {
default:
switch (readByte3) {
}
case -55:
case -54:
case -53:
if (byteOrderedDataInputStream.skipBytes(1) == 1) {
this.mAttributes[i3].put("ImageLength", ExifAttribute.createULong(byteOrderedDataInputStream.readUnsignedShort(), this.mExifByteOrder));
this.mAttributes[i3].put("ImageWidth", ExifAttribute.createULong(byteOrderedDataInputStream.readUnsignedShort(), this.mExifByteOrder));
readUnsignedShort -= 5;
break;
} else {
throw new IOException("Invalid SOFx");
}
}
case -59:
case -58:
case -57:
break;
}
case -64:
case -63:
case -62:
case -61:
break;
}
} else {
byte[] bArr = new byte[readUnsignedShort];
if (byteOrderedDataInputStream.read(bArr) == readUnsignedShort) {
if (getAttribute("UserComment") == null) {
this.mAttributes[1].put("UserComment", ExifAttribute.createString(new String(bArr, ASCII)));
}
readUnsignedShort = i4;
} else {
throw new IOException("Invalid exif");
}
}
str = str2;
} else {
byte[] bArr2 = new byte[readUnsignedShort];
byteOrderedDataInputStream.readFully(bArr2);
int i10 = i9 + readUnsignedShort;
byte[] bArr3 = IDENTIFIER_EXIF_APP1;
if (startsWith(bArr2, bArr3)) {
byte[] copyOfRange = Arrays.copyOfRange(bArr2, bArr3.length, readUnsignedShort);
this.mOffsetToExifData = i2 + i9 + bArr3.length;
readExifSegment(copyOfRange, i3);
setThumbnailData(new ByteOrderedDataInputStream(copyOfRange));
} else {
byte[] bArr4 = IDENTIFIER_XMP_APP1;
if (startsWith(bArr2, bArr4)) {
int length = i9 + bArr4.length;
byte[] copyOfRange2 = Arrays.copyOfRange(bArr2, bArr4.length, readUnsignedShort);
if (getAttribute("Xmp") == null) {
str = str2;
this.mAttributes[i4].put("Xmp", new ExifAttribute(1, copyOfRange2.length, length, copyOfRange2));
this.mXmpIsFromSeparateMarker = true;
i9 = i10;
readUnsignedShort = 0;
}
}
}
str = str2;
i9 = i10;
readUnsignedShort = 0;
}
if (readUnsignedShort >= 0) {
if (byteOrderedDataInputStream.skipBytes(readUnsignedShort) != readUnsignedShort) {
throw new IOException("Invalid JPEG segment");
}
i6 = i9 + readUnsignedShort;
str2 = str;
i4 = 0;
i5 = 2;
} else {
throw new IOException("Invalid length");
}
}
} else {
throw new IOException("Invalid marker:" + Integer.toHexString(readByte2 & 255));
}
}
} else {
throw new IOException("Invalid marker: " + Integer.toHexString(readByte & 255));
}
}
private int getMimeType(BufferedInputStream bufferedInputStream) throws IOException {
bufferedInputStream.mark(5000);
byte[] bArr = new byte[5000];
bufferedInputStream.read(bArr);
bufferedInputStream.reset();
if (isJpegFormat(bArr)) {
return 4;
}
if (isRafFormat(bArr)) {
return 9;
}
if (isHeifFormat(bArr)) {
return 12;
}
if (isOrfFormat(bArr)) {
return 7;
}
if (isRw2Format(bArr)) {
return 10;
}
if (isPngFormat(bArr)) {
return 13;
}
return isWebpFormat(bArr) ? 14 : 0;
}
private void getOrfAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
getRawAttributes(byteOrderedDataInputStream);
ExifAttribute exifAttribute = this.mAttributes[1].get("MakerNote");
if (exifAttribute != null) {
ByteOrderedDataInputStream byteOrderedDataInputStream2 = new ByteOrderedDataInputStream(exifAttribute.bytes);
byteOrderedDataInputStream2.setByteOrder(this.mExifByteOrder);
byte[] bArr = ORF_MAKER_NOTE_HEADER_1;
byte[] bArr2 = new byte[bArr.length];
byteOrderedDataInputStream2.readFully(bArr2);
byteOrderedDataInputStream2.seek(0L);
byte[] bArr3 = ORF_MAKER_NOTE_HEADER_2;
byte[] bArr4 = new byte[bArr3.length];
byteOrderedDataInputStream2.readFully(bArr4);
if (Arrays.equals(bArr2, bArr)) {
byteOrderedDataInputStream2.seek(8L);
} else if (Arrays.equals(bArr4, bArr3)) {
byteOrderedDataInputStream2.seek(12L);
}
readImageFileDirectory(byteOrderedDataInputStream2, 6);
ExifAttribute exifAttribute2 = this.mAttributes[7].get("PreviewImageStart");
ExifAttribute exifAttribute3 = this.mAttributes[7].get("PreviewImageLength");
if (exifAttribute2 != null && exifAttribute3 != null) {
this.mAttributes[5].put("JPEGInterchangeFormat", exifAttribute2);
this.mAttributes[5].put("JPEGInterchangeFormatLength", exifAttribute3);
}
ExifAttribute exifAttribute4 = this.mAttributes[8].get("AspectFrame");
if (exifAttribute4 != null) {
int[] iArr = (int[]) exifAttribute4.getValue(this.mExifByteOrder);
if (iArr != null && iArr.length == 4) {
if (iArr[2] <= iArr[0] || iArr[3] <= iArr[1]) {
return;
}
int i2 = (iArr[2] - iArr[0]) + 1;
int i3 = (iArr[3] - iArr[1]) + 1;
if (i2 < i3) {
int i4 = i2 + i3;
i3 = i4 - i3;
i2 = i4 - i3;
}
ExifAttribute createUShort = ExifAttribute.createUShort(i2, this.mExifByteOrder);
ExifAttribute createUShort2 = ExifAttribute.createUShort(i3, this.mExifByteOrder);
this.mAttributes[0].put("ImageWidth", createUShort);
this.mAttributes[0].put("ImageLength", createUShort2);
return;
}
Log.w(TAG, "Invalid aspect frame values. frame=" + Arrays.toString(iArr));
}
}
}
private void getPngAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
if (DEBUG) {
Log.d(TAG, "getPngAttributes starting with: " + byteOrderedDataInputStream);
}
byteOrderedDataInputStream.mark(0);
byteOrderedDataInputStream.setByteOrder(ByteOrder.BIG_ENDIAN);
byte[] bArr = PNG_SIGNATURE;
byteOrderedDataInputStream.skipBytes(bArr.length);
int length = bArr.length + 0;
while (true) {
try {
int readInt = byteOrderedDataInputStream.readInt();
int i2 = length + 4;
byte[] bArr2 = new byte[4];
if (byteOrderedDataInputStream.read(bArr2) == 4) {
int i3 = i2 + 4;
if (i3 == 16 && !Arrays.equals(bArr2, PNG_CHUNK_TYPE_IHDR)) {
throw new IOException("Encountered invalid PNG file--IHDR chunk should appearas the first chunk");
}
if (Arrays.equals(bArr2, PNG_CHUNK_TYPE_IEND)) {
return;
}
if (Arrays.equals(bArr2, PNG_CHUNK_TYPE_EXIF)) {
byte[] bArr3 = new byte[readInt];
if (byteOrderedDataInputStream.read(bArr3) == readInt) {
int readInt2 = byteOrderedDataInputStream.readInt();
CRC32 crc32 = new CRC32();
crc32.update(bArr2);
crc32.update(bArr3);
if (((int) crc32.getValue()) == readInt2) {
this.mOffsetToExifData = i3;
readExifSegment(bArr3, 0);
validateImages();
setThumbnailData(new ByteOrderedDataInputStream(bArr3));
return;
}
throw new IOException("Encountered invalid CRC value for PNG-EXIF chunk.\n recorded CRC value: " + readInt2 + ", calculated CRC value: " + crc32.getValue());
}
throw new IOException("Failed to read given length for given PNG chunk type: " + byteArrayToHexString(bArr2));
}
int i4 = readInt + 4;
byteOrderedDataInputStream.skipBytes(i4);
length = i3 + i4;
} else {
throw new IOException("Encountered invalid length while parsing PNG chunktype");
}
} catch (EOFException unused) {
throw new IOException("Encountered corrupt PNG file.");
}
}
}
private void getRafAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
boolean z = DEBUG;
if (z) {
Log.d(TAG, "getRafAttributes starting with: " + byteOrderedDataInputStream);
}
byteOrderedDataInputStream.mark(0);
byteOrderedDataInputStream.skipBytes(84);
byte[] bArr = new byte[4];
byte[] bArr2 = new byte[4];
byte[] bArr3 = new byte[4];
byteOrderedDataInputStream.read(bArr);
byteOrderedDataInputStream.read(bArr2);
byteOrderedDataInputStream.read(bArr3);
int i2 = ByteBuffer.wrap(bArr).getInt();
int i3 = ByteBuffer.wrap(bArr2).getInt();
int i4 = ByteBuffer.wrap(bArr3).getInt();
byte[] bArr4 = new byte[i3];
byteOrderedDataInputStream.seek(i2);
byteOrderedDataInputStream.read(bArr4);
getJpegAttributes(new ByteOrderedDataInputStream(bArr4), i2, 5);
byteOrderedDataInputStream.seek(i4);
byteOrderedDataInputStream.setByteOrder(ByteOrder.BIG_ENDIAN);
int readInt = byteOrderedDataInputStream.readInt();
if (z) {
Log.d(TAG, "numberOfDirectoryEntry: " + readInt);
}
for (int i5 = 0; i5 < readInt; i5++) {
int readUnsignedShort = byteOrderedDataInputStream.readUnsignedShort();
int readUnsignedShort2 = byteOrderedDataInputStream.readUnsignedShort();
if (readUnsignedShort == TAG_RAF_IMAGE_SIZE.number) {
short readShort = byteOrderedDataInputStream.readShort();
short readShort2 = byteOrderedDataInputStream.readShort();
ExifAttribute createUShort = ExifAttribute.createUShort(readShort, this.mExifByteOrder);
ExifAttribute createUShort2 = ExifAttribute.createUShort(readShort2, this.mExifByteOrder);
this.mAttributes[0].put("ImageLength", createUShort);
this.mAttributes[0].put("ImageWidth", createUShort2);
if (DEBUG) {
Log.d(TAG, "Updated to length: " + ((int) readShort) + ", width: " + ((int) readShort2));
return;
}
return;
}
byteOrderedDataInputStream.skipBytes(readUnsignedShort2);
}
}
private void getRawAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
ExifAttribute exifAttribute;
parseTiffHeaders(byteOrderedDataInputStream, byteOrderedDataInputStream.available());
readImageFileDirectory(byteOrderedDataInputStream, 0);
updateImageSizeValues(byteOrderedDataInputStream, 0);
updateImageSizeValues(byteOrderedDataInputStream, 5);
updateImageSizeValues(byteOrderedDataInputStream, 4);
validateImages();
if (this.mMimeType != 8 || (exifAttribute = this.mAttributes[1].get("MakerNote")) == null) {
return;
}
ByteOrderedDataInputStream byteOrderedDataInputStream2 = new ByteOrderedDataInputStream(exifAttribute.bytes);
byteOrderedDataInputStream2.setByteOrder(this.mExifByteOrder);
byteOrderedDataInputStream2.seek(6L);
readImageFileDirectory(byteOrderedDataInputStream2, 9);
ExifAttribute exifAttribute2 = this.mAttributes[9].get("ColorSpace");
if (exifAttribute2 != null) {
this.mAttributes[1].put("ColorSpace", exifAttribute2);
}
}
private void getRw2Attributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
if (DEBUG) {
Log.d(TAG, "getRw2Attributes starting with: " + byteOrderedDataInputStream);
}
getRawAttributes(byteOrderedDataInputStream);
ExifAttribute exifAttribute = this.mAttributes[0].get("JpgFromRaw");
if (exifAttribute != null) {
getJpegAttributes(new ByteOrderedDataInputStream(exifAttribute.bytes), (int) exifAttribute.bytesOffset, 5);
}
ExifAttribute exifAttribute2 = this.mAttributes[0].get("ISO");
ExifAttribute exifAttribute3 = this.mAttributes[1].get("PhotographicSensitivity");
if (exifAttribute2 == null || exifAttribute3 != null) {
return;
}
this.mAttributes[1].put("PhotographicSensitivity", exifAttribute2);
}
private void getStandaloneAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
byte[] bArr = IDENTIFIER_EXIF_APP1;
byteOrderedDataInputStream.skipBytes(bArr.length);
byte[] bArr2 = new byte[byteOrderedDataInputStream.available()];
byteOrderedDataInputStream.readFully(bArr2);
this.mOffsetToExifData = bArr.length;
readExifSegment(bArr2, 0);
}
private void getWebpAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
if (DEBUG) {
Log.d(TAG, "getWebpAttributes starting with: " + byteOrderedDataInputStream);
}
byteOrderedDataInputStream.mark(0);
byteOrderedDataInputStream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
byteOrderedDataInputStream.skipBytes(WEBP_SIGNATURE_1.length);
int readInt = byteOrderedDataInputStream.readInt() + 8;
int skipBytes = byteOrderedDataInputStream.skipBytes(WEBP_SIGNATURE_2.length) + 8;
while (true) {
try {
byte[] bArr = new byte[4];
if (byteOrderedDataInputStream.read(bArr) == 4) {
int readInt2 = byteOrderedDataInputStream.readInt();
int i2 = skipBytes + 4 + 4;
if (Arrays.equals(WEBP_CHUNK_TYPE_EXIF, bArr)) {
byte[] bArr2 = new byte[readInt2];
if (byteOrderedDataInputStream.read(bArr2) == readInt2) {
this.mOffsetToExifData = i2;
readExifSegment(bArr2, 0);
setThumbnailData(new ByteOrderedDataInputStream(bArr2));
return;
}
throw new IOException("Failed to read given length for given PNG chunk type: " + byteArrayToHexString(bArr));
}
if (readInt2 % 2 == 1) {
readInt2++;
}
int i3 = i2 + readInt2;
if (i3 == readInt) {
return;
}
if (i3 <= readInt) {
int skipBytes2 = byteOrderedDataInputStream.skipBytes(readInt2);
if (skipBytes2 != readInt2) {
throw new IOException("Encountered WebP file with invalid chunk size");
}
skipBytes = i2 + skipBytes2;
} else {
throw new IOException("Encountered WebP file with invalid chunk size");
}
} else {
throw new IOException("Encountered invalid length while parsing WebP chunktype");
}
} catch (EOFException unused) {
throw new IOException("Encountered corrupt WebP file.");
}
}
}
private static Pair<Integer, Integer> guessDataFormat(String str) {
if (str.contains(",")) {
String[] split = str.split(",", -1);
Pair<Integer, Integer> guessDataFormat = guessDataFormat(split[0]);
if (((Integer) guessDataFormat.first).intValue() == 2) {
return guessDataFormat;
}
for (int i2 = 1; i2 < split.length; i2++) {
Pair<Integer, Integer> guessDataFormat2 = guessDataFormat(split[i2]);
int intValue = (((Integer) guessDataFormat2.first).equals(guessDataFormat.first) || ((Integer) guessDataFormat2.second).equals(guessDataFormat.first)) ? ((Integer) guessDataFormat.first).intValue() : -1;
int intValue2 = (((Integer) guessDataFormat.second).intValue() == -1 || !(((Integer) guessDataFormat2.first).equals(guessDataFormat.second) || ((Integer) guessDataFormat2.second).equals(guessDataFormat.second))) ? -1 : ((Integer) guessDataFormat.second).intValue();
if (intValue == -1 && intValue2 == -1) {
return new Pair<>(2, -1);
}
if (intValue == -1) {
guessDataFormat = new Pair<>(Integer.valueOf(intValue2), -1);
} else if (intValue2 == -1) {
guessDataFormat = new Pair<>(Integer.valueOf(intValue), -1);
}
}
return guessDataFormat;
} else if (str.contains(Operators.DIV)) {
String[] split2 = str.split(Operators.DIV, -1);
if (split2.length == 2) {
try {
long parseDouble = (long) Double.parseDouble(split2[0]);
long parseDouble2 = (long) Double.parseDouble(split2[1]);
if (parseDouble >= 0 && parseDouble2 >= 0) {
if (parseDouble <= 2147483647L && parseDouble2 <= 2147483647L) {
return new Pair<>(10, 5);
}
return new Pair<>(5, -1);
}
return new Pair<>(10, -1);
} catch (NumberFormatException unused) {
}
}
return new Pair<>(2, -1);
} else {
try {
try {
Long valueOf = Long.valueOf(Long.parseLong(str));
if (valueOf.longValue() >= 0 && valueOf.longValue() <= 65535) {
return new Pair<>(3, 4);
}
if (valueOf.longValue() < 0) {
return new Pair<>(9, -1);
}
return new Pair<>(4, -1);
} catch (NumberFormatException unused2) {
return new Pair<>(2, -1);
}
} catch (NumberFormatException unused3) {
Double.parseDouble(str);
return new Pair<>(12, -1);
}
}
}
private void handleThumbnailFromJfif(ByteOrderedDataInputStream byteOrderedDataInputStream, HashMap hashMap) throws IOException {
ExifAttribute exifAttribute = (ExifAttribute) hashMap.get("JPEGInterchangeFormat");
ExifAttribute exifAttribute2 = (ExifAttribute) hashMap.get("JPEGInterchangeFormatLength");
if (exifAttribute == null || exifAttribute2 == null) {
return;
}
int intValue = exifAttribute.getIntValue(this.mExifByteOrder);
int intValue2 = exifAttribute2.getIntValue(this.mExifByteOrder);
if (this.mMimeType == 7) {
intValue += this.mOrfMakerNoteOffset;
}
int min = Math.min(intValue2, byteOrderedDataInputStream.getLength() - intValue);
if (intValue > 0 && min > 0) {
this.mHasThumbnail = true;
if (this.mFilename == null && this.mAssetInputStream == null && this.mSeekableFileDescriptor == null) {
byte[] bArr = new byte[min];
byteOrderedDataInputStream.skip(intValue);
byteOrderedDataInputStream.read(bArr);
this.mThumbnailBytes = bArr;
}
this.mThumbnailOffset = intValue;
this.mThumbnailLength = min;
}
if (DEBUG) {
Log.d(TAG, "Setting thumbnail attributes with offset: " + intValue + ", length: " + min);
}
}
private void handleThumbnailFromStrips(ByteOrderedDataInputStream byteOrderedDataInputStream, HashMap hashMap) throws IOException {
ExifAttribute exifAttribute = (ExifAttribute) hashMap.get("StripOffsets");
ExifAttribute exifAttribute2 = (ExifAttribute) hashMap.get("StripByteCounts");
if (exifAttribute == null || exifAttribute2 == null) {
return;
}
long[] convertToLongArray = convertToLongArray(exifAttribute.getValue(this.mExifByteOrder));
long[] convertToLongArray2 = convertToLongArray(exifAttribute2.getValue(this.mExifByteOrder));
if (convertToLongArray != null && convertToLongArray.length != 0) {
if (convertToLongArray2 != null && convertToLongArray2.length != 0) {
if (convertToLongArray.length != convertToLongArray2.length) {
Log.w(TAG, "stripOffsets and stripByteCounts should have same length.");
return;
}
long j2 = 0;
for (long j3 : convertToLongArray2) {
j2 += j3;
}
int i2 = (int) j2;
byte[] bArr = new byte[i2];
this.mAreThumbnailStripsConsecutive = true;
this.mHasThumbnailStrips = true;
this.mHasThumbnail = true;
int i3 = 0;
int i4 = 0;
for (int i5 = 0; i5 < convertToLongArray.length; i5++) {
int i6 = (int) convertToLongArray[i5];
int i7 = (int) convertToLongArray2[i5];
if (i5 < convertToLongArray.length - 1 && i6 + i7 != convertToLongArray[i5 + 1]) {
this.mAreThumbnailStripsConsecutive = false;
}
int i8 = i6 - i3;
if (i8 < 0) {
Log.d(TAG, "Invalid strip offset value");
return;
}
long j4 = i8;
if (byteOrderedDataInputStream.skip(j4) != j4) {
Log.d(TAG, "Failed to skip " + i8 + " bytes.");
return;
}
int i9 = i3 + i8;
byte[] bArr2 = new byte[i7];
if (byteOrderedDataInputStream.read(bArr2) != i7) {
Log.d(TAG, "Failed to read " + i7 + " bytes.");
return;
}
i3 = i9 + i7;
System.arraycopy(bArr2, 0, bArr, i4, i7);
i4 += i7;
}
this.mThumbnailBytes = bArr;
if (this.mAreThumbnailStripsConsecutive) {
this.mThumbnailOffset = (int) convertToLongArray[0];
this.mThumbnailLength = i2;
return;
}
return;
}
Log.w(TAG, "stripByteCounts should not be null or have zero length.");
return;
}
Log.w(TAG, "stripOffsets should not be null or have zero length.");
}
private void initForFilename(String str) throws IOException {
Objects.requireNonNull(str, "filename cannot be null");
FileInputStream fileInputStream = null;
this.mAssetInputStream = null;
this.mFilename = str;
try {
FileInputStream fileInputStream2 = new FileInputStream(str);
try {
if (isSeekableFD(fileInputStream2.getFD())) {
this.mSeekableFileDescriptor = fileInputStream2.getFD();
} else {
this.mSeekableFileDescriptor = null;
}
loadAttributes(fileInputStream2);
closeQuietly(fileInputStream2);
} catch (Throwable th) {
th = th;
fileInputStream = fileInputStream2;
closeQuietly(fileInputStream);
throw th;
}
} catch (Throwable th2) {
th = th2;
}
}
private static boolean isExifDataOnly(BufferedInputStream bufferedInputStream) throws IOException {
byte[] bArr = IDENTIFIER_EXIF_APP1;
bufferedInputStream.mark(bArr.length);
byte[] bArr2 = new byte[bArr.length];
bufferedInputStream.read(bArr2);
bufferedInputStream.reset();
int i2 = 0;
while (true) {
byte[] bArr3 = IDENTIFIER_EXIF_APP1;
if (i2 >= bArr3.length) {
return true;
}
if (bArr2[i2] != bArr3[i2]) {
return false;
}
i2++;
}
}
private boolean isHeifFormat(byte[] bArr) throws IOException {
ByteOrderedDataInputStream byteOrderedDataInputStream;
long readInt;
byte[] bArr2;
ByteOrderedDataInputStream byteOrderedDataInputStream2 = null;
try {
try {
byteOrderedDataInputStream = new ByteOrderedDataInputStream(bArr);
} catch (Exception e2) {
e = e2;
}
} catch (Throwable th) {
th = th;
}
try {
readInt = byteOrderedDataInputStream.readInt();
bArr2 = new byte[4];
byteOrderedDataInputStream.read(bArr2);
} catch (Exception e3) {
e = e3;
byteOrderedDataInputStream2 = byteOrderedDataInputStream;
if (DEBUG) {
Log.d(TAG, "Exception parsing HEIF file type box.", e);
}
if (byteOrderedDataInputStream2 != null) {
byteOrderedDataInputStream = byteOrderedDataInputStream2;
byteOrderedDataInputStream.close();
}
return false;
} catch (Throwable th2) {
th = th2;
byteOrderedDataInputStream2 = byteOrderedDataInputStream;
if (byteOrderedDataInputStream2 != null) {
byteOrderedDataInputStream2.close();
}
throw th;
}
if (!Arrays.equals(bArr2, HEIF_TYPE_FTYP)) {
byteOrderedDataInputStream.close();
return false;
}
long j2 = 16;
if (readInt == 1) {
readInt = byteOrderedDataInputStream.readLong();
if (readInt < 16) {
byteOrderedDataInputStream.close();
return false;
}
} else {
j2 = 8;
}
if (readInt > bArr.length) {
readInt = bArr.length;
}
long j3 = readInt - j2;
if (j3 < 8) {
byteOrderedDataInputStream.close();
return false;
}
byte[] bArr3 = new byte[4];
boolean z = false;
boolean z2 = false;
for (long j4 = 0; j4 < j3 / 4; j4++) {
if (byteOrderedDataInputStream.read(bArr3) != 4) {
byteOrderedDataInputStream.close();
return false;
}
if (j4 != 1) {
if (Arrays.equals(bArr3, HEIF_BRAND_MIF1)) {
z = true;
} else if (Arrays.equals(bArr3, HEIF_BRAND_HEIC)) {
z2 = true;
}
if (z && z2) {
byteOrderedDataInputStream.close();
return true;
}
}
}
byteOrderedDataInputStream.close();
return false;
}
private static boolean isJpegFormat(byte[] bArr) throws IOException {
int i2 = 0;
while (true) {
byte[] bArr2 = JPEG_SIGNATURE;
if (i2 >= bArr2.length) {
return true;
}
if (bArr[i2] != bArr2[i2]) {
return false;
}
i2++;
}
}
private boolean isOrfFormat(byte[] bArr) throws IOException {
boolean z = false;
ByteOrderedDataInputStream byteOrderedDataInputStream = null;
try {
ByteOrderedDataInputStream byteOrderedDataInputStream2 = new ByteOrderedDataInputStream(bArr);
try {
ByteOrder readByteOrder = readByteOrder(byteOrderedDataInputStream2);
this.mExifByteOrder = readByteOrder;
byteOrderedDataInputStream2.setByteOrder(readByteOrder);
short readShort = byteOrderedDataInputStream2.readShort();
z = (readShort == 20306 || readShort == 21330) ? true : true;
byteOrderedDataInputStream2.close();
return z;
} catch (Exception unused) {
byteOrderedDataInputStream = byteOrderedDataInputStream2;
if (byteOrderedDataInputStream != null) {
byteOrderedDataInputStream.close();
}
return false;
} catch (Throwable th) {
th = th;
byteOrderedDataInputStream = byteOrderedDataInputStream2;
if (byteOrderedDataInputStream != null) {
byteOrderedDataInputStream.close();
}
throw th;
}
} catch (Exception unused2) {
} catch (Throwable th2) {
th = th2;
}
}
private boolean isPngFormat(byte[] bArr) throws IOException {
int i2 = 0;
while (true) {
byte[] bArr2 = PNG_SIGNATURE;
if (i2 >= bArr2.length) {
return true;
}
if (bArr[i2] != bArr2[i2]) {
return false;
}
i2++;
}
}
private boolean isRafFormat(byte[] bArr) throws IOException {
byte[] bytes = RAF_SIGNATURE.getBytes(Charset.defaultCharset());
for (int i2 = 0; i2 < bytes.length; i2++) {
if (bArr[i2] != bytes[i2]) {
return false;
}
}
return true;
}
private boolean isRw2Format(byte[] bArr) throws IOException {
ByteOrderedDataInputStream byteOrderedDataInputStream = null;
try {
ByteOrderedDataInputStream byteOrderedDataInputStream2 = new ByteOrderedDataInputStream(bArr);
try {
ByteOrder readByteOrder = readByteOrder(byteOrderedDataInputStream2);
this.mExifByteOrder = readByteOrder;
byteOrderedDataInputStream2.setByteOrder(readByteOrder);
boolean z = byteOrderedDataInputStream2.readShort() == 85;
byteOrderedDataInputStream2.close();
return z;
} catch (Exception unused) {
byteOrderedDataInputStream = byteOrderedDataInputStream2;
if (byteOrderedDataInputStream != null) {
byteOrderedDataInputStream.close();
}
return false;
} catch (Throwable th) {
th = th;
byteOrderedDataInputStream = byteOrderedDataInputStream2;
if (byteOrderedDataInputStream != null) {
byteOrderedDataInputStream.close();
}
throw th;
}
} catch (Exception unused2) {
} catch (Throwable th2) {
th = th2;
}
}
private static boolean isSeekableFD(FileDescriptor fileDescriptor) {
if (Build.VERSION.SDK_INT >= 21) {
try {
Os.lseek(fileDescriptor, 0L, OsConstants.SEEK_CUR);
return true;
} catch (Exception unused) {
if (DEBUG) {
Log.d(TAG, "The file descriptor for the given input is not seekable");
}
}
}
return false;
}
private boolean isSupportedDataType(HashMap hashMap) throws IOException {
ExifAttribute exifAttribute;
int intValue;
ExifAttribute exifAttribute2 = (ExifAttribute) hashMap.get("BitsPerSample");
if (exifAttribute2 != null) {
int[] iArr = (int[]) exifAttribute2.getValue(this.mExifByteOrder);
int[] iArr2 = BITS_PER_SAMPLE_RGB;
if (Arrays.equals(iArr2, iArr)) {
return true;
}
if (this.mMimeType == 3 && (exifAttribute = (ExifAttribute) hashMap.get("PhotometricInterpretation")) != null && (((intValue = exifAttribute.getIntValue(this.mExifByteOrder)) == 1 && Arrays.equals(iArr, BITS_PER_SAMPLE_GREYSCALE_2)) || (intValue == 6 && Arrays.equals(iArr, iArr2)))) {
return true;
}
}
if (DEBUG) {
Log.d(TAG, "Unsupported data type value");
return false;
}
return false;
}
private boolean isSupportedFormatForSavingAttributes() {
int i2 = this.mMimeType;
return i2 == 4 || i2 == 13 || i2 == 14;
}
public static boolean isSupportedMimeType(String str) {
Objects.requireNonNull(str, "mimeType shouldn't be null");
String lowerCase = str.toLowerCase(Locale.ROOT);
lowerCase.hashCode();
char c = 65535;
switch (lowerCase.hashCode()) {
case -1875291391:
if (lowerCase.equals("image/x-fuji-raf")) {
c = 0;
break;
}
break;
case -1635437028:
if (lowerCase.equals("image/x-samsung-srw")) {
c = 1;
break;
}
break;
case -1594371159:
if (lowerCase.equals("image/x-sony-arw")) {
c = 2;
break;
}
break;
case -1487464693:
if (lowerCase.equals("image/heic")) {
c = 3;
break;
}
break;
case -1487464690:
if (lowerCase.equals("image/heif")) {
c = 4;
break;
}
break;
case -1487394660:
if (lowerCase.equals(MimeTypes.IMAGE_JPEG)) {
c = 5;
break;
}
break;
case -1487018032:
if (lowerCase.equals("image/webp")) {
c = 6;
break;
}
break;
case -1423313290:
if (lowerCase.equals("image/x-adobe-dng")) {
c = 7;
break;
}
break;
case -985160897:
if (lowerCase.equals("image/x-panasonic-rw2")) {
c = '\b';
break;
}
break;
case -879258763:
if (lowerCase.equals("image/png")) {
c = '\t';
break;
}
break;
case -332763809:
if (lowerCase.equals("image/x-pentax-pef")) {
c = '\n';
break;
}
break;
case 1378106698:
if (lowerCase.equals("image/x-olympus-orf")) {
c = 11;
break;
}
break;
case 2099152104:
if (lowerCase.equals("image/x-nikon-nef")) {
c = '\f';
break;
}
break;
case 2099152524:
if (lowerCase.equals("image/x-nikon-nrw")) {
c = '\r';
break;
}
break;
case 2111234748:
if (lowerCase.equals("image/x-canon-cr2")) {
c = 14;
break;
}
break;
}
switch (c) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case '\b':
case '\t':
case '\n':
case 11:
case '\f':
case '\r':
case 14:
return true;
default:
return false;
}
}
private boolean isThumbnail(HashMap hashMap) throws IOException {
ExifAttribute exifAttribute = (ExifAttribute) hashMap.get("ImageLength");
ExifAttribute exifAttribute2 = (ExifAttribute) hashMap.get("ImageWidth");
if (exifAttribute == null || exifAttribute2 == null) {
return false;
}
return exifAttribute.getIntValue(this.mExifByteOrder) <= 512 && exifAttribute2.getIntValue(this.mExifByteOrder) <= 512;
}
private boolean isWebpFormat(byte[] bArr) throws IOException {
int i2 = 0;
while (true) {
byte[] bArr2 = WEBP_SIGNATURE_1;
if (i2 >= bArr2.length) {
int i3 = 0;
while (true) {
byte[] bArr3 = WEBP_SIGNATURE_2;
if (i3 >= bArr3.length) {
return true;
}
if (bArr[WEBP_SIGNATURE_1.length + i3 + 4] != bArr3[i3]) {
return false;
}
i3++;
}
} else if (bArr[i2] != bArr2[i2]) {
return false;
} else {
i2++;
}
}
}
private void loadAttributes(InputStream inputStream) {
Objects.requireNonNull(inputStream, "inputstream shouldn't be null");
for (int i2 = 0; i2 < EXIF_TAGS.length; i2++) {
try {
try {
this.mAttributes[i2] = new HashMap<>();
} catch (IOException e2) {
boolean z = DEBUG;
if (z) {
Log.w(TAG, "Invalid image: ExifInterface got an unsupported image format file(ExifInterface supports JPEG and some RAW image formats only) or a corrupted JPEG file to ExifInterface.", e2);
}
addDefaultValuesForCompatibility();
if (!z) {
return;
}
}
} finally {
addDefaultValuesForCompatibility();
if (DEBUG) {
printAttributes();
}
}
}
if (!this.mIsExifDataOnly) {
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream, 5000);
this.mMimeType = getMimeType(bufferedInputStream);
inputStream = bufferedInputStream;
}
ByteOrderedDataInputStream byteOrderedDataInputStream = new ByteOrderedDataInputStream(inputStream);
if (!this.mIsExifDataOnly) {
switch (this.mMimeType) {
case 0:
case 1:
case 2:
case 3:
case 5:
case 6:
case 8:
case 11:
getRawAttributes(byteOrderedDataInputStream);
break;
case 4:
getJpegAttributes(byteOrderedDataInputStream, 0, 0);
addDefaultValuesForCompatibility();
if (DEBUG) {
printAttributes();
return;
}
return;
case 7:
getOrfAttributes(byteOrderedDataInputStream);
break;
case 9:
getRafAttributes(byteOrderedDataInputStream);
addDefaultValuesForCompatibility();
if (DEBUG) {
printAttributes();
return;
}
return;
case 10:
getRw2Attributes(byteOrderedDataInputStream);
addDefaultValuesForCompatibility();
if (DEBUG) {
printAttributes();
return;
}
return;
case 12:
getHeifAttributes(byteOrderedDataInputStream);
break;
case 13:
getPngAttributes(byteOrderedDataInputStream);
addDefaultValuesForCompatibility();
if (DEBUG) {
printAttributes();
return;
}
return;
case 14:
getWebpAttributes(byteOrderedDataInputStream);
addDefaultValuesForCompatibility();
if (DEBUG) {
printAttributes();
return;
}
return;
}
} else {
getStandaloneAttributes(byteOrderedDataInputStream);
}
byteOrderedDataInputStream.seek(this.mOffsetToExifData);
setThumbnailData(byteOrderedDataInputStream);
}
private static Long parseDateTime(String str, String str2, String str3) {
if (str != null && NON_ZERO_TIME_PATTERN.matcher(str).matches()) {
ParsePosition parsePosition = new ParsePosition(0);
try {
Date parse = sFormatterPrimary.parse(str, parsePosition);
if (parse == null && (parse = sFormatterSecondary.parse(str, parsePosition)) == null) {
return null;
}
long time = parse.getTime();
if (str3 != null) {
String substring = str3.substring(0, 1);
int parseInt = Integer.parseInt(str3.substring(1, 3));
int parseInt2 = Integer.parseInt(str3.substring(4, 6));
if (("+".equals(substring) || Operators.SUB.equals(substring)) && ":".equals(str3.substring(3, 4)) && parseInt <= 14) {
time += ((parseInt * 60) + parseInt2) * 60 * 1000 * (Operators.SUB.equals(substring) ? 1 : -1);
}
}
if (str2 != null) {
try {
long parseLong = Long.parseLong(str2);
while (parseLong > 1000) {
parseLong /= 10;
}
time += parseLong;
} catch (NumberFormatException unused) {
}
}
return Long.valueOf(time);
} catch (IllegalArgumentException unused2) {
}
}
return null;
}
private void parseTiffHeaders(ByteOrderedDataInputStream byteOrderedDataInputStream, int i2) throws IOException {
ByteOrder readByteOrder = readByteOrder(byteOrderedDataInputStream);
this.mExifByteOrder = readByteOrder;
byteOrderedDataInputStream.setByteOrder(readByteOrder);
int readUnsignedShort = byteOrderedDataInputStream.readUnsignedShort();
int i3 = this.mMimeType;
if (i3 != 7 && i3 != 10 && readUnsignedShort != 42) {
throw new IOException("Invalid start code: " + Integer.toHexString(readUnsignedShort));
}
int readInt = byteOrderedDataInputStream.readInt();
if (readInt >= 8 && readInt < i2) {
int i4 = readInt - 8;
if (i4 <= 0 || byteOrderedDataInputStream.skipBytes(i4) == i4) {
return;
}
throw new IOException("Couldn't jump to first Ifd: " + i4);
}
throw new IOException("Invalid first Ifd offset: " + readInt);
}
private void printAttributes() {
for (int i2 = 0; i2 < this.mAttributes.length; i2++) {
Log.d(TAG, "The size of tag group[" + i2 + "]: " + this.mAttributes[i2].size());
for (Map.Entry<String, ExifAttribute> entry : this.mAttributes[i2].entrySet()) {
ExifAttribute value = entry.getValue();
Log.d(TAG, "tagName: " + entry.getKey() + ", tagType: " + value.toString() + ", tagValue: '" + value.getStringValue(this.mExifByteOrder) + "'");
}
}
}
private ByteOrder readByteOrder(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
short readShort = byteOrderedDataInputStream.readShort();
if (readShort == 18761) {
if (DEBUG) {
Log.d(TAG, "readExifSegment: Byte Align II");
}
return ByteOrder.LITTLE_ENDIAN;
} else if (readShort == 19789) {
if (DEBUG) {
Log.d(TAG, "readExifSegment: Byte Align MM");
}
return ByteOrder.BIG_ENDIAN;
} else {
throw new IOException("Invalid byte order: " + Integer.toHexString(readShort));
}
}
private void readExifSegment(byte[] bArr, int i2) throws IOException {
ByteOrderedDataInputStream byteOrderedDataInputStream = new ByteOrderedDataInputStream(bArr);
parseTiffHeaders(byteOrderedDataInputStream, bArr.length);
readImageFileDirectory(byteOrderedDataInputStream, i2);
}
private void readImageFileDirectory(ByteOrderedDataInputStream byteOrderedDataInputStream, int i2) throws IOException {
String str;
short s;
int[] iArr;
long j2;
boolean z;
short s2;
ExifTag exifTag;
long j3;
int i3;
int i4;
long j4;
int readUnsignedShort;
long j5;
int i5 = i2;
this.mAttributesOffsets.add(Integer.valueOf(byteOrderedDataInputStream.mPosition));
if (byteOrderedDataInputStream.mPosition + 2 > byteOrderedDataInputStream.mLength) {
return;
}
short readShort = byteOrderedDataInputStream.readShort();
boolean z2 = DEBUG;
String str2 = TAG;
if (z2) {
Log.d(TAG, "numberOfDirectoryEntry: " + ((int) readShort));
}
if (byteOrderedDataInputStream.mPosition + (readShort * 12) > byteOrderedDataInputStream.mLength || readShort <= 0) {
return;
}
char c = 0;
short s3 = 0;
while (s3 < readShort) {
int readUnsignedShort2 = byteOrderedDataInputStream.readUnsignedShort();
int readUnsignedShort3 = byteOrderedDataInputStream.readUnsignedShort();
int readInt = byteOrderedDataInputStream.readInt();
long peek = byteOrderedDataInputStream.peek() + 4;
ExifTag exifTag2 = sExifTagMapsForReading[i5].get(Integer.valueOf(readUnsignedShort2));
boolean z3 = DEBUG;
if (z3) {
Object[] objArr = new Object[5];
objArr[c] = Integer.valueOf(i2);
objArr[1] = Integer.valueOf(readUnsignedShort2);
objArr[2] = exifTag2 != null ? exifTag2.name : null;
objArr[3] = Integer.valueOf(readUnsignedShort3);
objArr[4] = Integer.valueOf(readInt);
Log.d(str2, String.format("ifdType: %d, tagNumber: %d, tagName: %s, dataFormat: %d, numberOfComponents: %d", objArr));
}
if (exifTag2 != null) {
if (readUnsignedShort3 > 0) {
if (readUnsignedShort3 < IFD_FORMAT_BYTES_PER_FORMAT.length) {
if (exifTag2.isFormatCompatible(readUnsignedShort3)) {
if (readUnsignedShort3 == 7) {
readUnsignedShort3 = exifTag2.primaryFormat;
}
str = str2;
s = s3;
j2 = readInt * iArr[readUnsignedShort3];
if (j2 < 0 || j2 > 2147483647L) {
if (z3) {
Log.d(str, "Skip the tag entry since the number of components is invalid: " + readInt);
}
z = false;
if (z) {
byteOrderedDataInputStream.seek(peek);
s2 = readShort;
} else {
if (j2 > 4) {
int readInt2 = byteOrderedDataInputStream.readInt();
s2 = readShort;
if (z3) {
StringBuilder sb = new StringBuilder();
i3 = readUnsignedShort3;
sb.append("seek to data offset: ");
sb.append(readInt2);
Log.d(str, sb.toString());
} else {
i3 = readUnsignedShort3;
}
if (this.mMimeType == 7) {
if ("MakerNote".equals(exifTag2.name)) {
this.mOrfMakerNoteOffset = readInt2;
} else if (i5 == 6 && "ThumbnailImage".equals(exifTag2.name)) {
this.mOrfThumbnailOffset = readInt2;
this.mOrfThumbnailLength = readInt;
ExifAttribute createUShort = ExifAttribute.createUShort(6, this.mExifByteOrder);
i4 = readInt;
ExifAttribute createULong = ExifAttribute.createULong(this.mOrfThumbnailOffset, this.mExifByteOrder);
exifTag = exifTag2;
ExifAttribute createULong2 = ExifAttribute.createULong(this.mOrfThumbnailLength, this.mExifByteOrder);
this.mAttributes[4].put("Compression", createUShort);
this.mAttributes[4].put("JPEGInterchangeFormat", createULong);
this.mAttributes[4].put("JPEGInterchangeFormatLength", createULong2);
j5 = readInt2;
j3 = j2;
if (j5 + j2 > byteOrderedDataInputStream.mLength) {
byteOrderedDataInputStream.seek(j5);
} else {
if (z3) {
Log.d(str, "Skip the tag entry since data offset is invalid: " + readInt2);
}
byteOrderedDataInputStream.seek(peek);
}
}
}
exifTag = exifTag2;
i4 = readInt;
j5 = readInt2;
j3 = j2;
if (j5 + j2 > byteOrderedDataInputStream.mLength) {
}
} else {
s2 = readShort;
exifTag = exifTag2;
j3 = j2;
i3 = readUnsignedShort3;
i4 = readInt;
}
Integer num = sExifPointerTagMap.get(Integer.valueOf(readUnsignedShort2));
if (z3) {
StringBuilder sb2 = new StringBuilder();
sb2.append("nextIfdType: ");
sb2.append(num);
sb2.append(" byteCount: ");
j4 = j3;
sb2.append(j4);
Log.d(str, sb2.toString());
} else {
j4 = j3;
}
if (num != null) {
long j6 = -1;
int i6 = i3;
if (i6 == 3) {
readUnsignedShort = byteOrderedDataInputStream.readUnsignedShort();
} else {
if (i6 == 4) {
j6 = byteOrderedDataInputStream.readUnsignedInt();
} else if (i6 == 8) {
readUnsignedShort = byteOrderedDataInputStream.readShort();
} else if (i6 == 9 || i6 == 13) {
readUnsignedShort = byteOrderedDataInputStream.readInt();
}
if (z3) {
Log.d(str, String.format("Offset: %d, tagName: %s", Long.valueOf(j6), exifTag.name));
}
if (j6 > 0 || j6 >= byteOrderedDataInputStream.mLength) {
if (z3) {
Log.d(str, "Skip jump into the IFD since its offset is invalid: " + j6);
}
} else if (!this.mAttributesOffsets.contains(Integer.valueOf((int) j6))) {
byteOrderedDataInputStream.seek(j6);
readImageFileDirectory(byteOrderedDataInputStream, num.intValue());
} else if (z3) {
Log.d(str, "Skip jump into the IFD since it has already been read: IfdType " + num + " (at " + j6 + Operators.BRACKET_END_STR);
}
byteOrderedDataInputStream.seek(peek);
}
j6 = readUnsignedShort;
if (z3) {
}
if (j6 > 0) {
}
if (z3) {
}
byteOrderedDataInputStream.seek(peek);
} else {
ExifTag exifTag3 = exifTag;
int peek2 = byteOrderedDataInputStream.peek() + this.mOffsetToExifData;
byte[] bArr = new byte[(int) j4];
byteOrderedDataInputStream.readFully(bArr);
ExifAttribute exifAttribute = new ExifAttribute(i3, i4, peek2, bArr);
this.mAttributes[i2].put(exifTag3.name, exifAttribute);
if ("DNGVersion".equals(exifTag3.name)) {
this.mMimeType = 3;
}
if ((("Make".equals(exifTag3.name) || "Model".equals(exifTag3.name)) && exifAttribute.getStringValue(this.mExifByteOrder).contains(PEF_SIGNATURE)) || ("Compression".equals(exifTag3.name) && exifAttribute.getIntValue(this.mExifByteOrder) == 65535)) {
this.mMimeType = 8;
}
if (byteOrderedDataInputStream.peek() != peek) {
byteOrderedDataInputStream.seek(peek);
}
}
}
s3 = (short) (s + 1);
i5 = i2;
str2 = str;
readShort = s2;
c = 0;
} else {
z = true;
if (z) {
}
s3 = (short) (s + 1);
i5 = i2;
str2 = str;
readShort = s2;
c = 0;
}
} else if (z3) {
Log.d(str2, "Skip the tag entry since data format (" + IFD_FORMAT_NAMES[readUnsignedShort3] + ") is unexpected for tag: " + exifTag2.name);
}
}
}
str = str2;
s = s3;
if (z3) {
Log.d(str, "Skip the tag entry since data format is invalid: " + readUnsignedShort3);
}
j2 = 0;
z = false;
if (z) {
}
s3 = (short) (s + 1);
i5 = i2;
str2 = str;
readShort = s2;
c = 0;
} else if (z3) {
Log.d(str2, "Skip the tag entry since tag number is not defined: " + readUnsignedShort2);
}
str = str2;
s = s3;
j2 = 0;
z = false;
if (z) {
}
s3 = (short) (s + 1);
i5 = i2;
str2 = str;
readShort = s2;
c = 0;
}
String str3 = str2;
if (byteOrderedDataInputStream.peek() + 4 <= byteOrderedDataInputStream.mLength) {
int readInt3 = byteOrderedDataInputStream.readInt();
boolean z4 = DEBUG;
if (z4) {
Log.d(str3, String.format("nextIfdOffset: %d", Integer.valueOf(readInt3)));
}
long j7 = readInt3;
if (j7 <= 0 || readInt3 >= byteOrderedDataInputStream.mLength) {
if (z4) {
Log.d(str3, "Stop reading file since a wrong offset may cause an infinite loop: " + readInt3);
}
} else if (this.mAttributesOffsets.contains(Integer.valueOf(readInt3))) {
if (z4) {
Log.d(str3, "Stop reading file since re-reading an IFD may cause an infinite loop: " + readInt3);
}
} else {
byteOrderedDataInputStream.seek(j7);
if (this.mAttributes[4].isEmpty()) {
readImageFileDirectory(byteOrderedDataInputStream, 4);
} else if (this.mAttributes[5].isEmpty()) {
readImageFileDirectory(byteOrderedDataInputStream, 5);
}
}
}
}
private void removeAttribute(String str) {
for (int i2 = 0; i2 < EXIF_TAGS.length; i2++) {
this.mAttributes[i2].remove(str);
}
}
private void retrieveJpegImageSize(ByteOrderedDataInputStream byteOrderedDataInputStream, int i2) throws IOException {
ExifAttribute exifAttribute = this.mAttributes[i2].get("ImageLength");
ExifAttribute exifAttribute2 = this.mAttributes[i2].get("ImageWidth");
if (exifAttribute == null || exifAttribute2 == null) {
ExifAttribute exifAttribute3 = this.mAttributes[i2].get("JPEGInterchangeFormat");
ExifAttribute exifAttribute4 = this.mAttributes[i2].get("JPEGInterchangeFormatLength");
if (exifAttribute3 == null || exifAttribute4 == null) {
return;
}
int intValue = exifAttribute3.getIntValue(this.mExifByteOrder);
int intValue2 = exifAttribute3.getIntValue(this.mExifByteOrder);
byteOrderedDataInputStream.seek(intValue);
byte[] bArr = new byte[intValue2];
byteOrderedDataInputStream.read(bArr);
getJpegAttributes(new ByteOrderedDataInputStream(bArr), intValue, i2);
}
}
private void saveJpegAttributes(InputStream inputStream, OutputStream outputStream) throws IOException {
if (DEBUG) {
Log.d(TAG, "saveJpegAttributes starting with (inputStream: " + inputStream + ", outputStream: " + outputStream + Operators.BRACKET_END_STR);
}
DataInputStream dataInputStream = new DataInputStream(inputStream);
ByteOrderedDataOutputStream byteOrderedDataOutputStream = new ByteOrderedDataOutputStream(outputStream, ByteOrder.BIG_ENDIAN);
if (dataInputStream.readByte() == -1) {
byteOrderedDataOutputStream.writeByte(-1);
if (dataInputStream.readByte() == -40) {
byteOrderedDataOutputStream.writeByte(-40);
ExifAttribute exifAttribute = null;
if (getAttribute("Xmp") != null && this.mXmpIsFromSeparateMarker) {
exifAttribute = this.mAttributes[0].remove("Xmp");
}
byteOrderedDataOutputStream.writeByte(-1);
byteOrderedDataOutputStream.writeByte(-31);
writeExifSegment(byteOrderedDataOutputStream);
if (exifAttribute != null) {
this.mAttributes[0].put("Xmp", exifAttribute);
}
byte[] bArr = new byte[4096];
while (dataInputStream.readByte() == -1) {
byte readByte = dataInputStream.readByte();
if (readByte == -39 || readByte == -38) {
byteOrderedDataOutputStream.writeByte(-1);
byteOrderedDataOutputStream.writeByte(readByte);
copy(dataInputStream, byteOrderedDataOutputStream);
return;
} else if (readByte != -31) {
byteOrderedDataOutputStream.writeByte(-1);
byteOrderedDataOutputStream.writeByte(readByte);
int readUnsignedShort = dataInputStream.readUnsignedShort();
byteOrderedDataOutputStream.writeUnsignedShort(readUnsignedShort);
int i2 = readUnsignedShort - 2;
if (i2 < 0) {
throw new IOException("Invalid length");
}
while (i2 > 0) {
int read = dataInputStream.read(bArr, 0, Math.min(i2, 4096));
if (read >= 0) {
byteOrderedDataOutputStream.write(bArr, 0, read);
i2 -= read;
}
}
} else {
int readUnsignedShort2 = dataInputStream.readUnsignedShort() - 2;
if (readUnsignedShort2 >= 0) {
byte[] bArr2 = new byte[6];
if (readUnsignedShort2 >= 6) {
if (dataInputStream.read(bArr2) == 6) {
if (Arrays.equals(bArr2, IDENTIFIER_EXIF_APP1)) {
int i3 = readUnsignedShort2 - 6;
if (dataInputStream.skipBytes(i3) != i3) {
throw new IOException("Invalid length");
}
}
} else {
throw new IOException("Invalid exif");
}
}
byteOrderedDataOutputStream.writeByte(-1);
byteOrderedDataOutputStream.writeByte(readByte);
byteOrderedDataOutputStream.writeUnsignedShort(readUnsignedShort2 + 2);
if (readUnsignedShort2 >= 6) {
readUnsignedShort2 -= 6;
byteOrderedDataOutputStream.write(bArr2);
}
while (readUnsignedShort2 > 0) {
int read2 = dataInputStream.read(bArr, 0, Math.min(readUnsignedShort2, 4096));
if (read2 >= 0) {
byteOrderedDataOutputStream.write(bArr, 0, read2);
readUnsignedShort2 -= read2;
}
}
} else {
throw new IOException("Invalid length");
}
}
}
throw new IOException("Invalid marker");
}
throw new IOException("Invalid marker");
}
throw new IOException("Invalid marker");
}
private void savePngAttributes(InputStream inputStream, OutputStream outputStream) throws IOException {
ByteArrayOutputStream byteArrayOutputStream;
if (DEBUG) {
Log.d(TAG, "savePngAttributes starting with (inputStream: " + inputStream + ", outputStream: " + outputStream + Operators.BRACKET_END_STR);
}
DataInputStream dataInputStream = new DataInputStream(inputStream);
ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
ByteOrderedDataOutputStream byteOrderedDataOutputStream = new ByteOrderedDataOutputStream(outputStream, byteOrder);
byte[] bArr = PNG_SIGNATURE;
copy(dataInputStream, byteOrderedDataOutputStream, bArr.length);
int i2 = this.mOffsetToExifData;
if (i2 == 0) {
int readInt = dataInputStream.readInt();
byteOrderedDataOutputStream.writeInt(readInt);
copy(dataInputStream, byteOrderedDataOutputStream, readInt + 4 + 4);
} else {
copy(dataInputStream, byteOrderedDataOutputStream, ((i2 - bArr.length) - 4) - 4);
dataInputStream.skipBytes(dataInputStream.readInt() + 4 + 4);
}
ByteArrayOutputStream byteArrayOutputStream2 = null;
try {
byteArrayOutputStream = new ByteArrayOutputStream();
} catch (Throwable th) {
th = th;
}
try {
ByteOrderedDataOutputStream byteOrderedDataOutputStream2 = new ByteOrderedDataOutputStream(byteArrayOutputStream, byteOrder);
writeExifSegment(byteOrderedDataOutputStream2);
byte[] byteArray = ((ByteArrayOutputStream) byteOrderedDataOutputStream2.mOutputStream).toByteArray();
byteOrderedDataOutputStream.write(byteArray);
CRC32 crc32 = new CRC32();
crc32.update(byteArray, 4, byteArray.length - 4);
byteOrderedDataOutputStream.writeInt((int) crc32.getValue());
closeQuietly(byteArrayOutputStream);
copy(dataInputStream, byteOrderedDataOutputStream);
} catch (Throwable th2) {
th = th2;
byteArrayOutputStream2 = byteArrayOutputStream;
closeQuietly(byteArrayOutputStream2);
throw th;
}
}
private void saveWebpAttributes(InputStream inputStream, OutputStream outputStream) throws IOException {
ByteArrayOutputStream byteArrayOutputStream;
int i2;
int i3;
int i4;
int i5;
if (DEBUG) {
Log.d(TAG, "saveWebpAttributes starting with (inputStream: " + inputStream + ", outputStream: " + outputStream + Operators.BRACKET_END_STR);
}
ByteOrder byteOrder = ByteOrder.LITTLE_ENDIAN;
ByteOrderedDataInputStream byteOrderedDataInputStream = new ByteOrderedDataInputStream(inputStream, byteOrder);
ByteOrderedDataOutputStream byteOrderedDataOutputStream = new ByteOrderedDataOutputStream(outputStream, byteOrder);
byte[] bArr = WEBP_SIGNATURE_1;
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream, bArr.length);
byte[] bArr2 = WEBP_SIGNATURE_2;
byteOrderedDataInputStream.skipBytes(bArr2.length + 4);
ByteArrayOutputStream byteArrayOutputStream2 = null;
try {
try {
byteArrayOutputStream = new ByteArrayOutputStream();
} catch (Exception e2) {
e = e2;
}
} catch (Throwable th) {
th = th;
}
try {
ByteOrderedDataOutputStream byteOrderedDataOutputStream2 = new ByteOrderedDataOutputStream(byteArrayOutputStream, byteOrder);
int i6 = this.mOffsetToExifData;
if (i6 != 0) {
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream2, ((i6 - ((bArr.length + 4) + bArr2.length)) - 4) - 4);
byteOrderedDataInputStream.skipBytes(4);
byteOrderedDataInputStream.skipBytes(byteOrderedDataInputStream.readInt());
writeExifSegment(byteOrderedDataOutputStream2);
} else {
byte[] bArr3 = new byte[4];
if (byteOrderedDataInputStream.read(bArr3) == 4) {
byte[] bArr4 = WEBP_CHUNK_TYPE_VP8X;
boolean z = true;
if (Arrays.equals(bArr3, bArr4)) {
int readInt = byteOrderedDataInputStream.readInt();
byte[] bArr5 = new byte[readInt % 2 == 1 ? readInt + 1 : readInt];
byteOrderedDataInputStream.read(bArr5);
bArr5[0] = (byte) (8 | bArr5[0]);
if (((bArr5[0] >> 1) & 1) != 1) {
z = false;
}
byteOrderedDataOutputStream2.write(bArr4);
byteOrderedDataOutputStream2.writeInt(readInt);
byteOrderedDataOutputStream2.write(bArr5);
if (z) {
copyChunksUpToGivenChunkType(byteOrderedDataInputStream, byteOrderedDataOutputStream2, WEBP_CHUNK_TYPE_ANIM, null);
while (true) {
byte[] bArr6 = new byte[4];
inputStream.read(bArr6);
if (!Arrays.equals(bArr6, WEBP_CHUNK_TYPE_ANMF)) {
break;
}
copyWebPChunk(byteOrderedDataInputStream, byteOrderedDataOutputStream2, bArr6);
}
writeExifSegment(byteOrderedDataOutputStream2);
} else {
copyChunksUpToGivenChunkType(byteOrderedDataInputStream, byteOrderedDataOutputStream2, WEBP_CHUNK_TYPE_VP8, WEBP_CHUNK_TYPE_VP8L);
writeExifSegment(byteOrderedDataOutputStream2);
}
} else {
byte[] bArr7 = WEBP_CHUNK_TYPE_VP8;
if (Arrays.equals(bArr3, bArr7) || Arrays.equals(bArr3, WEBP_CHUNK_TYPE_VP8L)) {
int readInt2 = byteOrderedDataInputStream.readInt();
int i7 = readInt2 % 2 == 1 ? readInt2 + 1 : readInt2;
byte[] bArr8 = new byte[3];
if (Arrays.equals(bArr3, bArr7)) {
byteOrderedDataInputStream.read(bArr8);
byte[] bArr9 = new byte[3];
if (byteOrderedDataInputStream.read(bArr9) == 3 && Arrays.equals(WEBP_VP8_SIGNATURE, bArr9)) {
i2 = byteOrderedDataInputStream.readInt();
i3 = (i2 << 18) >> 18;
i4 = (i2 << 2) >> 18;
i7 -= 10;
i5 = 0;
} else {
throw new IOException("Encountered error while checking VP8 signature");
}
} else if (!Arrays.equals(bArr3, WEBP_CHUNK_TYPE_VP8L)) {
i2 = 0;
i3 = 0;
i4 = 0;
i5 = 0;
} else if (byteOrderedDataInputStream.readByte() == 47) {
i2 = byteOrderedDataInputStream.readInt();
i5 = i2 & 8;
i7 -= 5;
i4 = ((i2 << 4) >> 18) + 1;
i3 = ((i2 << 18) >> 18) + 1;
} else {
throw new IOException("Encountered error while checking VP8L signature");
}
byteOrderedDataOutputStream2.write(bArr4);
byteOrderedDataOutputStream2.writeInt(10);
byte[] bArr10 = new byte[10];
bArr10[0] = (byte) (bArr10[0] | 8);
bArr10[0] = (byte) (bArr10[0] | (i5 << 4));
int i8 = i3 - 1;
int i9 = i4 - 1;
bArr10[4] = (byte) i8;
bArr10[5] = (byte) (i8 >> 8);
bArr10[6] = (byte) (i8 >> 16);
bArr10[7] = (byte) i9;
bArr10[8] = (byte) (i9 >> 8);
bArr10[9] = (byte) (i9 >> 16);
byteOrderedDataOutputStream2.write(bArr10);
byteOrderedDataOutputStream2.write(bArr3);
byteOrderedDataOutputStream2.writeInt(readInt2);
if (Arrays.equals(bArr3, bArr7)) {
byteOrderedDataOutputStream2.write(bArr8);
byteOrderedDataOutputStream2.write(WEBP_VP8_SIGNATURE);
byteOrderedDataOutputStream2.writeInt(i2);
} else if (Arrays.equals(bArr3, WEBP_CHUNK_TYPE_VP8L)) {
byteOrderedDataOutputStream2.write(47);
byteOrderedDataOutputStream2.writeInt(i2);
}
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream2, i7);
writeExifSegment(byteOrderedDataOutputStream2);
}
}
} else {
throw new IOException("Encountered invalid length while parsing WebP chunk type");
}
}
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream2);
int size = byteArrayOutputStream.size();
byte[] bArr11 = WEBP_SIGNATURE_2;
byteOrderedDataOutputStream.writeInt(size + bArr11.length);
byteOrderedDataOutputStream.write(bArr11);
byteArrayOutputStream.writeTo(byteOrderedDataOutputStream);
closeQuietly(byteArrayOutputStream);
} catch (Exception e3) {
e = e3;
byteArrayOutputStream2 = byteArrayOutputStream;
throw new IOException("Failed to save WebP file", e);
} catch (Throwable th2) {
th = th2;
byteArrayOutputStream2 = byteArrayOutputStream;
closeQuietly(byteArrayOutputStream2);
throw th;
}
}
private void setThumbnailData(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
HashMap<String, ExifAttribute> hashMap = this.mAttributes[4];
ExifAttribute exifAttribute = hashMap.get("Compression");
if (exifAttribute != null) {
int intValue = exifAttribute.getIntValue(this.mExifByteOrder);
this.mThumbnailCompression = intValue;
if (intValue != 1) {
if (intValue == 6) {
handleThumbnailFromJfif(byteOrderedDataInputStream, hashMap);
return;
} else if (intValue != 7) {
return;
}
}
if (isSupportedDataType(hashMap)) {
handleThumbnailFromStrips(byteOrderedDataInputStream, hashMap);
return;
}
return;
}
this.mThumbnailCompression = 6;
handleThumbnailFromJfif(byteOrderedDataInputStream, hashMap);
}
private static boolean startsWith(byte[] bArr, byte[] bArr2) {
if (bArr == null || bArr2 == null || bArr.length < bArr2.length) {
return false;
}
for (int i2 = 0; i2 < bArr2.length; i2++) {
if (bArr[i2] != bArr2[i2]) {
return false;
}
}
return true;
}
private void swapBasedOnImageSize(int i2, int i3) throws IOException {
if (!this.mAttributes[i2].isEmpty() && !this.mAttributes[i3].isEmpty()) {
ExifAttribute exifAttribute = this.mAttributes[i2].get("ImageLength");
ExifAttribute exifAttribute2 = this.mAttributes[i2].get("ImageWidth");
ExifAttribute exifAttribute3 = this.mAttributes[i3].get("ImageLength");
ExifAttribute exifAttribute4 = this.mAttributes[i3].get("ImageWidth");
if (exifAttribute == null || exifAttribute2 == null) {
if (DEBUG) {
Log.d(TAG, "First image does not contain valid size information");
}
} else if (exifAttribute3 != null && exifAttribute4 != null) {
int intValue = exifAttribute.getIntValue(this.mExifByteOrder);
int intValue2 = exifAttribute2.getIntValue(this.mExifByteOrder);
int intValue3 = exifAttribute3.getIntValue(this.mExifByteOrder);
int intValue4 = exifAttribute4.getIntValue(this.mExifByteOrder);
if (intValue >= intValue3 || intValue2 >= intValue4) {
return;
}
HashMap<String, ExifAttribute>[] hashMapArr = this.mAttributes;
HashMap<String, ExifAttribute> hashMap = hashMapArr[i2];
hashMapArr[i2] = hashMapArr[i3];
hashMapArr[i3] = hashMap;
} else if (DEBUG) {
Log.d(TAG, "Second image does not contain valid size information");
}
} else if (DEBUG) {
Log.d(TAG, "Cannot perform swap since only one image data exists");
}
}
private void updateImageSizeValues(ByteOrderedDataInputStream byteOrderedDataInputStream, int i2) throws IOException {
ExifAttribute createUShort;
ExifAttribute createUShort2;
ExifAttribute exifAttribute = this.mAttributes[i2].get("DefaultCropSize");
ExifAttribute exifAttribute2 = this.mAttributes[i2].get("SensorTopBorder");
ExifAttribute exifAttribute3 = this.mAttributes[i2].get("SensorLeftBorder");
ExifAttribute exifAttribute4 = this.mAttributes[i2].get("SensorBottomBorder");
ExifAttribute exifAttribute5 = this.mAttributes[i2].get("SensorRightBorder");
if (exifAttribute == null) {
if (exifAttribute2 != null && exifAttribute3 != null && exifAttribute4 != null && exifAttribute5 != null) {
int intValue = exifAttribute2.getIntValue(this.mExifByteOrder);
int intValue2 = exifAttribute4.getIntValue(this.mExifByteOrder);
int intValue3 = exifAttribute5.getIntValue(this.mExifByteOrder);
int intValue4 = exifAttribute3.getIntValue(this.mExifByteOrder);
if (intValue2 <= intValue || intValue3 <= intValue4) {
return;
}
ExifAttribute createUShort3 = ExifAttribute.createUShort(intValue2 - intValue, this.mExifByteOrder);
ExifAttribute createUShort4 = ExifAttribute.createUShort(intValue3 - intValue4, this.mExifByteOrder);
this.mAttributes[i2].put("ImageLength", createUShort3);
this.mAttributes[i2].put("ImageWidth", createUShort4);
return;
}
retrieveJpegImageSize(byteOrderedDataInputStream, i2);
return;
}
if (exifAttribute.format == 5) {
Rational[] rationalArr = (Rational[]) exifAttribute.getValue(this.mExifByteOrder);
if (rationalArr != null && rationalArr.length == 2) {
createUShort = ExifAttribute.createURational(rationalArr[0], this.mExifByteOrder);
createUShort2 = ExifAttribute.createURational(rationalArr[1], this.mExifByteOrder);
} else {
Log.w(TAG, "Invalid crop size values. cropSize=" + Arrays.toString(rationalArr));
return;
}
} else {
int[] iArr = (int[]) exifAttribute.getValue(this.mExifByteOrder);
if (iArr != null && iArr.length == 2) {
createUShort = ExifAttribute.createUShort(iArr[0], this.mExifByteOrder);
createUShort2 = ExifAttribute.createUShort(iArr[1], this.mExifByteOrder);
} else {
Log.w(TAG, "Invalid crop size values. cropSize=" + Arrays.toString(iArr));
return;
}
}
this.mAttributes[i2].put("ImageWidth", createUShort);
this.mAttributes[i2].put("ImageLength", createUShort2);
}
private void validateImages() throws IOException {
swapBasedOnImageSize(0, 5);
swapBasedOnImageSize(0, 4);
swapBasedOnImageSize(5, 4);
ExifAttribute exifAttribute = this.mAttributes[1].get("PixelXDimension");
ExifAttribute exifAttribute2 = this.mAttributes[1].get("PixelYDimension");
if (exifAttribute != null && exifAttribute2 != null) {
this.mAttributes[0].put("ImageWidth", exifAttribute);
this.mAttributes[0].put("ImageLength", exifAttribute2);
}
if (this.mAttributes[4].isEmpty() && isThumbnail(this.mAttributes[5])) {
HashMap<String, ExifAttribute>[] hashMapArr = this.mAttributes;
hashMapArr[4] = hashMapArr[5];
hashMapArr[5] = new HashMap<>();
}
if (isThumbnail(this.mAttributes[4])) {
return;
}
Log.d(TAG, "No image meets the size requirements of a thumbnail image.");
}
private int writeExifSegment(ByteOrderedDataOutputStream byteOrderedDataOutputStream) throws IOException {
ExifTag[][] exifTagArr = EXIF_TAGS;
int[] iArr = new int[exifTagArr.length];
int[] iArr2 = new int[exifTagArr.length];
for (ExifTag exifTag : EXIF_POINTER_TAGS) {
removeAttribute(exifTag.name);
}
removeAttribute(JPEG_INTERCHANGE_FORMAT_TAG.name);
removeAttribute(JPEG_INTERCHANGE_FORMAT_LENGTH_TAG.name);
for (int i2 = 0; i2 < EXIF_TAGS.length; i2++) {
for (Object obj : this.mAttributes[i2].entrySet().toArray()) {
Map.Entry entry = (Map.Entry) obj;
if (entry.getValue() == null) {
this.mAttributes[i2].remove(entry.getKey());
}
}
}
if (!this.mAttributes[1].isEmpty()) {
this.mAttributes[0].put(EXIF_POINTER_TAGS[1].name, ExifAttribute.createULong(0L, this.mExifByteOrder));
}
if (!this.mAttributes[2].isEmpty()) {
this.mAttributes[0].put(EXIF_POINTER_TAGS[2].name, ExifAttribute.createULong(0L, this.mExifByteOrder));
}
if (!this.mAttributes[3].isEmpty()) {
this.mAttributes[1].put(EXIF_POINTER_TAGS[3].name, ExifAttribute.createULong(0L, this.mExifByteOrder));
}
if (this.mHasThumbnail) {
this.mAttributes[4].put(JPEG_INTERCHANGE_FORMAT_TAG.name, ExifAttribute.createULong(0L, this.mExifByteOrder));
this.mAttributes[4].put(JPEG_INTERCHANGE_FORMAT_LENGTH_TAG.name, ExifAttribute.createULong(this.mThumbnailLength, this.mExifByteOrder));
}
for (int i3 = 0; i3 < EXIF_TAGS.length; i3++) {
int i4 = 0;
for (Map.Entry<String, ExifAttribute> entry2 : this.mAttributes[i3].entrySet()) {
int size = entry2.getValue().size();
if (size > 4) {
i4 += size;
}
}
iArr2[i3] = iArr2[i3] + i4;
}
int i5 = 8;
for (int i6 = 0; i6 < EXIF_TAGS.length; i6++) {
if (!this.mAttributes[i6].isEmpty()) {
iArr[i6] = i5;
i5 += (this.mAttributes[i6].size() * 12) + 2 + 4 + iArr2[i6];
}
}
if (this.mHasThumbnail) {
this.mAttributes[4].put(JPEG_INTERCHANGE_FORMAT_TAG.name, ExifAttribute.createULong(i5, this.mExifByteOrder));
this.mThumbnailOffset = i5;
i5 += this.mThumbnailLength;
}
if (this.mMimeType == 4) {
i5 += 8;
}
if (DEBUG) {
for (int i7 = 0; i7 < EXIF_TAGS.length; i7++) {
Log.d(TAG, String.format("index: %d, offsets: %d, tag count: %d, data sizes: %d, total size: %d", Integer.valueOf(i7), Integer.valueOf(iArr[i7]), Integer.valueOf(this.mAttributes[i7].size()), Integer.valueOf(iArr2[i7]), Integer.valueOf(i5)));
}
}
if (!this.mAttributes[1].isEmpty()) {
this.mAttributes[0].put(EXIF_POINTER_TAGS[1].name, ExifAttribute.createULong(iArr[1], this.mExifByteOrder));
}
if (!this.mAttributes[2].isEmpty()) {
this.mAttributes[0].put(EXIF_POINTER_TAGS[2].name, ExifAttribute.createULong(iArr[2], this.mExifByteOrder));
}
if (!this.mAttributes[3].isEmpty()) {
this.mAttributes[1].put(EXIF_POINTER_TAGS[3].name, ExifAttribute.createULong(iArr[3], this.mExifByteOrder));
}
int i8 = this.mMimeType;
if (i8 == 4) {
byteOrderedDataOutputStream.writeUnsignedShort(i5);
byteOrderedDataOutputStream.write(IDENTIFIER_EXIF_APP1);
} else if (i8 == 13) {
byteOrderedDataOutputStream.writeInt(i5);
byteOrderedDataOutputStream.write(PNG_CHUNK_TYPE_EXIF);
} else if (i8 == 14) {
byteOrderedDataOutputStream.write(WEBP_CHUNK_TYPE_EXIF);
byteOrderedDataOutputStream.writeInt(i5);
}
byteOrderedDataOutputStream.writeShort(this.mExifByteOrder == ByteOrder.BIG_ENDIAN ? (short) 19789 : (short) 18761);
byteOrderedDataOutputStream.setByteOrder(this.mExifByteOrder);
byteOrderedDataOutputStream.writeUnsignedShort(42);
byteOrderedDataOutputStream.writeUnsignedInt(8L);
for (int i9 = 0; i9 < EXIF_TAGS.length; i9++) {
if (!this.mAttributes[i9].isEmpty()) {
byteOrderedDataOutputStream.writeUnsignedShort(this.mAttributes[i9].size());
int size2 = iArr[i9] + 2 + (this.mAttributes[i9].size() * 12) + 4;
for (Map.Entry<String, ExifAttribute> entry3 : this.mAttributes[i9].entrySet()) {
int i10 = sExifTagMapsForWriting[i9].get(entry3.getKey()).number;
ExifAttribute value = entry3.getValue();
int size3 = value.size();
byteOrderedDataOutputStream.writeUnsignedShort(i10);
byteOrderedDataOutputStream.writeUnsignedShort(value.format);
byteOrderedDataOutputStream.writeInt(value.numberOfComponents);
if (size3 > 4) {
byteOrderedDataOutputStream.writeUnsignedInt(size2);
size2 += size3;
} else {
byteOrderedDataOutputStream.write(value.bytes);
if (size3 < 4) {
while (size3 < 4) {
byteOrderedDataOutputStream.writeByte(0);
size3++;
}
}
}
}
if (i9 == 0 && !this.mAttributes[4].isEmpty()) {
byteOrderedDataOutputStream.writeUnsignedInt(iArr[4]);
} else {
byteOrderedDataOutputStream.writeUnsignedInt(0L);
}
for (Map.Entry<String, ExifAttribute> entry4 : this.mAttributes[i9].entrySet()) {
byte[] bArr = entry4.getValue().bytes;
if (bArr.length > 4) {
byteOrderedDataOutputStream.write(bArr, 0, bArr.length);
}
}
}
}
if (this.mHasThumbnail) {
byteOrderedDataOutputStream.write(getThumbnailBytes());
}
if (this.mMimeType == 14 && i5 % 2 == 1) {
byteOrderedDataOutputStream.writeByte(0);
}
byteOrderedDataOutputStream.setByteOrder(ByteOrder.BIG_ENDIAN);
return i5;
}
public void flipHorizontally() {
int i2 = 1;
switch (getAttributeInt("Orientation", 1)) {
case 1:
i2 = 2;
break;
case 2:
break;
case 3:
i2 = 4;
break;
case 4:
i2 = 3;
break;
case 5:
i2 = 6;
break;
case 6:
i2 = 5;
break;
case 7:
i2 = 8;
break;
case 8:
i2 = 7;
break;
default:
i2 = 0;
break;
}
setAttribute("Orientation", Integer.toString(i2));
}
public void flipVertically() {
int i2 = 1;
switch (getAttributeInt("Orientation", 1)) {
case 1:
i2 = 4;
break;
case 2:
i2 = 3;
break;
case 3:
i2 = 2;
break;
case 4:
break;
case 5:
i2 = 8;
break;
case 6:
i2 = 7;
break;
case 7:
i2 = 6;
break;
case 8:
i2 = 5;
break;
default:
i2 = 0;
break;
}
setAttribute("Orientation", Integer.toString(i2));
}
public double getAltitude(double d2) {
double attributeDouble = getAttributeDouble("GPSAltitude", -1.0d);
int attributeInt = getAttributeInt("GPSAltitudeRef", -1);
if (attributeDouble < ShadowDrawableWrapper.COS_45 || attributeInt < 0) {
return d2;
}
return attributeDouble * (attributeInt != 1 ? 1 : -1);
}
public String getAttribute(String str) {
Objects.requireNonNull(str, "tag shouldn't be null");
ExifAttribute exifAttribute = getExifAttribute(str);
if (exifAttribute != null) {
if (!sTagSetForCompatibility.contains(str)) {
return exifAttribute.getStringValue(this.mExifByteOrder);
}
if (str.equals("GPSTimeStamp")) {
int i2 = exifAttribute.format;
if (i2 != 5 && i2 != 10) {
Log.w(TAG, "GPS Timestamp format is not rational. format=" + exifAttribute.format);
return null;
}
Rational[] rationalArr = (Rational[]) exifAttribute.getValue(this.mExifByteOrder);
if (rationalArr != null && rationalArr.length == 3) {
return String.format("%02d:%02d:%02d", Integer.valueOf((int) (((float) rationalArr[0].numerator) / ((float) rationalArr[0].denominator))), Integer.valueOf((int) (((float) rationalArr[1].numerator) / ((float) rationalArr[1].denominator))), Integer.valueOf((int) (((float) rationalArr[2].numerator) / ((float) rationalArr[2].denominator))));
}
Log.w(TAG, "Invalid GPS Timestamp array. array=" + Arrays.toString(rationalArr));
return null;
}
try {
return Double.toString(exifAttribute.getDoubleValue(this.mExifByteOrder));
} catch (NumberFormatException unused) {
}
}
return null;
}
public byte[] getAttributeBytes(String str) {
Objects.requireNonNull(str, "tag shouldn't be null");
ExifAttribute exifAttribute = getExifAttribute(str);
if (exifAttribute != null) {
return exifAttribute.bytes;
}
return null;
}
public double getAttributeDouble(String str, double d2) {
Objects.requireNonNull(str, "tag shouldn't be null");
ExifAttribute exifAttribute = getExifAttribute(str);
if (exifAttribute == null) {
return d2;
}
try {
return exifAttribute.getDoubleValue(this.mExifByteOrder);
} catch (NumberFormatException unused) {
return d2;
}
}
public int getAttributeInt(String str, int i2) {
Objects.requireNonNull(str, "tag shouldn't be null");
ExifAttribute exifAttribute = getExifAttribute(str);
if (exifAttribute == null) {
return i2;
}
try {
return exifAttribute.getIntValue(this.mExifByteOrder);
} catch (NumberFormatException unused) {
return i2;
}
}
public long[] getAttributeRange(String str) {
Objects.requireNonNull(str, "tag shouldn't be null");
if (!this.mModified) {
ExifAttribute exifAttribute = getExifAttribute(str);
if (exifAttribute != null) {
return new long[]{exifAttribute.bytesOffset, exifAttribute.bytes.length};
}
return null;
}
throw new IllegalStateException("The underlying file has been modified since being parsed");
}
public Long getDateTime() {
return parseDateTime(getAttribute("DateTime"), getAttribute("SubSecTime"), getAttribute("OffsetTime"));
}
public Long getDateTimeDigitized() {
return parseDateTime(getAttribute("DateTimeDigitized"), getAttribute("SubSecTimeDigitized"), getAttribute("OffsetTimeDigitized"));
}
public Long getDateTimeOriginal() {
return parseDateTime(getAttribute("DateTimeOriginal"), getAttribute("SubSecTimeOriginal"), getAttribute("OffsetTimeOriginal"));
}
public Long getGpsDateTime() {
String attribute = getAttribute("GPSDateStamp");
String attribute2 = getAttribute("GPSTimeStamp");
if (attribute != null && attribute2 != null) {
Pattern pattern = NON_ZERO_TIME_PATTERN;
if (pattern.matcher(attribute).matches() || pattern.matcher(attribute2).matches()) {
String str = attribute + ' ' + attribute2;
ParsePosition parsePosition = new ParsePosition(0);
try {
Date parse = sFormatterPrimary.parse(str, parsePosition);
if (parse == null && (parse = sFormatterSecondary.parse(str, parsePosition)) == null) {
return null;
}
return Long.valueOf(parse.getTime());
} catch (IllegalArgumentException unused) {
}
}
}
return null;
}
@Deprecated
public boolean getLatLong(float[] fArr) {
double[] latLong = getLatLong();
if (latLong == null) {
return false;
}
fArr[0] = (float) latLong[0];
fArr[1] = (float) latLong[1];
return true;
}
public int getRotationDegrees() {
switch (getAttributeInt("Orientation", 1)) {
case 3:
case 4:
return 180;
case 5:
case 8:
return 270;
case 6:
case 7:
return 90;
default:
return 0;
}
}
public byte[] getThumbnail() {
int i2 = this.mThumbnailCompression;
if (i2 == 6 || i2 == 7) {
return getThumbnailBytes();
}
return null;
}
public Bitmap getThumbnailBitmap() {
if (this.mHasThumbnail) {
if (this.mThumbnailBytes == null) {
this.mThumbnailBytes = getThumbnailBytes();
}
int i2 = this.mThumbnailCompression;
if (i2 == 6 || i2 == 7) {
return BitmapFactory.decodeByteArray(this.mThumbnailBytes, 0, this.mThumbnailLength);
}
if (i2 == 1) {
int length = this.mThumbnailBytes.length / 3;
int[] iArr = new int[length];
for (int i3 = 0; i3 < length; i3++) {
byte[] bArr = this.mThumbnailBytes;
int i4 = i3 * 3;
iArr[i3] = (bArr[i4] << Ascii.DLE) + 0 + (bArr[i4 + 1] << 8) + bArr[i4 + 2];
}
ExifAttribute exifAttribute = this.mAttributes[4].get("ImageLength");
ExifAttribute exifAttribute2 = this.mAttributes[4].get("ImageWidth");
if (exifAttribute != null && exifAttribute2 != null) {
return Bitmap.createBitmap(iArr, exifAttribute2.getIntValue(this.mExifByteOrder), exifAttribute.getIntValue(this.mExifByteOrder), Bitmap.Config.ARGB_8888);
}
}
return null;
}
return null;
}
public byte[] getThumbnailBytes() {
FileDescriptor fileDescriptor;
Object obj;
FileDescriptor fileDescriptor2;
Exception e2;
InputStream inputStream;
FileDescriptor fileDescriptor3;
InputStream inputStream2 = null;
if (!this.mHasThumbnail) {
return null;
}
byte[] bArr = this.mThumbnailBytes;
if (bArr != null) {
return bArr;
}
try {
inputStream = this.mAssetInputStream;
} catch (Exception e3) {
e = e3;
obj = null;
} catch (Throwable th) {
th = th;
fileDescriptor = 0;
}
try {
if (inputStream != null) {
try {
if (inputStream.markSupported()) {
inputStream.reset();
} else {
Log.d(TAG, "Cannot read thumbnail from inputstream without mark/reset support");
closeQuietly(inputStream);
return null;
}
} catch (Exception e4) {
e2 = e4;
fileDescriptor2 = 0;
try {
Log.d(TAG, "Encountered exception while getting thumbnail", e2);
closeQuietly(inputStream);
if (fileDescriptor2 != 0) {
}
return null;
} catch (Throwable th2) {
th = th2;
inputStream2 = fileDescriptor2;
InputStream inputStream3 = inputStream2;
inputStream2 = inputStream;
fileDescriptor = inputStream3;
closeQuietly(inputStream2);
if (fileDescriptor != 0) {
closeFileDescriptor(fileDescriptor);
}
throw th;
}
} catch (Throwable th3) {
th = th3;
InputStream inputStream32 = inputStream2;
inputStream2 = inputStream;
fileDescriptor = inputStream32;
closeQuietly(inputStream2);
if (fileDescriptor != 0) {
}
throw th;
}
} else if (this.mFilename != null) {
inputStream = new FileInputStream(this.mFilename);
} else {
if (Build.VERSION.SDK_INT >= 21) {
fileDescriptor = Os.dup(this.mSeekableFileDescriptor);
try {
Os.lseek(fileDescriptor, 0L, OsConstants.SEEK_SET);
fileDescriptor3 = fileDescriptor;
inputStream = new FileInputStream(fileDescriptor);
} catch (Exception e5) {
obj = fileDescriptor;
e = e5;
fileDescriptor2 = obj;
e2 = e;
inputStream = null;
Log.d(TAG, "Encountered exception while getting thumbnail", e2);
closeQuietly(inputStream);
if (fileDescriptor2 != 0) {
closeFileDescriptor(fileDescriptor2);
}
return null;
} catch (Throwable th4) {
th = th4;
closeQuietly(inputStream2);
if (fileDescriptor != 0) {
}
throw th;
}
} else {
inputStream = null;
fileDescriptor3 = 0;
}
if (inputStream == null) {
if (inputStream.skip(this.mThumbnailOffset + this.mOffsetToExifData) == this.mThumbnailOffset + this.mOffsetToExifData) {
byte[] bArr2 = new byte[this.mThumbnailLength];
if (inputStream.read(bArr2) == this.mThumbnailLength) {
this.mThumbnailBytes = bArr2;
closeQuietly(inputStream);
if (fileDescriptor3 != 0) {
closeFileDescriptor(fileDescriptor3);
}
return bArr2;
}
throw new IOException("Corrupted image");
}
throw new IOException("Corrupted image");
}
throw new FileNotFoundException();
}
if (inputStream == null) {
}
} catch (Exception e6) {
fileDescriptor2 = fileDescriptor3;
e2 = e6;
Log.d(TAG, "Encountered exception while getting thumbnail", e2);
closeQuietly(inputStream);
if (fileDescriptor2 != 0) {
}
return null;
} catch (Throwable th5) {
th = th5;
inputStream2 = fileDescriptor3;
InputStream inputStream322 = inputStream2;
inputStream2 = inputStream;
fileDescriptor = inputStream322;
closeQuietly(inputStream2);
if (fileDescriptor != 0) {
}
throw th;
}
fileDescriptor3 = 0;
}
public long[] getThumbnailRange() {
if (!this.mModified) {
if (this.mHasThumbnail) {
if (!this.mHasThumbnailStrips || this.mAreThumbnailStripsConsecutive) {
return new long[]{this.mThumbnailOffset + this.mOffsetToExifData, this.mThumbnailLength};
}
return null;
}
return null;
}
throw new IllegalStateException("The underlying file has been modified since being parsed");
}
public boolean hasAttribute(String str) {
return getExifAttribute(str) != null;
}
public boolean hasThumbnail() {
return this.mHasThumbnail;
}
public boolean isFlipped() {
int attributeInt = getAttributeInt("Orientation", 1);
return attributeInt == 2 || attributeInt == 7 || attributeInt == 4 || attributeInt == 5;
}
public boolean isThumbnailCompressed() {
if (this.mHasThumbnail) {
int i2 = this.mThumbnailCompression;
return i2 == 6 || i2 == 7;
}
return false;
}
public void resetOrientation() {
setAttribute("Orientation", Integer.toString(1));
}
public void rotate(int i2) {
if (i2 % 90 == 0) {
int attributeInt = getAttributeInt("Orientation", 1);
List<Integer> list = ROTATION_ORDER;
if (list.contains(Integer.valueOf(attributeInt))) {
int indexOf = (list.indexOf(Integer.valueOf(attributeInt)) + (i2 / 90)) % 4;
r4 = list.get(indexOf + (indexOf < 0 ? 4 : 0)).intValue();
} else {
List<Integer> list2 = FLIPPED_ROTATION_ORDER;
if (list2.contains(Integer.valueOf(attributeInt))) {
int indexOf2 = (list2.indexOf(Integer.valueOf(attributeInt)) + (i2 / 90)) % 4;
r4 = list2.get(indexOf2 + (indexOf2 < 0 ? 4 : 0)).intValue();
}
}
setAttribute("Orientation", Integer.toString(r4));
return;
}
throw new IllegalArgumentException("degree should be a multiple of 90");
}
public void saveAttributes() throws IOException {
FileInputStream fileInputStream;
File createTempFile;
FileOutputStream fileOutputStream;
BufferedInputStream bufferedInputStream;
BufferedInputStream bufferedInputStream2;
FileOutputStream fileOutputStream2;
Exception e2;
FileInputStream fileInputStream2;
FileInputStream fileInputStream3;
FileOutputStream fileOutputStream3;
FileOutputStream fileOutputStream4;
if (isSupportedFormatForSavingAttributes()) {
if (this.mSeekableFileDescriptor == null && this.mFilename == null) {
throw new IOException("ExifInterface does not support saving attributes for the current input.");
}
this.mModified = true;
this.mThumbnailBytes = getThumbnail();
FileOutputStream fileOutputStream5 = null;
try {
createTempFile = File.createTempFile("temp", "tmp");
if (this.mFilename != null) {
fileInputStream = new FileInputStream(this.mFilename);
} else if (Build.VERSION.SDK_INT >= 21) {
Os.lseek(this.mSeekableFileDescriptor, 0L, OsConstants.SEEK_SET);
fileInputStream = new FileInputStream(this.mSeekableFileDescriptor);
} else {
fileInputStream = null;
}
try {
try {
fileOutputStream = new FileOutputStream(createTempFile);
} catch (Exception e3) {
e = e3;
}
} catch (Throwable th) {
th = th;
}
} catch (Exception e4) {
e = e4;
fileInputStream = null;
} catch (Throwable th2) {
th = th2;
fileInputStream = null;
}
try {
copy(fileInputStream, fileOutputStream);
closeQuietly(fileInputStream);
closeQuietly(fileOutputStream);
try {
try {
try {
fileInputStream2 = new FileInputStream(createTempFile);
} catch (Exception e5) {
e2 = e5;
fileInputStream2 = null;
}
} catch (Throwable th3) {
th = th3;
bufferedInputStream2 = null;
}
} catch (Throwable th4) {
th = th4;
bufferedInputStream2 = bufferedInputStream;
fileOutputStream5 = fileOutputStream2;
}
try {
if (this.mFilename != null) {
fileOutputStream4 = new FileOutputStream(this.mFilename);
} else if (Build.VERSION.SDK_INT >= 21) {
Os.lseek(this.mSeekableFileDescriptor, 0L, OsConstants.SEEK_SET);
fileOutputStream4 = new FileOutputStream(this.mSeekableFileDescriptor);
} else {
fileOutputStream4 = null;
}
try {
bufferedInputStream2 = new BufferedInputStream(fileInputStream2);
try {
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream4);
try {
int i2 = this.mMimeType;
if (i2 == 4) {
saveJpegAttributes(bufferedInputStream2, bufferedOutputStream);
} else if (i2 == 13) {
savePngAttributes(bufferedInputStream2, bufferedOutputStream);
} else if (i2 == 14) {
saveWebpAttributes(bufferedInputStream2, bufferedOutputStream);
}
closeQuietly(bufferedInputStream2);
closeQuietly(bufferedOutputStream);
createTempFile.delete();
this.mThumbnailBytes = null;
} catch (Exception e6) {
FileOutputStream fileOutputStream6 = fileOutputStream4;
e2 = e6;
fileOutputStream5 = fileOutputStream6;
try {
fileInputStream3 = new FileInputStream(createTempFile);
} catch (Exception e7) {
e = e7;
} catch (Throwable th5) {
th = th5;
}
try {
if (this.mFilename == null) {
if (Build.VERSION.SDK_INT >= 21) {
Os.lseek(this.mSeekableFileDescriptor, 0L, OsConstants.SEEK_SET);
fileOutputStream3 = new FileOutputStream(this.mSeekableFileDescriptor);
}
copy(fileInputStream3, fileOutputStream5);
closeQuietly(fileInputStream3);
closeQuietly(fileOutputStream5);
throw new IOException("Failed to save new file", e2);
}
fileOutputStream3 = new FileOutputStream(this.mFilename);
fileOutputStream5 = fileOutputStream3;
copy(fileInputStream3, fileOutputStream5);
closeQuietly(fileInputStream3);
closeQuietly(fileOutputStream5);
throw new IOException("Failed to save new file", e2);
} catch (Exception e8) {
e = e8;
fileInputStream2 = fileInputStream3;
try {
throw new IOException("Failed to save new file. Original file is stored in " + createTempFile.getAbsolutePath(), e);
} catch (Throwable th6) {
th = th6;
closeQuietly(fileInputStream2);
closeQuietly(fileOutputStream5);
throw th;
}
} catch (Throwable th7) {
th = th7;
fileInputStream2 = fileInputStream3;
closeQuietly(fileInputStream2);
closeQuietly(fileOutputStream5);
throw th;
}
}
} catch (Exception e9) {
fileOutputStream5 = fileOutputStream4;
e2 = e9;
} catch (Throwable th8) {
th = th8;
closeQuietly(bufferedInputStream2);
closeQuietly(fileOutputStream5);
if (0 == 0) {
createTempFile.delete();
}
throw th;
}
} catch (Exception e10) {
fileOutputStream5 = fileOutputStream4;
e2 = e10;
}
} catch (Exception e11) {
e2 = e11;
}
} catch (Exception e12) {
e = e12;
fileOutputStream5 = fileOutputStream;
throw new IOException("Failed to copy original file to temp file", e);
} catch (Throwable th9) {
th = th9;
fileOutputStream5 = fileOutputStream;
closeQuietly(fileInputStream);
closeQuietly(fileOutputStream5);
throw th;
}
} else {
throw new IOException("ExifInterface only supports saving attributes on JPEG, PNG, or WebP formats.");
}
}
public void setAltitude(double d2) {
String str = d2 >= ShadowDrawableWrapper.COS_45 ? "0" : "1";
setAttribute("GPSAltitude", new Rational(Math.abs(d2)).toString());
setAttribute("GPSAltitudeRef", str);
}
public void setAttribute(String str, String str2) {
ExifTag exifTag;
int i2;
int i3;
Matcher matcher;
String str3 = str;
String str4 = str2;
Objects.requireNonNull(str3, "tag shouldn't be null");
if (("DateTime".equals(str3) || "DateTimeOriginal".equals(str3) || "DateTimeDigitized".equals(str3)) && str4 != null) {
boolean find = DATETIME_PRIMARY_FORMAT_PATTERN.matcher(str4).find();
boolean find2 = DATETIME_SECONDARY_FORMAT_PATTERN.matcher(str4).find();
if (str2.length() != 19 || (!find && !find2)) {
Log.w(TAG, "Invalid value for " + str3 + " : " + str4);
return;
} else if (find2) {
str4 = str4.replaceAll(Operators.SUB, ":");
}
}
if ("ISOSpeedRatings".equals(str3)) {
if (DEBUG) {
Log.d(TAG, "setAttribute: Replacing TAG_ISO_SPEED_RATINGS with TAG_PHOTOGRAPHIC_SENSITIVITY.");
}
str3 = "PhotographicSensitivity";
}
int i4 = 2;
int i5 = 1;
if (str4 != null && sTagSetForCompatibility.contains(str3)) {
if (str3.equals("GPSTimeStamp")) {
if (!GPS_TIMESTAMP_PATTERN.matcher(str4).find()) {
Log.w(TAG, "Invalid value for " + str3 + " : " + str4);
return;
}
str4 = Integer.parseInt(matcher.group(1)) + "/1," + Integer.parseInt(matcher.group(2)) + "/1," + Integer.parseInt(matcher.group(3)) + "/1";
} else {
try {
str4 = new Rational(Double.parseDouble(str4)).toString();
} catch (NumberFormatException unused) {
Log.w(TAG, "Invalid value for " + str3 + " : " + str4);
return;
}
}
}
int i6 = 0;
int i7 = 0;
while (i7 < EXIF_TAGS.length) {
if ((i7 != 4 || this.mHasThumbnail) && (exifTag = sExifTagMapsForWriting[i7].get(str3)) != null) {
if (str4 == null) {
this.mAttributes[i7].remove(str3);
} else {
Pair<Integer, Integer> guessDataFormat = guessDataFormat(str4);
int i8 = -1;
if (exifTag.primaryFormat != ((Integer) guessDataFormat.first).intValue() && exifTag.primaryFormat != ((Integer) guessDataFormat.second).intValue()) {
int i9 = exifTag.secondaryFormat;
if (i9 != -1 && (i9 == ((Integer) guessDataFormat.first).intValue() || exifTag.secondaryFormat == ((Integer) guessDataFormat.second).intValue())) {
i2 = exifTag.secondaryFormat;
} else {
int i10 = exifTag.primaryFormat;
if (i10 == i5 || i10 == 7 || i10 == i4) {
i2 = i10;
} else if (DEBUG) {
StringBuilder sb = new StringBuilder();
sb.append("Given tag (");
sb.append(str3);
sb.append(") value didn't match with one of expected formats: ");
String[] strArr = IFD_FORMAT_NAMES;
sb.append(strArr[exifTag.primaryFormat]);
sb.append(exifTag.secondaryFormat == -1 ? "" : ", " + strArr[exifTag.secondaryFormat]);
sb.append(" (guess: ");
sb.append(strArr[((Integer) guessDataFormat.first).intValue()]);
sb.append(((Integer) guessDataFormat.second).intValue() != -1 ? ", " + strArr[((Integer) guessDataFormat.second).intValue()] : "");
sb.append(Operators.BRACKET_END_STR);
Log.d(TAG, sb.toString());
}
}
} else {
i2 = exifTag.primaryFormat;
}
switch (i2) {
case 1:
i3 = i5;
this.mAttributes[i7].put(str3, ExifAttribute.createByte(str4));
break;
case 2:
case 7:
i3 = i5;
this.mAttributes[i7].put(str3, ExifAttribute.createString(str4));
break;
case 3:
i3 = i5;
String[] split = str4.split(",", -1);
int[] iArr = new int[split.length];
for (int i11 = 0; i11 < split.length; i11++) {
iArr[i11] = Integer.parseInt(split[i11]);
}
this.mAttributes[i7].put(str3, ExifAttribute.createUShort(iArr, this.mExifByteOrder));
break;
case 4:
i3 = i5;
String[] split2 = str4.split(",", -1);
long[] jArr = new long[split2.length];
for (int i12 = 0; i12 < split2.length; i12++) {
jArr[i12] = Long.parseLong(split2[i12]);
}
this.mAttributes[i7].put(str3, ExifAttribute.createULong(jArr, this.mExifByteOrder));
break;
case 5:
String[] split3 = str4.split(",", -1);
Rational[] rationalArr = new Rational[split3.length];
int i13 = 0;
while (i13 < split3.length) {
String[] split4 = split3[i13].split(Operators.DIV, i8);
rationalArr[i13] = new Rational((long) Double.parseDouble(split4[0]), (long) Double.parseDouble(split4[1]));
i13++;
i8 = -1;
}
i3 = 1;
this.mAttributes[i7].put(str3, ExifAttribute.createURational(rationalArr, this.mExifByteOrder));
break;
case 6:
case 8:
case 11:
default:
i3 = i5;
if (DEBUG) {
Log.d(TAG, "Data format isn't one of expected formats: " + i2);
break;
} else {
break;
}
case 9:
String[] split5 = str4.split(",", -1);
int[] iArr2 = new int[split5.length];
for (int i14 = 0; i14 < split5.length; i14++) {
iArr2[i14] = Integer.parseInt(split5[i14]);
}
this.mAttributes[i7].put(str3, ExifAttribute.createSLong(iArr2, this.mExifByteOrder));
i3 = 1;
break;
case 10:
String[] split6 = str4.split(",", -1);
Rational[] rationalArr2 = new Rational[split6.length];
int i15 = i6;
while (i15 < split6.length) {
String[] split7 = split6[i15].split(Operators.DIV, -1);
rationalArr2[i15] = new Rational((long) Double.parseDouble(split7[i6]), (long) Double.parseDouble(split7[i5]));
i15++;
split6 = split6;
i6 = 0;
i5 = 1;
}
this.mAttributes[i7].put(str3, ExifAttribute.createSRational(rationalArr2, this.mExifByteOrder));
i3 = 1;
break;
case 12:
String[] split8 = str4.split(",", -1);
double[] dArr = new double[split8.length];
for (int i16 = i6; i16 < split8.length; i16++) {
dArr[i16] = Double.parseDouble(split8[i16]);
}
this.mAttributes[i7].put(str3, ExifAttribute.createDouble(dArr, this.mExifByteOrder));
break;
}
i7++;
i5 = i3;
i4 = 2;
i6 = 0;
}
}
i3 = i5;
i7++;
i5 = i3;
i4 = 2;
i6 = 0;
}
}
public void setDateTime(Long l2) {
setAttribute("DateTime", sFormatterPrimary.format(new Date(l2.longValue())));
setAttribute("SubSecTime", Long.toString(l2.longValue() % 1000));
}
public void setGpsInfo(Location location) {
if (location == null) {
return;
}
setAttribute("GPSProcessingMethod", location.getProvider());
setLatLong(location.getLatitude(), location.getLongitude());
setAltitude(location.getAltitude());
setAttribute("GPSSpeedRef", "K");
setAttribute("GPSSpeed", new Rational((location.getSpeed() * ((float) TimeUnit.HOURS.toSeconds(1L))) / 1000.0f).toString());
String[] split = sFormatterPrimary.format(new Date(location.getTime())).split("\\s+", -1);
setAttribute("GPSDateStamp", split[0]);
setAttribute("GPSTimeStamp", split[1]);
}
public void setLatLong(double d2, double d3) {
if (d2 >= -90.0d && d2 <= 90.0d && !Double.isNaN(d2)) {
if (d3 >= -180.0d && d3 <= 180.0d && !Double.isNaN(d3)) {
setAttribute("GPSLatitudeRef", d2 >= ShadowDrawableWrapper.COS_45 ? "N" : "S");
setAttribute("GPSLatitude", convertDecimalDegree(Math.abs(d2)));
setAttribute("GPSLongitudeRef", d3 >= ShadowDrawableWrapper.COS_45 ? "E" : "W");
setAttribute("GPSLongitude", convertDecimalDegree(Math.abs(d3)));
return;
}
throw new IllegalArgumentException("Longitude value " + d3 + " is not valid.");
}
throw new IllegalArgumentException("Latitude value " + d2 + " is not valid.");
}
private static void copy(InputStream inputStream, OutputStream outputStream, int i2) throws IOException {
byte[] bArr = new byte[8192];
while (i2 > 0) {
int min = Math.min(i2, 8192);
int read = inputStream.read(bArr, 0, min);
if (read == min) {
i2 -= read;
outputStream.write(bArr, 0, read);
} else {
throw new IOException("Failed to copy the given amount of bytes from the inputstream to the output stream.");
}
}
}
public double[] getLatLong() {
String attribute = getAttribute("GPSLatitude");
String attribute2 = getAttribute("GPSLatitudeRef");
String attribute3 = getAttribute("GPSLongitude");
String attribute4 = getAttribute("GPSLongitudeRef");
if (attribute == null || attribute2 == null || attribute3 == null || attribute4 == null) {
return null;
}
try {
return new double[]{convertRationalLatLonToDouble(attribute, attribute2), convertRationalLatLonToDouble(attribute3, attribute4)};
} catch (IllegalArgumentException unused) {
Log.w(TAG, "Latitude/longitude values are not parsable. " + String.format("latValue=%s, latRef=%s, lngValue=%s, lngRef=%s", attribute, attribute2, attribute3, attribute4));
return null;
}
}
public static class ExifTag {
public final String name;
public final int number;
public final int primaryFormat;
public final int secondaryFormat;
public ExifTag(String str, int i2, int i3) {
this.name = str;
this.number = i2;
this.primaryFormat = i3;
this.secondaryFormat = -1;
}
public boolean isFormatCompatible(int i2) {
int i3;
int i4 = this.primaryFormat;
if (i4 == 7 || i2 == 7 || i4 == i2 || (i3 = this.secondaryFormat) == i2) {
return true;
}
if ((i4 == 4 || i3 == 4) && i2 == 3) {
return true;
}
if ((i4 == 9 || i3 == 9) && i2 == 8) {
return true;
}
return (i4 == 12 || i3 == 12) && i2 == 11;
}
public ExifTag(String str, int i2, int i3, int i4) {
this.name = str;
this.number = i2;
this.primaryFormat = i3;
this.secondaryFormat = i4;
}
}
public ExifInterface(String str) throws IOException {
ExifTag[][] exifTagArr = EXIF_TAGS;
this.mAttributes = new HashMap[exifTagArr.length];
this.mAttributesOffsets = new HashSet(exifTagArr.length);
this.mExifByteOrder = ByteOrder.BIG_ENDIAN;
Objects.requireNonNull(str, "filename cannot be null");
initForFilename(str);
}
public ExifInterface(FileDescriptor fileDescriptor) throws IOException {
ExifTag[][] exifTagArr = EXIF_TAGS;
this.mAttributes = new HashMap[exifTagArr.length];
this.mAttributesOffsets = new HashSet(exifTagArr.length);
this.mExifByteOrder = ByteOrder.BIG_ENDIAN;
Objects.requireNonNull(fileDescriptor, "fileDescriptor cannot be null");
FileInputStream fileInputStream = null;
this.mAssetInputStream = null;
this.mFilename = null;
boolean z = false;
if (Build.VERSION.SDK_INT >= 21 && isSeekableFD(fileDescriptor)) {
this.mSeekableFileDescriptor = fileDescriptor;
try {
fileDescriptor = Os.dup(fileDescriptor);
z = true;
} catch (Exception e2) {
throw new IOException("Failed to duplicate file descriptor", e2);
}
} else {
this.mSeekableFileDescriptor = null;
}
try {
FileInputStream fileInputStream2 = new FileInputStream(fileDescriptor);
try {
loadAttributes(fileInputStream2);
closeQuietly(fileInputStream2);
if (z) {
closeFileDescriptor(fileDescriptor);
}
} catch (Throwable th) {
th = th;
fileInputStream = fileInputStream2;
closeQuietly(fileInputStream);
if (z) {
closeFileDescriptor(fileDescriptor);
}
throw th;
}
} catch (Throwable th2) {
th = th2;
}
}
public ExifInterface(InputStream inputStream) throws IOException {
this(inputStream, 0);
}
public ExifInterface(InputStream inputStream, int i2) throws IOException {
ExifTag[][] exifTagArr = EXIF_TAGS;
this.mAttributes = new HashMap[exifTagArr.length];
this.mAttributesOffsets = new HashSet(exifTagArr.length);
this.mExifByteOrder = ByteOrder.BIG_ENDIAN;
Objects.requireNonNull(inputStream, "inputStream cannot be null");
this.mFilename = null;
if (i2 == 1) {
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream, 5000);
if (!isExifDataOnly(bufferedInputStream)) {
Log.w(TAG, "Given data does not follow the structure of an Exif-only data.");
return;
}
this.mIsExifDataOnly = true;
this.mAssetInputStream = null;
this.mSeekableFileDescriptor = null;
inputStream = bufferedInputStream;
} else if (inputStream instanceof AssetManager.AssetInputStream) {
this.mAssetInputStream = (AssetManager.AssetInputStream) inputStream;
this.mSeekableFileDescriptor = null;
} else {
if (inputStream instanceof FileInputStream) {
FileInputStream fileInputStream = (FileInputStream) inputStream;
if (isSeekableFD(fileInputStream.getFD())) {
this.mAssetInputStream = null;
this.mSeekableFileDescriptor = fileInputStream.getFD();
}
}
this.mAssetInputStream = null;
this.mSeekableFileDescriptor = null;
}
loadAttributes(inputStream);
}
}