4855 lines
237 KiB
Java
4855 lines
237 KiB
Java
package androidx.exifinterface.media;
|
|
|
|
import android.annotation.SuppressLint;
|
|
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.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RestrictTo;
|
|
import c.d.b.a.a;
|
|
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;
|
|
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 int[] BITS_PER_SAMPLE_GREYSCALE_1 = {4};
|
|
public static final int[] BITS_PER_SAMPLE_GREYSCALE_2 = {8};
|
|
public static final int[] BITS_PER_SAMPLE_RGB = {8, 8, 8};
|
|
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 = Pattern.compile("^(\\d{4}):(\\d{2}):(\\d{2})\\s(\\d{2}):(\\d{2}):(\\d{2})$");
|
|
private static final Pattern DATETIME_SECONDARY_FORMAT_PATTERN = Pattern.compile("^(\\d{4})-(\\d{2})-(\\d{2})\\s(\\d{2}):(\\d{2}):(\\d{2})$");
|
|
private static final int DATETIME_VALUE_STRING_LENGTH = 19;
|
|
private static final boolean DEBUG = Log.isLoggable("ExifInterface", 3);
|
|
public static final byte[] EXIF_ASCII_PREFIX = {65, 83, 67, 73, 73, 0, 0, 0};
|
|
private static final ExifTag[] EXIF_POINTER_TAGS = {new ExifTag("SubIFDPointer", 330, 4), new ExifTag("ExifIFDPointer", 34665, 4), new ExifTag("GPSInfoIFDPointer", 34853, 4), new ExifTag("InteroperabilityIFDPointer", 40965, 4), new ExifTag("CameraSettingsIFDPointer", 8224, 1), new ExifTag("ImageProcessingIFDPointer", 8256, 1)};
|
|
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;
|
|
private static final List<Integer> FLIPPED_ROTATION_ORDER = Arrays.asList(2, 7, 4, 5);
|
|
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 = Pattern.compile("^(\\d{2}):(\\d{2}):(\\d{2})$");
|
|
private static final byte[] HEIF_BRAND_HEIC = {104, 101, 105, 99};
|
|
private static final byte[] HEIF_BRAND_MIF1 = {109, 105, 102, 49};
|
|
private static final byte[] HEIF_TYPE_FTYP = {102, 116, 121, 112};
|
|
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;
|
|
public static final int[] IFD_FORMAT_BYTES_PER_FORMAT = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 1};
|
|
private static final int IFD_FORMAT_DOUBLE = 12;
|
|
private static final int IFD_FORMAT_IFD = 13;
|
|
public static final String[] IFD_FORMAT_NAMES = {"", "BYTE", "STRING", "USHORT", "ULONG", "URATIONAL", "SBYTE", "UNDEFINED", "SSHORT", "SLONG", "SRATIONAL", "SINGLE", "DOUBLE", "IFD"};
|
|
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 = new ExifTag("JPEGInterchangeFormatLength", 514, 4);
|
|
private static final ExifTag JPEG_INTERCHANGE_FORMAT_TAG = new ExifTag("JPEGInterchangeFormat", 513, 4);
|
|
public static final byte[] JPEG_SIGNATURE = {-1, -40, -1};
|
|
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_SOI = -40;
|
|
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 = Pattern.compile(".*[1-9].*");
|
|
private static final ExifTag[] ORF_CAMERA_SETTINGS_TAGS;
|
|
private static final ExifTag[] ORF_IMAGE_PROCESSING_TAGS;
|
|
private static final byte[] ORF_MAKER_NOTE_HEADER_1 = {79, 76, 89, 77, 80, 0};
|
|
private static final int ORF_MAKER_NOTE_HEADER_1_SIZE = 8;
|
|
private static final byte[] ORF_MAKER_NOTE_HEADER_2 = {79, 76, 89, 77, 80, 85, 83, 0, 73, 73};
|
|
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 byte[] PNG_CHUNK_TYPE_EXIF = {101, 88, 73, 102};
|
|
private static final byte[] PNG_CHUNK_TYPE_IEND = {73, 69, 78, 68};
|
|
private static final byte[] PNG_CHUNK_TYPE_IHDR = {73, 72, 68, 82};
|
|
private static final byte[] PNG_SIGNATURE = {-119, 80, 78, 71, 13, 10, 26, 10};
|
|
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 List<Integer> ROTATION_ORDER = Arrays.asList(1, 6, 3, 8);
|
|
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;
|
|
private static final String TAG = "ExifInterface";
|
|
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 = new ExifTag("StripOffsets", 273, 3);
|
|
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";
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
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 byte[] WEBP_CHUNK_TYPE_ANIM = "ANIM".getBytes(Charset.defaultCharset());
|
|
private static final byte[] WEBP_CHUNK_TYPE_ANMF = "ANMF".getBytes(Charset.defaultCharset());
|
|
private static final int WEBP_CHUNK_TYPE_BYTE_LENGTH = 4;
|
|
private static final byte[] WEBP_CHUNK_TYPE_EXIF = {69, 88, 73, 70};
|
|
private static final byte[] WEBP_CHUNK_TYPE_VP8 = "VP8 ".getBytes(Charset.defaultCharset());
|
|
private static final byte[] WEBP_CHUNK_TYPE_VP8L = "VP8L".getBytes(Charset.defaultCharset());
|
|
private static final byte[] WEBP_CHUNK_TYPE_VP8X = "VP8X".getBytes(Charset.defaultCharset());
|
|
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_SIGNATURE_1 = {82, 73, 70, 70};
|
|
private static final byte[] WEBP_SIGNATURE_2 = {87, 69, 66, 80};
|
|
private static final byte WEBP_VP8L_SIGNATURE = 47;
|
|
private static final byte[] WEBP_VP8_SIGNATURE = {-99, 1, 42};
|
|
@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 = new HashMap<>();
|
|
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 = new HashSet<>(Arrays.asList("FNumber", "DigitalZoomRatio", "ExposureTime", "SubjectDistance", "GPSTimeStamp"));
|
|
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;
|
|
|
|
/* renamed from: androidx.exifinterface.media.ExifInterface$1 reason: invalid class name */
|
|
public class AnonymousClass1 extends MediaDataSource {
|
|
public long mPosition;
|
|
public final /* synthetic */ ByteOrderedDataInputStream val$in;
|
|
|
|
public AnonymousClass1(ByteOrderedDataInputStream byteOrderedDataInputStream) {
|
|
this.val$in = byteOrderedDataInputStream;
|
|
}
|
|
|
|
@Override // java.io.Closeable, java.lang.AutoCloseable
|
|
public void close() throws IOException {
|
|
}
|
|
|
|
@Override // android.media.MediaDataSource
|
|
public long getSize() throws IOException {
|
|
return -1;
|
|
}
|
|
|
|
@Override // android.media.MediaDataSource
|
|
public int readAt(long j, byte[] bArr, int i, int i2) throws IOException {
|
|
if (i2 == 0) {
|
|
return 0;
|
|
}
|
|
if (j < 0) {
|
|
return -1;
|
|
}
|
|
try {
|
|
long j2 = this.mPosition;
|
|
if (j2 != j) {
|
|
if (j2 >= 0 && j >= j2 + ((long) this.val$in.available())) {
|
|
return -1;
|
|
}
|
|
this.val$in.seek(j);
|
|
this.mPosition = j;
|
|
}
|
|
if (i2 > this.val$in.available()) {
|
|
i2 = this.val$in.available();
|
|
}
|
|
int read = this.val$in.read(bArr, i, i2);
|
|
if (read >= 0) {
|
|
this.mPosition += (long) read;
|
|
return read;
|
|
}
|
|
} catch (IOException unused) {
|
|
}
|
|
this.mPosition = -1;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
public static class ByteOrderedDataInputStream extends InputStream implements DataInput {
|
|
private static final ByteOrder BIG_ENDIAN = ByteOrder.BIG_ENDIAN;
|
|
private static final ByteOrder LITTLE_ENDIAN = ByteOrder.LITTLE_ENDIAN;
|
|
private ByteOrder mByteOrder;
|
|
private DataInputStream mDataInputStream;
|
|
public final int mLength;
|
|
public int mPosition;
|
|
|
|
public ByteOrderedDataInputStream(InputStream inputStream) throws IOException {
|
|
this(inputStream, ByteOrder.BIG_ENDIAN);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
public ByteOrderedDataInputStream(byte[] bArr) throws IOException {
|
|
this(new ByteArrayInputStream(bArr));
|
|
}
|
|
|
|
@Override // java.io.InputStream
|
|
public int available() throws IOException {
|
|
return this.mDataInputStream.available();
|
|
}
|
|
|
|
public int getLength() {
|
|
return this.mLength;
|
|
}
|
|
|
|
@Override // java.io.InputStream
|
|
public synchronized void mark(int i) {
|
|
this.mDataInputStream.mark(i);
|
|
}
|
|
|
|
public int peek() {
|
|
return this.mPosition;
|
|
}
|
|
|
|
@Override // java.io.InputStream
|
|
public int read() throws IOException {
|
|
this.mPosition++;
|
|
return this.mDataInputStream.read();
|
|
}
|
|
|
|
@Override // java.io.InputStream
|
|
public int read(byte[] bArr, int i, int i2) throws IOException {
|
|
int read = this.mDataInputStream.read(bArr, i, i2);
|
|
this.mPosition += read;
|
|
return read;
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public boolean readBoolean() throws IOException {
|
|
this.mPosition++;
|
|
return this.mDataInputStream.readBoolean();
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public byte readByte() throws IOException {
|
|
int i = this.mPosition + 1;
|
|
this.mPosition = i;
|
|
if (i <= this.mLength) {
|
|
int read = this.mDataInputStream.read();
|
|
if (read >= 0) {
|
|
return (byte) read;
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public char readChar() throws IOException {
|
|
this.mPosition += 2;
|
|
return this.mDataInputStream.readChar();
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public double readDouble() throws IOException {
|
|
return Double.longBitsToDouble(readLong());
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public float readFloat() throws IOException {
|
|
return Float.intBitsToFloat(readInt());
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public void readFully(byte[] bArr) throws IOException {
|
|
int length = this.mPosition + bArr.length;
|
|
this.mPosition = length;
|
|
if (length > this.mLength) {
|
|
throw new EOFException();
|
|
} else if (this.mDataInputStream.read(bArr, 0, bArr.length) != bArr.length) {
|
|
throw new IOException("Couldn't read up to the length of buffer");
|
|
}
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public void readFully(byte[] bArr, int i, int i2) throws IOException {
|
|
int i3 = this.mPosition + i2;
|
|
this.mPosition = i3;
|
|
if (i3 > this.mLength) {
|
|
throw new EOFException();
|
|
} else if (this.mDataInputStream.read(bArr, i, i2) != i2) {
|
|
throw new IOException("Couldn't read up to the length of buffer");
|
|
}
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public int readInt() throws IOException {
|
|
int i = this.mPosition + 4;
|
|
this.mPosition = i;
|
|
if (i <= 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;
|
|
}
|
|
StringBuilder L = a.L("Invalid byte order: ");
|
|
L.append(this.mByteOrder);
|
|
throw new IOException(L.toString());
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public String readLine() throws IOException {
|
|
Log.d("ExifInterface", "Currently unsupported");
|
|
return null;
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public long readLong() throws IOException {
|
|
int i = this.mPosition + 8;
|
|
this.mPosition = i;
|
|
if (i <= 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 (((long) read8) << 56) + (((long) read7) << 48) + (((long) read6) << 40) + (((long) read5) << 32) + (((long) read4) << 24) + (((long) read3) << 16) + (((long) read2) << 8) + ((long) read);
|
|
}
|
|
if (byteOrder == BIG_ENDIAN) {
|
|
return (((long) read) << 56) + (((long) read2) << 48) + (((long) read3) << 40) + (((long) read4) << 32) + (((long) read5) << 24) + (((long) read6) << 16) + (((long) read7) << 8) + ((long) read8);
|
|
}
|
|
StringBuilder L = a.L("Invalid byte order: ");
|
|
L.append(this.mByteOrder);
|
|
throw new IOException(L.toString());
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public short readShort() throws IOException {
|
|
int i = this.mPosition + 2;
|
|
this.mPosition = i;
|
|
if (i <= 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);
|
|
}
|
|
StringBuilder L = a.L("Invalid byte order: ");
|
|
L.append(this.mByteOrder);
|
|
throw new IOException(L.toString());
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public String readUTF() throws IOException {
|
|
this.mPosition += 2;
|
|
return this.mDataInputStream.readUTF();
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public int readUnsignedByte() throws IOException {
|
|
this.mPosition++;
|
|
return this.mDataInputStream.readUnsignedByte();
|
|
}
|
|
|
|
public long readUnsignedInt() throws IOException {
|
|
return ((long) readInt()) & 4294967295L;
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public int readUnsignedShort() throws IOException {
|
|
int i = this.mPosition + 2;
|
|
this.mPosition = i;
|
|
if (i <= 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;
|
|
}
|
|
StringBuilder L = a.L("Invalid byte order: ");
|
|
L.append(this.mByteOrder);
|
|
throw new IOException(L.toString());
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
throw new EOFException();
|
|
}
|
|
|
|
public void seek(long j) throws IOException {
|
|
int i = this.mPosition;
|
|
if (((long) i) > j) {
|
|
this.mPosition = 0;
|
|
this.mDataInputStream.reset();
|
|
this.mDataInputStream.mark(this.mLength);
|
|
} else {
|
|
j -= (long) i;
|
|
}
|
|
int i2 = (int) j;
|
|
if (skipBytes(i2) != i2) {
|
|
throw new IOException("Couldn't seek up to the byteCount");
|
|
}
|
|
}
|
|
|
|
public void setByteOrder(ByteOrder byteOrder) {
|
|
this.mByteOrder = byteOrder;
|
|
}
|
|
|
|
@Override // java.io.DataInput
|
|
public int skipBytes(int i) throws IOException {
|
|
int min = Math.min(i, this.mLength - this.mPosition);
|
|
int i2 = 0;
|
|
while (i2 < min) {
|
|
i2 += this.mDataInputStream.skipBytes(min - i2);
|
|
}
|
|
this.mPosition += i2;
|
|
return i2;
|
|
}
|
|
}
|
|
|
|
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 // java.io.FilterOutputStream, java.io.OutputStream
|
|
public void write(byte[] bArr) throws IOException {
|
|
this.mOutputStream.write(bArr);
|
|
}
|
|
|
|
@Override // java.io.FilterOutputStream, java.io.OutputStream
|
|
public void write(byte[] bArr, int i, int i2) throws IOException {
|
|
this.mOutputStream.write(bArr, i, i2);
|
|
}
|
|
|
|
public void writeByte(int i) throws IOException {
|
|
this.mOutputStream.write(i);
|
|
}
|
|
|
|
public void writeInt(int i) throws IOException {
|
|
ByteOrder byteOrder = this.mByteOrder;
|
|
if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
|
|
this.mOutputStream.write((i >>> 0) & 255);
|
|
this.mOutputStream.write((i >>> 8) & 255);
|
|
this.mOutputStream.write((i >>> 16) & 255);
|
|
this.mOutputStream.write((i >>> 24) & 255);
|
|
} else if (byteOrder == ByteOrder.BIG_ENDIAN) {
|
|
this.mOutputStream.write((i >>> 24) & 255);
|
|
this.mOutputStream.write((i >>> 16) & 255);
|
|
this.mOutputStream.write((i >>> 8) & 255);
|
|
this.mOutputStream.write((i >>> 0) & 255);
|
|
}
|
|
}
|
|
|
|
public void writeShort(short s2) throws IOException {
|
|
ByteOrder byteOrder = this.mByteOrder;
|
|
if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
|
|
this.mOutputStream.write((s2 >>> 0) & 255);
|
|
this.mOutputStream.write((s2 >>> 8) & 255);
|
|
} else if (byteOrder == ByteOrder.BIG_ENDIAN) {
|
|
this.mOutputStream.write((s2 >>> 8) & 255);
|
|
this.mOutputStream.write((s2 >>> 0) & 255);
|
|
}
|
|
}
|
|
|
|
public void writeUnsignedInt(long j) throws IOException {
|
|
writeInt((int) j);
|
|
}
|
|
|
|
public void writeUnsignedShort(int i) throws IOException {
|
|
writeShort((short) i);
|
|
}
|
|
}
|
|
|
|
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 i, int i2, long j, byte[] bArr) {
|
|
this.format = i;
|
|
this.numberOfComponents = i2;
|
|
this.bytesOffset = j;
|
|
this.bytes = bArr;
|
|
}
|
|
|
|
public ExifAttribute(int i, int i2, byte[] bArr) {
|
|
this(i, i2, -1, 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 d, ByteOrder byteOrder) {
|
|
return createDouble(new double[]{d}, byteOrder);
|
|
}
|
|
|
|
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 d : dArr) {
|
|
wrap.putDouble(d);
|
|
}
|
|
return new ExifAttribute(12, dArr.length, wrap.array());
|
|
}
|
|
|
|
public static ExifAttribute createSLong(int i, ByteOrder byteOrder) {
|
|
return createSLong(new int[]{i}, byteOrder);
|
|
}
|
|
|
|
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 i : iArr) {
|
|
wrap.putInt(i);
|
|
}
|
|
return new ExifAttribute(9, iArr.length, wrap.array());
|
|
}
|
|
|
|
public static ExifAttribute createSRational(Rational rational, ByteOrder byteOrder) {
|
|
return createSRational(new Rational[]{rational}, byteOrder);
|
|
}
|
|
|
|
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 j, ByteOrder byteOrder) {
|
|
return createULong(new long[]{j}, byteOrder);
|
|
}
|
|
|
|
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 j : jArr) {
|
|
wrap.putInt((int) j);
|
|
}
|
|
return new ExifAttribute(4, jArr.length, wrap.array());
|
|
}
|
|
|
|
public static ExifAttribute createURational(Rational rational, ByteOrder byteOrder) {
|
|
return createURational(new Rational[]{rational}, byteOrder);
|
|
}
|
|
|
|
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 i, ByteOrder byteOrder) {
|
|
return createUShort(new int[]{i}, byteOrder);
|
|
}
|
|
|
|
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 i : iArr) {
|
|
wrap.putShort((short) i);
|
|
}
|
|
return new ExifAttribute(3, iArr.length, wrap.array());
|
|
}
|
|
|
|
public double getDoubleValue(ByteOrder byteOrder) {
|
|
Object value = getValue(byteOrder);
|
|
if (value == null) {
|
|
throw new NumberFormatException("NULL can't be converted to a double value");
|
|
} else if (value instanceof String) {
|
|
return Double.parseDouble((String) value);
|
|
} else {
|
|
if (value instanceof long[]) {
|
|
long[] jArr = (long[]) value;
|
|
if (jArr.length == 1) {
|
|
return (double) 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 (double) 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");
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getIntValue(ByteOrder byteOrder) {
|
|
Object value = getValue(byteOrder);
|
|
if (value == null) {
|
|
throw new NumberFormatException("NULL can't be converted to a integer value");
|
|
} else if (value instanceof String) {
|
|
return Integer.parseInt((String) value);
|
|
} else {
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
|
|
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 i = 0;
|
|
if (value instanceof long[]) {
|
|
long[] jArr = (long[]) value;
|
|
while (i < jArr.length) {
|
|
sb.append(jArr[i]);
|
|
i++;
|
|
if (i != jArr.length) {
|
|
sb.append(",");
|
|
}
|
|
}
|
|
return sb.toString();
|
|
} else if (value instanceof int[]) {
|
|
int[] iArr = (int[]) value;
|
|
while (i < iArr.length) {
|
|
sb.append(iArr[i]);
|
|
i++;
|
|
if (i != iArr.length) {
|
|
sb.append(",");
|
|
}
|
|
}
|
|
return sb.toString();
|
|
} else if (value instanceof double[]) {
|
|
double[] dArr = (double[]) value;
|
|
while (i < dArr.length) {
|
|
sb.append(dArr[i]);
|
|
i++;
|
|
if (i != dArr.length) {
|
|
sb.append(",");
|
|
}
|
|
}
|
|
return sb.toString();
|
|
} else if (!(value instanceof Rational[])) {
|
|
return null;
|
|
} else {
|
|
Rational[] rationalArr = (Rational[]) value;
|
|
while (i < rationalArr.length) {
|
|
sb.append(rationalArr[i].numerator);
|
|
sb.append('/');
|
|
sb.append(rationalArr[i].denominator);
|
|
i++;
|
|
if (i != rationalArr.length) {
|
|
sb.append(",");
|
|
}
|
|
}
|
|
return sb.toString();
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:138:0x0196 A[SYNTHETIC, Splitter:B:138:0x0196] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:146:0x01a3 A[SYNTHETIC, Splitter:B:146:0x01a3] */
|
|
public Object getValue(ByteOrder byteOrder) {
|
|
Throwable th;
|
|
IOException e;
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream;
|
|
byte b;
|
|
byte[] bArr;
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream2 = null;
|
|
try {
|
|
byteOrderedDataInputStream = new ByteOrderedDataInputStream(this.bytes);
|
|
try {
|
|
byteOrderedDataInputStream.setByteOrder(byteOrder);
|
|
boolean z2 = true;
|
|
int i = 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(this.bytes, ExifInterface.ASCII);
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e2) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e2);
|
|
}
|
|
return str;
|
|
}
|
|
String str2 = new String(new char[]{(char) (this.bytes[0] + 48)});
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e3) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e3);
|
|
}
|
|
return str2;
|
|
case 2:
|
|
case 7:
|
|
if (this.numberOfComponents >= ExifInterface.EXIF_ASCII_PREFIX.length) {
|
|
int i2 = 0;
|
|
while (true) {
|
|
bArr = ExifInterface.EXIF_ASCII_PREFIX;
|
|
if (i2 < bArr.length) {
|
|
if (this.bytes[i2] != bArr[i2]) {
|
|
z2 = false;
|
|
} else {
|
|
i2++;
|
|
}
|
|
}
|
|
}
|
|
if (z2) {
|
|
i = bArr.length;
|
|
}
|
|
}
|
|
StringBuilder sb = new StringBuilder();
|
|
while (i < this.numberOfComponents && (b = this.bytes[i]) != 0) {
|
|
if (b >= 32) {
|
|
sb.append((char) b);
|
|
} else {
|
|
sb.append('?');
|
|
}
|
|
i++;
|
|
}
|
|
String sb2 = sb.toString();
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e4) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e4);
|
|
}
|
|
return sb2;
|
|
case 3:
|
|
int[] iArr = new int[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
iArr[i] = byteOrderedDataInputStream.readUnsignedShort();
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e5) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e5);
|
|
}
|
|
return iArr;
|
|
case 4:
|
|
long[] jArr = new long[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
jArr[i] = byteOrderedDataInputStream.readUnsignedInt();
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e6) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e6);
|
|
}
|
|
return jArr;
|
|
case 5:
|
|
Rational[] rationalArr = new Rational[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
rationalArr[i] = new Rational(byteOrderedDataInputStream.readUnsignedInt(), byteOrderedDataInputStream.readUnsignedInt());
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e7) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e7);
|
|
}
|
|
return rationalArr;
|
|
case 8:
|
|
int[] iArr2 = new int[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
iArr2[i] = byteOrderedDataInputStream.readShort();
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e8) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e8);
|
|
}
|
|
return iArr2;
|
|
case 9:
|
|
int[] iArr3 = new int[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
iArr3[i] = byteOrderedDataInputStream.readInt();
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e9) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e9);
|
|
}
|
|
return iArr3;
|
|
case 10:
|
|
Rational[] rationalArr2 = new Rational[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
rationalArr2[i] = new Rational((long) byteOrderedDataInputStream.readInt(), (long) byteOrderedDataInputStream.readInt());
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e10) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e10);
|
|
}
|
|
return rationalArr2;
|
|
case 11:
|
|
double[] dArr = new double[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
dArr[i] = (double) byteOrderedDataInputStream.readFloat();
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e11) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e11);
|
|
}
|
|
return dArr;
|
|
case 12:
|
|
double[] dArr2 = new double[this.numberOfComponents];
|
|
while (i < this.numberOfComponents) {
|
|
dArr2[i] = byteOrderedDataInputStream.readDouble();
|
|
i++;
|
|
}
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e12) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e12);
|
|
}
|
|
return dArr2;
|
|
default:
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e13) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e13);
|
|
}
|
|
return null;
|
|
}
|
|
} catch (IOException e14) {
|
|
e = e14;
|
|
try {
|
|
Log.w("ExifInterface", "IOException occurred during reading a value", e);
|
|
if (byteOrderedDataInputStream != null) {
|
|
}
|
|
return null;
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
byteOrderedDataInputStream2 = byteOrderedDataInputStream;
|
|
if (byteOrderedDataInputStream2 != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
} catch (IOException e15) {
|
|
e = e15;
|
|
byteOrderedDataInputStream = null;
|
|
Log.w("ExifInterface", "IOException occurred during reading a value", e);
|
|
if (byteOrderedDataInputStream != null) {
|
|
try {
|
|
byteOrderedDataInputStream.close();
|
|
} catch (IOException e16) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e16);
|
|
}
|
|
}
|
|
return null;
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
if (byteOrderedDataInputStream2 != null) {
|
|
try {
|
|
byteOrderedDataInputStream2.close();
|
|
} catch (IOException e17) {
|
|
Log.e("ExifInterface", "IOException occurred while closing InputStream", e17);
|
|
}
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public int size() {
|
|
return ExifInterface.IFD_FORMAT_BYTES_PER_FORMAT[this.format] * this.numberOfComponents;
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder L = a.L("(");
|
|
L.append(ExifInterface.IFD_FORMAT_NAMES[this.format]);
|
|
L.append(", data length:");
|
|
return a.y(L, this.bytes.length, ")");
|
|
}
|
|
}
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public @interface ExifStreamType {
|
|
}
|
|
|
|
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 i, int i2) {
|
|
this.name = str;
|
|
this.number = i;
|
|
this.primaryFormat = i2;
|
|
this.secondaryFormat = -1;
|
|
}
|
|
|
|
public ExifTag(String str, int i, int i2, int i3) {
|
|
this.name = str;
|
|
this.number = i;
|
|
this.primaryFormat = i2;
|
|
this.secondaryFormat = i3;
|
|
}
|
|
|
|
public boolean isFormatCompatible(int i) {
|
|
int i2;
|
|
int i3 = this.primaryFormat;
|
|
if (i3 == 7 || i == 7 || i3 == i || (i2 = this.secondaryFormat) == i) {
|
|
return true;
|
|
}
|
|
if ((i3 == 4 || i2 == 4) && i == 3) {
|
|
return true;
|
|
}
|
|
if ((i3 == 9 || i2 == 9) && i == 8) {
|
|
return true;
|
|
}
|
|
return (i3 == 12 || i2 == 12) && i == 11;
|
|
}
|
|
}
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public @interface IfdType {
|
|
}
|
|
|
|
public static class Rational {
|
|
public final long denominator;
|
|
public final long numerator;
|
|
|
|
public Rational(double d) {
|
|
this((long) (d * 10000.0d), 10000);
|
|
}
|
|
|
|
public Rational(long j, long j2) {
|
|
if (j2 == 0) {
|
|
this.numerator = 0;
|
|
this.denominator = 1;
|
|
return;
|
|
}
|
|
this.numerator = j;
|
|
this.denominator = j2;
|
|
}
|
|
|
|
public double calculate() {
|
|
return ((double) this.numerator) / ((double) this.denominator);
|
|
}
|
|
|
|
public String toString() {
|
|
return this.numerator + "/" + this.denominator;
|
|
}
|
|
}
|
|
|
|
static {
|
|
ExifTag[] exifTagArr = {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", 273, 3, 4), new ExifTag("Orientation", 274, 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", 318, 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 = exifTagArr;
|
|
ExifTag[] exifTagArr2 = {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 = exifTagArr2;
|
|
ExifTag[] exifTagArr3 = {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 = exifTagArr3;
|
|
ExifTag[] exifTagArr4 = {new ExifTag("InteroperabilityIndex", 1, 2)};
|
|
IFD_INTEROPERABILITY_TAGS = exifTagArr4;
|
|
ExifTag[] exifTagArr5 = {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", 273, 3, 4), new ExifTag("ThumbnailOrientation", 274, 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", 318, 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 = exifTagArr5;
|
|
ExifTag[] exifTagArr6 = {new ExifTag("ThumbnailImage", 256, 7), new ExifTag("CameraSettingsIFDPointer", 8224, 4), new ExifTag("ImageProcessingIFDPointer", 8256, 4)};
|
|
ORF_MAKER_NOTE_TAGS = exifTagArr6;
|
|
ExifTag[] exifTagArr7 = {new ExifTag("PreviewImageStart", 257, 4), new ExifTag("PreviewImageLength", 258, 4)};
|
|
ORF_CAMERA_SETTINGS_TAGS = exifTagArr7;
|
|
ExifTag[] exifTagArr8 = {new ExifTag("AspectFrame", 4371, 3)};
|
|
ORF_IMAGE_PROCESSING_TAGS = exifTagArr8;
|
|
ExifTag[] exifTagArr9 = {new ExifTag("ColorSpace", 55, 3)};
|
|
PEF_TAGS = exifTagArr9;
|
|
ExifTag[][] exifTagArr10 = {exifTagArr, exifTagArr2, exifTagArr3, exifTagArr4, exifTagArr5, exifTagArr, exifTagArr6, exifTagArr7, exifTagArr8, exifTagArr9};
|
|
EXIF_TAGS = exifTagArr10;
|
|
sExifTagMapsForReading = new HashMap[exifTagArr10.length];
|
|
sExifTagMapsForWriting = new HashMap[exifTagArr10.length];
|
|
Charset forName = Charset.forName("US-ASCII");
|
|
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("UTC"));
|
|
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", locale);
|
|
sFormatterSecondary = simpleDateFormat2;
|
|
simpleDateFormat2.setTimeZone(TimeZone.getTimeZone("UTC"));
|
|
int i = 0;
|
|
while (true) {
|
|
ExifTag[][] exifTagArr11 = EXIF_TAGS;
|
|
if (i < exifTagArr11.length) {
|
|
sExifTagMapsForReading[i] = new HashMap<>();
|
|
sExifTagMapsForWriting[i] = new HashMap<>();
|
|
ExifTag[] exifTagArr12 = exifTagArr11[i];
|
|
for (ExifTag exifTag : exifTagArr12) {
|
|
sExifTagMapsForReading[i].put(Integer.valueOf(exifTag.number), exifTag);
|
|
sExifTagMapsForWriting[i].put(exifTag.name, exifTag);
|
|
}
|
|
i++;
|
|
} else {
|
|
HashMap<Integer, Integer> hashMap = sExifPointerTagMap;
|
|
ExifTag[] exifTagArr13 = EXIF_POINTER_TAGS;
|
|
hashMap.put(Integer.valueOf(exifTagArr13[0].number), 5);
|
|
hashMap.put(Integer.valueOf(exifTagArr13[1].number), 1);
|
|
hashMap.put(Integer.valueOf(exifTagArr13[2].number), 2);
|
|
hashMap.put(Integer.valueOf(exifTagArr13[3].number), 3);
|
|
hashMap.put(Integer.valueOf(exifTagArr13[4].number), 7);
|
|
hashMap.put(Integer.valueOf(exifTagArr13[5].number), 8);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public ExifInterface(@NonNull 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());
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:22:0x0056 */
|
|
public ExifInterface(@NonNull FileDescriptor fileDescriptor) throws IOException {
|
|
FileInputStream fileInputStream;
|
|
Throwable th;
|
|
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");
|
|
this.mAssetInputStream = null;
|
|
this.mFilename = null;
|
|
boolean z2 = false;
|
|
if (isSeekableFD(fileDescriptor)) {
|
|
this.mSeekableFileDescriptor = fileDescriptor;
|
|
try {
|
|
fileDescriptor = Os.dup(fileDescriptor);
|
|
z2 = true;
|
|
} catch (Exception e) {
|
|
throw new IOException("Failed to duplicate file descriptor", e);
|
|
}
|
|
} else {
|
|
this.mSeekableFileDescriptor = null;
|
|
}
|
|
try {
|
|
fileInputStream = new FileInputStream(fileDescriptor);
|
|
try {
|
|
loadAttributes(fileInputStream);
|
|
closeQuietly(fileInputStream);
|
|
if (z2) {
|
|
closeFileDescriptor(fileDescriptor);
|
|
}
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
closeQuietly(fileInputStream);
|
|
if (z2) {
|
|
closeFileDescriptor(fileDescriptor);
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (Throwable th3) {
|
|
fileInputStream = null;
|
|
th = th3;
|
|
closeQuietly(fileInputStream);
|
|
if (z2) {
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public ExifInterface(@NonNull InputStream inputStream) throws IOException {
|
|
this(inputStream, 0);
|
|
}
|
|
|
|
public ExifInterface(@NonNull InputStream inputStream, int i) 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 (i == 1) {
|
|
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream, 5000);
|
|
if (!isExifDataOnly(bufferedInputStream)) {
|
|
Log.w("ExifInterface", "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);
|
|
}
|
|
|
|
public ExifInterface(@NonNull 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);
|
|
}
|
|
|
|
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(0, this.mExifByteOrder));
|
|
}
|
|
if (getAttribute("ImageLength") == null) {
|
|
this.mAttributes[0].put("ImageLength", ExifAttribute.createULong(0, this.mExifByteOrder));
|
|
}
|
|
if (getAttribute("Orientation") == null) {
|
|
this.mAttributes[0].put("Orientation", ExifAttribute.createULong(0, this.mExifByteOrder));
|
|
}
|
|
if (getAttribute("LightSource") == null) {
|
|
this.mAttributes[1].put("LightSource", ExifAttribute.createULong(0, this.mExifByteOrder));
|
|
}
|
|
}
|
|
|
|
private static String byteArrayToHexString(byte[] bArr) {
|
|
StringBuilder sb = new StringBuilder(bArr.length * 2);
|
|
for (int i = 0; i < bArr.length; i++) {
|
|
sb.append(String.format("%02x", Byte.valueOf(bArr[i])));
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
private static void closeFileDescriptor(FileDescriptor fileDescriptor) {
|
|
try {
|
|
Os.close(fileDescriptor);
|
|
} catch (Exception unused) {
|
|
Log.e("ExifInterface", "Error closing fd.");
|
|
}
|
|
}
|
|
|
|
private static void closeQuietly(Closeable closeable) {
|
|
if (closeable != null) {
|
|
try {
|
|
closeable.close();
|
|
} catch (RuntimeException e) {
|
|
throw e;
|
|
} catch (Exception unused) {
|
|
}
|
|
}
|
|
}
|
|
|
|
private String convertDecimalDegree(double d) {
|
|
long j = (long) d;
|
|
double d2 = d - ((double) j);
|
|
long j2 = (long) (d2 * 60.0d);
|
|
long round = Math.round((d2 - (((double) j2) / 60.0d)) * 3600.0d * 1.0E7d);
|
|
return j + "/1," + j2 + "/1," + round + "/10000000";
|
|
}
|
|
|
|
private static double convertRationalLatLonToDouble(String str, String str2) {
|
|
try {
|
|
String[] split = str.split(",", -1);
|
|
String[] split2 = split[0].split("/", -1);
|
|
double parseDouble = Double.parseDouble(split2[0].trim()) / Double.parseDouble(split2[1].trim());
|
|
String[] split3 = split[1].split("/", -1);
|
|
String[] split4 = split[2].split("/", -1);
|
|
double parseDouble2 = ((Double.parseDouble(split4[0].trim()) / Double.parseDouble(split4[1].trim())) / 3600.0d) + ((Double.parseDouble(split3[0].trim()) / Double.parseDouble(split3[1].trim())) / 60.0d) + parseDouble;
|
|
if (!str2.equals("S")) {
|
|
if (!str2.equals("W")) {
|
|
if (!str2.equals("N")) {
|
|
if (!str2.equals("E")) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
return parseDouble2;
|
|
}
|
|
}
|
|
return -parseDouble2;
|
|
} 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 i = 0; i < iArr.length; i++) {
|
|
jArr[i] = (long) iArr[i];
|
|
}
|
|
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 i = 0;
|
|
while (true) {
|
|
int read = inputStream.read(bArr);
|
|
if (read == -1) {
|
|
return i;
|
|
}
|
|
i += read;
|
|
outputStream.write(bArr, 0, read);
|
|
}
|
|
}
|
|
|
|
private static void copy(InputStream inputStream, OutputStream outputStream, int i) throws IOException {
|
|
byte[] bArr = new byte[8192];
|
|
while (i > 0) {
|
|
int min = Math.min(i, 8192);
|
|
int read = inputStream.read(bArr, 0, min);
|
|
if (read == min) {
|
|
i -= 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.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void copyChunksUpToGivenChunkType(ByteOrderedDataInputStream byteOrderedDataInputStream, ByteOrderedDataOutputStream byteOrderedDataOutputStream, byte[] bArr, byte[] bArr2) throws IOException {
|
|
String str;
|
|
while (true) {
|
|
byte[] bArr3 = new byte[4];
|
|
if (byteOrderedDataInputStream.read(bArr3) != 4) {
|
|
StringBuilder L = a.L("Encountered invalid length while copying WebP chunks up tochunk type ");
|
|
Charset charset = ASCII;
|
|
L.append(new String(bArr, charset));
|
|
if (bArr2 == null) {
|
|
str = "";
|
|
} else {
|
|
StringBuilder L2 = a.L(" or ");
|
|
L2.append(new String(bArr2, charset));
|
|
str = L2.toString();
|
|
}
|
|
L.append(str);
|
|
throw new IOException(L.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);
|
|
}
|
|
|
|
@Nullable
|
|
private ExifAttribute getExifAttribute(@NonNull String str) {
|
|
Objects.requireNonNull(str, "tag shouldn't be null");
|
|
if ("ISOSpeedRatings".equals(str)) {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "getExifAttribute: Replacing TAG_ISO_SPEED_RATINGS with TAG_PHOTOGRAPHIC_SENSITIVITY.");
|
|
}
|
|
str = "PhotographicSensitivity";
|
|
}
|
|
for (int i = 0; i < EXIF_TAGS.length; i++) {
|
|
ExifAttribute exifAttribute = this.mAttributes[i].get(str);
|
|
if (exifAttribute != null) {
|
|
return exifAttribute;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void getHeifAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
|
|
String str;
|
|
String str2;
|
|
MediaMetadataRetriever mediaMetadataRetriever = new MediaMetadataRetriever();
|
|
try {
|
|
if (Build.VERSION.SDK_INT >= 23) {
|
|
mediaMetadataRetriever.setDataSource(new AnonymousClass1(byteOrderedDataInputStream));
|
|
} else {
|
|
FileDescriptor fileDescriptor = this.mSeekableFileDescriptor;
|
|
if (fileDescriptor != null) {
|
|
mediaMetadataRetriever.setDataSource(fileDescriptor);
|
|
} else {
|
|
String str3 = this.mFilename;
|
|
if (str3 != null) {
|
|
mediaMetadataRetriever.setDataSource(str3);
|
|
} else {
|
|
mediaMetadataRetriever.release();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
String extractMetadata = mediaMetadataRetriever.extractMetadata(33);
|
|
String extractMetadata2 = mediaMetadataRetriever.extractMetadata(34);
|
|
String extractMetadata3 = mediaMetadataRetriever.extractMetadata(26);
|
|
String extractMetadata4 = mediaMetadataRetriever.extractMetadata(17);
|
|
String str4 = null;
|
|
if ("yes".equals(extractMetadata3)) {
|
|
str4 = mediaMetadataRetriever.extractMetadata(29);
|
|
str2 = mediaMetadataRetriever.extractMetadata(30);
|
|
str = mediaMetadataRetriever.extractMetadata(31);
|
|
} else if ("yes".equals(extractMetadata4)) {
|
|
str4 = mediaMetadataRetriever.extractMetadata(18);
|
|
str2 = mediaMetadataRetriever.extractMetadata(19);
|
|
str = mediaMetadataRetriever.extractMetadata(24);
|
|
} else {
|
|
str2 = null;
|
|
str = 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 i = 1;
|
|
int parseInt = Integer.parseInt(str);
|
|
if (parseInt == 90) {
|
|
i = 6;
|
|
} else if (parseInt == 180) {
|
|
i = 3;
|
|
} else if (parseInt == 270) {
|
|
i = 8;
|
|
}
|
|
this.mAttributes[0].put("Orientation", ExifAttribute.createUShort(i, this.mExifByteOrder));
|
|
}
|
|
if (!(extractMetadata == null || extractMetadata2 == null)) {
|
|
int parseInt2 = Integer.parseInt(extractMetadata);
|
|
int parseInt3 = Integer.parseInt(extractMetadata2);
|
|
if (parseInt3 > 6) {
|
|
byteOrderedDataInputStream.seek((long) parseInt2);
|
|
byte[] bArr = new byte[6];
|
|
if (byteOrderedDataInputStream.read(bArr) == 6) {
|
|
int i2 = parseInt2 + 6;
|
|
int i3 = parseInt3 - 6;
|
|
if (Arrays.equals(bArr, IDENTIFIER_EXIF_APP1)) {
|
|
byte[] bArr2 = new byte[i3];
|
|
if (byteOrderedDataInputStream.read(bArr2) == i3) {
|
|
this.mOffsetToExifData = i2;
|
|
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("ExifInterface", "Heif meta: " + str4 + "x" + str2 + ", rotation " + str);
|
|
}
|
|
} finally {
|
|
mediaMetadataRetriever.release();
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:30:0x00b3 A[FALL_THROUGH] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:53:0x0170 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:74:0x0184 A[SYNTHETIC] */
|
|
private void getJpegAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream, int i, int i2) throws IOException {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "getJpegAttributes starting with: " + byteOrderedDataInputStream);
|
|
}
|
|
char c2 = 0;
|
|
byteOrderedDataInputStream.mark(0);
|
|
byteOrderedDataInputStream.setByteOrder(ByteOrder.BIG_ENDIAN);
|
|
byte readByte = byteOrderedDataInputStream.readByte();
|
|
byte b = -1;
|
|
if (readByte != -1) {
|
|
StringBuilder L = a.L("Invalid marker: ");
|
|
L.append(Integer.toHexString(readByte & 255));
|
|
throw new IOException(L.toString());
|
|
} else if (byteOrderedDataInputStream.readByte() == -40) {
|
|
int i3 = 2;
|
|
int i4 = 2;
|
|
while (true) {
|
|
byte readByte2 = byteOrderedDataInputStream.readByte();
|
|
if (readByte2 == b) {
|
|
int i5 = i4 + 1;
|
|
byte readByte3 = byteOrderedDataInputStream.readByte();
|
|
boolean z2 = DEBUG;
|
|
if (z2) {
|
|
StringBuilder L2 = a.L("Found JPEG segment indicator: ");
|
|
L2.append(Integer.toHexString(readByte3 & 255));
|
|
Log.d("ExifInterface", L2.toString());
|
|
}
|
|
int i6 = i5 + 1;
|
|
if (readByte3 != -39 && readByte3 != -38) {
|
|
int readUnsignedShort = byteOrderedDataInputStream.readUnsignedShort() - i3;
|
|
int i7 = i6 + i3;
|
|
if (z2) {
|
|
StringBuilder L3 = a.L("JPEG segment: ");
|
|
L3.append(Integer.toHexString(readByte3 & 255));
|
|
L3.append(" (length: ");
|
|
L3.append(readUnsignedShort + 2);
|
|
L3.append(")");
|
|
Log.d("ExifInterface", L3.toString());
|
|
}
|
|
if (readUnsignedShort >= 0) {
|
|
if (readByte3 == -31) {
|
|
byte[] bArr = new byte[readUnsignedShort];
|
|
byteOrderedDataInputStream.readFully(bArr);
|
|
int i8 = i7 + readUnsignedShort;
|
|
byte[] bArr2 = IDENTIFIER_EXIF_APP1;
|
|
if (startsWith(bArr, bArr2)) {
|
|
byte[] copyOfRange = Arrays.copyOfRange(bArr, bArr2.length, readUnsignedShort);
|
|
this.mOffsetToExifData = i + i7 + bArr2.length;
|
|
readExifSegment(copyOfRange, i2);
|
|
setThumbnailData(new ByteOrderedDataInputStream(copyOfRange));
|
|
} else {
|
|
byte[] bArr3 = IDENTIFIER_XMP_APP1;
|
|
if (startsWith(bArr, bArr3)) {
|
|
int length = i7 + bArr3.length;
|
|
byte[] copyOfRange2 = Arrays.copyOfRange(bArr, bArr3.length, readUnsignedShort);
|
|
if (getAttribute("Xmp") == null) {
|
|
this.mAttributes[c2].put("Xmp", new ExifAttribute(1, copyOfRange2.length, (long) length, copyOfRange2));
|
|
this.mXmpIsFromSeparateMarker = true;
|
|
}
|
|
}
|
|
}
|
|
i7 = i8;
|
|
} else 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[i2].put("ImageLength", ExifAttribute.createULong((long) byteOrderedDataInputStream.readUnsignedShort(), this.mExifByteOrder));
|
|
this.mAttributes[i2].put("ImageWidth", ExifAttribute.createULong((long) 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;
|
|
}
|
|
if (readUnsignedShort >= 0) {
|
|
throw new IOException("Invalid length");
|
|
} else if (byteOrderedDataInputStream.skipBytes(readUnsignedShort) == readUnsignedShort) {
|
|
i4 = i7 + readUnsignedShort;
|
|
c2 = 0;
|
|
i3 = 2;
|
|
b = -1;
|
|
} else {
|
|
throw new IOException("Invalid JPEG segment");
|
|
}
|
|
} else {
|
|
byte[] bArr4 = new byte[readUnsignedShort];
|
|
if (byteOrderedDataInputStream.read(bArr4) != readUnsignedShort) {
|
|
throw new IOException("Invalid exif");
|
|
} else if (getAttribute("UserComment") == null) {
|
|
this.mAttributes[1].put("UserComment", ExifAttribute.createString(new String(bArr4, ASCII)));
|
|
}
|
|
}
|
|
readUnsignedShort = 0;
|
|
if (readUnsignedShort >= 0) {
|
|
}
|
|
} else {
|
|
throw new IOException("Invalid length");
|
|
}
|
|
}
|
|
} else {
|
|
StringBuilder L4 = a.L("Invalid marker:");
|
|
L4.append(Integer.toHexString(readByte2 & 255));
|
|
throw new IOException(L4.toString());
|
|
}
|
|
}
|
|
byteOrderedDataInputStream.setByteOrder(this.mExifByteOrder);
|
|
} else {
|
|
StringBuilder L5 = a.L("Invalid marker: ");
|
|
L5.append(Integer.toHexString(readByte & 255));
|
|
throw new IOException(L5.toString());
|
|
}
|
|
}
|
|
|
|
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(0);
|
|
byte[] bArr3 = ORF_MAKER_NOTE_HEADER_2;
|
|
byte[] bArr4 = new byte[bArr3.length];
|
|
byteOrderedDataInputStream2.readFully(bArr4);
|
|
if (Arrays.equals(bArr2, bArr)) {
|
|
byteOrderedDataInputStream2.seek(8);
|
|
} else if (Arrays.equals(bArr4, bArr3)) {
|
|
byteOrderedDataInputStream2.seek(12);
|
|
}
|
|
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) {
|
|
StringBuilder L = a.L("Invalid aspect frame values. frame=");
|
|
L.append(Arrays.toString(iArr));
|
|
Log.w("ExifInterface", L.toString());
|
|
} else if (iArr[2] > iArr[0] && iArr[3] > iArr[1]) {
|
|
int i = (iArr[2] - iArr[0]) + 1;
|
|
int i2 = (iArr[3] - iArr[1]) + 1;
|
|
if (i < i2) {
|
|
int i3 = i + i2;
|
|
i2 = i3 - i2;
|
|
i = i3 - i2;
|
|
}
|
|
ExifAttribute createUShort = ExifAttribute.createUShort(i, this.mExifByteOrder);
|
|
ExifAttribute createUShort2 = ExifAttribute.createUShort(i2, this.mExifByteOrder);
|
|
this.mAttributes[0].put("ImageWidth", createUShort);
|
|
this.mAttributes[0].put("ImageLength", createUShort2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void getPngAttributes(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "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 i = length + 4;
|
|
byte[] bArr2 = new byte[4];
|
|
if (byteOrderedDataInputStream.read(bArr2) == 4) {
|
|
int i2 = i + 4;
|
|
if (i2 == 16) {
|
|
if (!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)) {
|
|
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 = i2;
|
|
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 i3 = readInt + 4;
|
|
byteOrderedDataInputStream.skipBytes(i3);
|
|
length = i2 + i3;
|
|
} else {
|
|
return;
|
|
}
|
|
} 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 z2 = DEBUG;
|
|
if (z2) {
|
|
Log.d("ExifInterface", "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 i = ByteBuffer.wrap(bArr).getInt();
|
|
int i2 = ByteBuffer.wrap(bArr2).getInt();
|
|
int i3 = ByteBuffer.wrap(bArr3).getInt();
|
|
byte[] bArr4 = new byte[i2];
|
|
byteOrderedDataInputStream.seek((long) i);
|
|
byteOrderedDataInputStream.read(bArr4);
|
|
getJpegAttributes(new ByteOrderedDataInputStream(bArr4), i, 5);
|
|
byteOrderedDataInputStream.seek((long) i3);
|
|
byteOrderedDataInputStream.setByteOrder(ByteOrder.BIG_ENDIAN);
|
|
int readInt = byteOrderedDataInputStream.readInt();
|
|
if (z2) {
|
|
a.d0("numberOfDirectoryEntry: ", readInt, "ExifInterface");
|
|
}
|
|
for (int i4 = 0; i4 < readInt; i4++) {
|
|
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("ExifInterface", "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) {
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream2 = new ByteOrderedDataInputStream(exifAttribute.bytes);
|
|
byteOrderedDataInputStream2.setByteOrder(this.mExifByteOrder);
|
|
byteOrderedDataInputStream2.seek(6);
|
|
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("ExifInterface", "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) {
|
|
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("ExifInterface", "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 i = skipBytes + 4 + 4;
|
|
if (Arrays.equals(WEBP_CHUNK_TYPE_EXIF, bArr)) {
|
|
byte[] bArr2 = new byte[readInt2];
|
|
if (byteOrderedDataInputStream.read(bArr2) == readInt2) {
|
|
this.mOffsetToExifData = i;
|
|
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 i2 = i + readInt2;
|
|
if (i2 != readInt) {
|
|
if (i2 <= readInt) {
|
|
int skipBytes2 = byteOrderedDataInputStream.skipBytes(readInt2);
|
|
if (skipBytes2 == readInt2) {
|
|
skipBytes = i + skipBytes2;
|
|
} else {
|
|
throw new IOException("Encountered WebP file with invalid chunk size");
|
|
}
|
|
} else {
|
|
throw new IOException("Encountered WebP file with invalid chunk size");
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
} 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 i = 1; i < split.length; i++) {
|
|
Pair<Integer, Integer> guessDataFormat2 = guessDataFormat(split[i]);
|
|
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("/")) {
|
|
String[] split2 = str.split("/", -1);
|
|
if (split2.length == 2) {
|
|
try {
|
|
long parseDouble = (long) Double.parseDouble(split2[0]);
|
|
long parseDouble2 = (long) Double.parseDouble(split2[1]);
|
|
if (parseDouble >= 0) {
|
|
if (parseDouble2 >= 0) {
|
|
if (parseDouble <= 2147483647L) {
|
|
if (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 {
|
|
Long valueOf = Long.valueOf(Long.parseLong(str));
|
|
return (valueOf.longValue() < 0 || valueOf.longValue() > 65535) ? valueOf.longValue() < 0 ? new Pair<>(9, -1) : new Pair<>(4, -1) : new Pair<>(3, 4);
|
|
} catch (NumberFormatException unused2) {
|
|
try {
|
|
Double.parseDouble(str);
|
|
return new Pair<>(12, -1);
|
|
} catch (NumberFormatException unused3) {
|
|
return new Pair<>(2, -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) {
|
|
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((long) intValue);
|
|
byteOrderedDataInputStream.read(bArr);
|
|
this.mThumbnailBytes = bArr;
|
|
}
|
|
this.mThumbnailOffset = intValue;
|
|
this.mThumbnailLength = min;
|
|
}
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "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) {
|
|
long[] convertToLongArray = convertToLongArray(exifAttribute.getValue(this.mExifByteOrder));
|
|
long[] convertToLongArray2 = convertToLongArray(exifAttribute2.getValue(this.mExifByteOrder));
|
|
if (convertToLongArray == null || convertToLongArray.length == 0) {
|
|
Log.w("ExifInterface", "stripOffsets should not be null or have zero length.");
|
|
} else if (convertToLongArray2 == null || convertToLongArray2.length == 0) {
|
|
Log.w("ExifInterface", "stripByteCounts should not be null or have zero length.");
|
|
} else if (convertToLongArray.length != convertToLongArray2.length) {
|
|
Log.w("ExifInterface", "stripOffsets and stripByteCounts should have same length.");
|
|
} else {
|
|
long j = 0;
|
|
for (long j2 : convertToLongArray2) {
|
|
j += j2;
|
|
}
|
|
int i = (int) j;
|
|
byte[] bArr = new byte[i];
|
|
int i2 = 1;
|
|
this.mAreThumbnailStripsConsecutive = true;
|
|
this.mHasThumbnailStrips = true;
|
|
this.mHasThumbnail = true;
|
|
int i3 = 0;
|
|
int i4 = 0;
|
|
int i5 = 0;
|
|
while (i3 < convertToLongArray.length) {
|
|
int i6 = (int) convertToLongArray[i3];
|
|
int i7 = (int) convertToLongArray2[i3];
|
|
if (i3 < convertToLongArray.length - i2 && ((long) (i6 + i7)) != convertToLongArray[i3 + 1]) {
|
|
this.mAreThumbnailStripsConsecutive = false;
|
|
}
|
|
int i8 = i6 - i4;
|
|
if (i8 < 0) {
|
|
Log.d("ExifInterface", "Invalid strip offset value");
|
|
return;
|
|
}
|
|
long j3 = (long) i8;
|
|
if (byteOrderedDataInputStream.skip(j3) != j3) {
|
|
Log.d("ExifInterface", "Failed to skip " + i8 + " bytes.");
|
|
return;
|
|
}
|
|
int i9 = i4 + i8;
|
|
byte[] bArr2 = new byte[i7];
|
|
if (byteOrderedDataInputStream.read(bArr2) != i7) {
|
|
Log.d("ExifInterface", "Failed to read " + i7 + " bytes.");
|
|
return;
|
|
}
|
|
i4 = i9 + i7;
|
|
System.arraycopy(bArr2, 0, bArr, i5, i7);
|
|
i5 += i7;
|
|
i3++;
|
|
i2 = 1;
|
|
}
|
|
this.mThumbnailBytes = bArr;
|
|
if (this.mAreThumbnailStripsConsecutive) {
|
|
this.mThumbnailOffset = (int) convertToLongArray[0];
|
|
this.mThumbnailLength = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void initForFilename(String str) throws IOException {
|
|
Throwable th;
|
|
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 th2) {
|
|
th = th2;
|
|
fileInputStream = fileInputStream2;
|
|
closeQuietly(fileInputStream);
|
|
throw th;
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
closeQuietly(fileInputStream);
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
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 i = 0;
|
|
while (true) {
|
|
byte[] bArr3 = IDENTIFIER_EXIF_APP1;
|
|
if (i >= bArr3.length) {
|
|
return true;
|
|
}
|
|
if (bArr2[i] != bArr3[i]) {
|
|
return false;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:52:0x0092 A[Catch:{ all -> 0x008b }] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:54:0x009b */
|
|
/* JADX WARNING: Removed duplicated region for block: B:57:0x00a1 */
|
|
private boolean isHeifFormat(byte[] bArr) throws IOException {
|
|
Throwable th;
|
|
Exception e;
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream = null;
|
|
try {
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream2 = new ByteOrderedDataInputStream(bArr);
|
|
try {
|
|
long readInt = (long) byteOrderedDataInputStream2.readInt();
|
|
byte[] bArr2 = new byte[4];
|
|
byteOrderedDataInputStream2.read(bArr2);
|
|
if (!Arrays.equals(bArr2, HEIF_TYPE_FTYP)) {
|
|
byteOrderedDataInputStream2.close();
|
|
return false;
|
|
}
|
|
long j = 16;
|
|
if (readInt == 1) {
|
|
readInt = byteOrderedDataInputStream2.readLong();
|
|
if (readInt < 16) {
|
|
byteOrderedDataInputStream2.close();
|
|
return false;
|
|
}
|
|
} else {
|
|
j = 8;
|
|
}
|
|
if (readInt > ((long) bArr.length)) {
|
|
readInt = (long) bArr.length;
|
|
}
|
|
long j2 = readInt - j;
|
|
if (j2 < 8) {
|
|
byteOrderedDataInputStream2.close();
|
|
return false;
|
|
}
|
|
byte[] bArr3 = new byte[4];
|
|
boolean z2 = false;
|
|
boolean z3 = false;
|
|
for (long j3 = 0; j3 < j2 / 4; j3++) {
|
|
if (byteOrderedDataInputStream2.read(bArr3) != 4) {
|
|
byteOrderedDataInputStream2.close();
|
|
return false;
|
|
}
|
|
if (j3 != 1) {
|
|
if (Arrays.equals(bArr3, HEIF_BRAND_MIF1)) {
|
|
z2 = true;
|
|
} else if (Arrays.equals(bArr3, HEIF_BRAND_HEIC)) {
|
|
z3 = true;
|
|
}
|
|
if (z2 && z3) {
|
|
byteOrderedDataInputStream2.close();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
byteOrderedDataInputStream2.close();
|
|
return false;
|
|
} catch (Exception e2) {
|
|
e = e2;
|
|
byteOrderedDataInputStream = byteOrderedDataInputStream2;
|
|
try {
|
|
if (DEBUG) {
|
|
}
|
|
if (byteOrderedDataInputStream != null) {
|
|
}
|
|
return false;
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
if (byteOrderedDataInputStream != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
byteOrderedDataInputStream = byteOrderedDataInputStream2;
|
|
if (byteOrderedDataInputStream != null) {
|
|
byteOrderedDataInputStream.close();
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (Exception e3) {
|
|
e = e3;
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "Exception parsing HEIF file type box.", e);
|
|
}
|
|
if (byteOrderedDataInputStream != null) {
|
|
byteOrderedDataInputStream.close();
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static boolean isJpegFormat(byte[] bArr) throws IOException {
|
|
int i = 0;
|
|
while (true) {
|
|
byte[] bArr2 = JPEG_SIGNATURE;
|
|
if (i >= bArr2.length) {
|
|
return true;
|
|
}
|
|
if (bArr[i] != bArr2[i]) {
|
|
return false;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:18:0x0029 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:22:0x0030 */
|
|
private boolean isOrfFormat(byte[] bArr) throws IOException {
|
|
Throwable th;
|
|
boolean z2 = 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();
|
|
if (readShort == 20306 || readShort == 21330) {
|
|
z2 = true;
|
|
}
|
|
byteOrderedDataInputStream2.close();
|
|
return z2;
|
|
} catch (Exception unused) {
|
|
byteOrderedDataInputStream = byteOrderedDataInputStream2;
|
|
if (byteOrderedDataInputStream != null) {
|
|
}
|
|
return false;
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
byteOrderedDataInputStream = byteOrderedDataInputStream2;
|
|
if (byteOrderedDataInputStream != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (Exception unused2) {
|
|
if (byteOrderedDataInputStream != null) {
|
|
byteOrderedDataInputStream.close();
|
|
}
|
|
return false;
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
if (byteOrderedDataInputStream != null) {
|
|
byteOrderedDataInputStream.close();
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
private boolean isPngFormat(byte[] bArr) throws IOException {
|
|
int i = 0;
|
|
while (true) {
|
|
byte[] bArr2 = PNG_SIGNATURE;
|
|
if (i >= bArr2.length) {
|
|
return true;
|
|
}
|
|
if (bArr[i] != bArr2[i]) {
|
|
return false;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
private boolean isRafFormat(byte[] bArr) throws IOException {
|
|
byte[] bytes = "FUJIFILMCCD-RAW".getBytes(Charset.defaultCharset());
|
|
for (int i = 0; i < bytes.length; i++) {
|
|
if (bArr[i] != bytes[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:16:0x0025 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:20:0x002c */
|
|
private boolean isRw2Format(byte[] bArr) throws IOException {
|
|
Throwable th;
|
|
boolean z2 = false;
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream = null;
|
|
try {
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream2 = new ByteOrderedDataInputStream(bArr);
|
|
try {
|
|
ByteOrder readByteOrder = readByteOrder(byteOrderedDataInputStream2);
|
|
this.mExifByteOrder = readByteOrder;
|
|
byteOrderedDataInputStream2.setByteOrder(readByteOrder);
|
|
if (byteOrderedDataInputStream2.readShort() == 85) {
|
|
z2 = true;
|
|
}
|
|
byteOrderedDataInputStream2.close();
|
|
return z2;
|
|
} catch (Exception unused) {
|
|
byteOrderedDataInputStream = byteOrderedDataInputStream2;
|
|
if (byteOrderedDataInputStream != null) {
|
|
}
|
|
return false;
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
byteOrderedDataInputStream = byteOrderedDataInputStream2;
|
|
if (byteOrderedDataInputStream != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (Exception unused2) {
|
|
if (byteOrderedDataInputStream != null) {
|
|
byteOrderedDataInputStream.close();
|
|
}
|
|
return false;
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
if (byteOrderedDataInputStream != null) {
|
|
byteOrderedDataInputStream.close();
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
private static boolean isSeekableFD(FileDescriptor fileDescriptor) {
|
|
try {
|
|
Os.lseek(fileDescriptor, 0, OsConstants.SEEK_CUR);
|
|
return true;
|
|
} catch (Exception unused) {
|
|
if (!DEBUG) {
|
|
return false;
|
|
}
|
|
Log.d("ExifInterface", "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) {
|
|
return false;
|
|
}
|
|
Log.d("ExifInterface", "Unsupported data type value");
|
|
return false;
|
|
}
|
|
|
|
private boolean isSupportedFormatForSavingAttributes() {
|
|
int i = this.mMimeType;
|
|
return i == 4 || i == 13 || i == 14;
|
|
}
|
|
|
|
public static boolean isSupportedMimeType(@NonNull String str) {
|
|
Objects.requireNonNull(str, "mimeType shouldn't be null");
|
|
String lowerCase = str.toLowerCase(Locale.ROOT);
|
|
lowerCase.hashCode();
|
|
char c2 = 65535;
|
|
switch (lowerCase.hashCode()) {
|
|
case -1875291391:
|
|
if (lowerCase.equals("image/x-fuji-raf")) {
|
|
c2 = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case -1635437028:
|
|
if (lowerCase.equals("image/x-samsung-srw")) {
|
|
c2 = 1;
|
|
break;
|
|
}
|
|
break;
|
|
case -1594371159:
|
|
if (lowerCase.equals("image/x-sony-arw")) {
|
|
c2 = 2;
|
|
break;
|
|
}
|
|
break;
|
|
case -1487464693:
|
|
if (lowerCase.equals("image/heic")) {
|
|
c2 = 3;
|
|
break;
|
|
}
|
|
break;
|
|
case -1487464690:
|
|
if (lowerCase.equals("image/heif")) {
|
|
c2 = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case -1487394660:
|
|
if (lowerCase.equals("image/jpeg")) {
|
|
c2 = 5;
|
|
break;
|
|
}
|
|
break;
|
|
case -1487018032:
|
|
if (lowerCase.equals("image/webp")) {
|
|
c2 = 6;
|
|
break;
|
|
}
|
|
break;
|
|
case -1423313290:
|
|
if (lowerCase.equals("image/x-adobe-dng")) {
|
|
c2 = 7;
|
|
break;
|
|
}
|
|
break;
|
|
case -985160897:
|
|
if (lowerCase.equals("image/x-panasonic-rw2")) {
|
|
c2 = '\b';
|
|
break;
|
|
}
|
|
break;
|
|
case -879258763:
|
|
if (lowerCase.equals("image/png")) {
|
|
c2 = '\t';
|
|
break;
|
|
}
|
|
break;
|
|
case -332763809:
|
|
if (lowerCase.equals("image/x-pentax-pef")) {
|
|
c2 = '\n';
|
|
break;
|
|
}
|
|
break;
|
|
case 1378106698:
|
|
if (lowerCase.equals("image/x-olympus-orf")) {
|
|
c2 = 11;
|
|
break;
|
|
}
|
|
break;
|
|
case 2099152104:
|
|
if (lowerCase.equals("image/x-nikon-nef")) {
|
|
c2 = '\f';
|
|
break;
|
|
}
|
|
break;
|
|
case 2099152524:
|
|
if (lowerCase.equals("image/x-nikon-nrw")) {
|
|
c2 = '\r';
|
|
break;
|
|
}
|
|
break;
|
|
case 2111234748:
|
|
if (lowerCase.equals("image/x-canon-cr2")) {
|
|
c2 = 14;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
switch (c2) {
|
|
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 i = 0;
|
|
while (true) {
|
|
byte[] bArr2 = WEBP_SIGNATURE_1;
|
|
if (i >= bArr2.length) {
|
|
int i2 = 0;
|
|
while (true) {
|
|
byte[] bArr3 = WEBP_SIGNATURE_2;
|
|
if (i2 >= bArr3.length) {
|
|
return true;
|
|
}
|
|
if (bArr[WEBP_SIGNATURE_1.length + i2 + 4] != bArr3[i2]) {
|
|
return false;
|
|
}
|
|
i2++;
|
|
}
|
|
} else if (bArr[i] != bArr2[i]) {
|
|
return false;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void loadAttributes(@NonNull InputStream inputStream) {
|
|
Objects.requireNonNull(inputStream, "inputstream shouldn't be null");
|
|
for (int i = 0; i < EXIF_TAGS.length; i++) {
|
|
try {
|
|
this.mAttributes[i] = new HashMap<>();
|
|
} catch (IOException e) {
|
|
boolean z2 = DEBUG;
|
|
if (z2) {
|
|
Log.w("ExifInterface", "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.", e);
|
|
}
|
|
addDefaultValuesForCompatibility();
|
|
if (!z2) {
|
|
return;
|
|
}
|
|
} catch (Throwable th) {
|
|
addDefaultValuesForCompatibility();
|
|
if (DEBUG) {
|
|
printAttributes();
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
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((long) this.mOffsetToExifData);
|
|
setThumbnailData(byteOrderedDataInputStream);
|
|
addDefaultValuesForCompatibility();
|
|
if (!DEBUG) {
|
|
return;
|
|
}
|
|
printAttributes();
|
|
}
|
|
|
|
private static Long parseDateTime(@Nullable String str, @Nullable String str2, @Nullable 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) {
|
|
int i = 1;
|
|
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) || "-".equals(substring)) && ":".equals(str3.substring(3, 4)) && parseInt <= 14) {
|
|
int i2 = ((parseInt * 60) + parseInt2) * 60 * 1000;
|
|
if (!"-".equals(substring)) {
|
|
i = -1;
|
|
}
|
|
time += (long) (i2 * i);
|
|
}
|
|
}
|
|
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 i) throws IOException {
|
|
ByteOrder readByteOrder = readByteOrder(byteOrderedDataInputStream);
|
|
this.mExifByteOrder = readByteOrder;
|
|
byteOrderedDataInputStream.setByteOrder(readByteOrder);
|
|
int readUnsignedShort = byteOrderedDataInputStream.readUnsignedShort();
|
|
int i2 = this.mMimeType;
|
|
if (i2 == 7 || i2 == 10 || readUnsignedShort == 42) {
|
|
int readInt = byteOrderedDataInputStream.readInt();
|
|
if (readInt < 8 || readInt >= i) {
|
|
throw new IOException(a.k("Invalid first Ifd offset: ", readInt));
|
|
}
|
|
int i3 = readInt - 8;
|
|
if (i3 > 0 && byteOrderedDataInputStream.skipBytes(i3) != i3) {
|
|
throw new IOException(a.k("Couldn't jump to first Ifd: ", i3));
|
|
}
|
|
return;
|
|
}
|
|
StringBuilder L = a.L("Invalid start code: ");
|
|
L.append(Integer.toHexString(readUnsignedShort));
|
|
throw new IOException(L.toString());
|
|
}
|
|
|
|
private void printAttributes() {
|
|
for (int i = 0; i < this.mAttributes.length; i++) {
|
|
StringBuilder M = a.M("The size of tag group[", i, "]: ");
|
|
M.append(this.mAttributes[i].size());
|
|
Log.d("ExifInterface", M.toString());
|
|
for (Map.Entry<String, ExifAttribute> entry : this.mAttributes[i].entrySet()) {
|
|
ExifAttribute value = entry.getValue();
|
|
StringBuilder L = a.L("tagName: ");
|
|
L.append(entry.getKey());
|
|
L.append(", tagType: ");
|
|
L.append(value.toString());
|
|
L.append(", tagValue: '");
|
|
L.append(value.getStringValue(this.mExifByteOrder));
|
|
L.append("'");
|
|
Log.d("ExifInterface", L.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private ByteOrder readByteOrder(ByteOrderedDataInputStream byteOrderedDataInputStream) throws IOException {
|
|
short readShort = byteOrderedDataInputStream.readShort();
|
|
if (readShort == 18761) {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "readExifSegment: Byte Align II");
|
|
}
|
|
return ByteOrder.LITTLE_ENDIAN;
|
|
} else if (readShort == 19789) {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "readExifSegment: Byte Align MM");
|
|
}
|
|
return ByteOrder.BIG_ENDIAN;
|
|
} else {
|
|
StringBuilder L = a.L("Invalid byte order: ");
|
|
L.append(Integer.toHexString(readShort));
|
|
throw new IOException(L.toString());
|
|
}
|
|
}
|
|
|
|
private void readExifSegment(byte[] bArr, int i) throws IOException {
|
|
ByteOrderedDataInputStream byteOrderedDataInputStream = new ByteOrderedDataInputStream(bArr);
|
|
parseTiffHeaders(byteOrderedDataInputStream, bArr.length);
|
|
readImageFileDirectory(byteOrderedDataInputStream, i);
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:103:0x026a */
|
|
/* JADX WARNING: Removed duplicated region for block: B:46:0x0108 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:47:0x010d */
|
|
/* JADX WARNING: Removed duplicated region for block: B:65:0x018e */
|
|
/* JADX WARNING: Removed duplicated region for block: B:66:0x0192 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:92:0x0206 */
|
|
private void readImageFileDirectory(ByteOrderedDataInputStream byteOrderedDataInputStream, int i) throws IOException {
|
|
short s2;
|
|
short s3;
|
|
boolean z2;
|
|
long j;
|
|
long j2;
|
|
int i2;
|
|
ExifTag exifTag;
|
|
int i3;
|
|
long j3;
|
|
int i4;
|
|
long j4;
|
|
int i5 = i;
|
|
this.mAttributesOffsets.add(Integer.valueOf(byteOrderedDataInputStream.mPosition));
|
|
if (byteOrderedDataInputStream.mPosition + 2 <= byteOrderedDataInputStream.mLength) {
|
|
short readShort = byteOrderedDataInputStream.readShort();
|
|
if (DEBUG) {
|
|
a.d0("numberOfDirectoryEntry: ", readShort, "ExifInterface");
|
|
}
|
|
if ((readShort * 12) + byteOrderedDataInputStream.mPosition <= byteOrderedDataInputStream.mLength && readShort > 0) {
|
|
char c2 = 0;
|
|
short s4 = 0;
|
|
while (s4 < readShort) {
|
|
int readUnsignedShort = byteOrderedDataInputStream.readUnsignedShort();
|
|
int readUnsignedShort2 = byteOrderedDataInputStream.readUnsignedShort();
|
|
int readInt = byteOrderedDataInputStream.readInt();
|
|
long peek = ((long) byteOrderedDataInputStream.peek()) + 4;
|
|
ExifTag exifTag2 = sExifTagMapsForReading[i5].get(Integer.valueOf(readUnsignedShort));
|
|
boolean z3 = DEBUG;
|
|
if (z3) {
|
|
Object[] objArr = new Object[5];
|
|
objArr[c2] = Integer.valueOf(i);
|
|
objArr[1] = Integer.valueOf(readUnsignedShort);
|
|
objArr[2] = exifTag2 != null ? exifTag2.name : null;
|
|
objArr[3] = Integer.valueOf(readUnsignedShort2);
|
|
objArr[4] = Integer.valueOf(readInt);
|
|
Log.d("ExifInterface", String.format("ifdType: %d, tagNumber: %d, tagName: %s, dataFormat: %d, numberOfComponents: %d", objArr));
|
|
}
|
|
if (exifTag2 != null) {
|
|
if (readUnsignedShort2 > 0) {
|
|
int[] iArr = IFD_FORMAT_BYTES_PER_FORMAT;
|
|
if (readUnsignedShort2 < iArr.length) {
|
|
if (exifTag2.isFormatCompatible(readUnsignedShort2)) {
|
|
if (readUnsignedShort2 == 7) {
|
|
readUnsignedShort2 = exifTag2.primaryFormat;
|
|
}
|
|
s3 = readShort;
|
|
s2 = s4;
|
|
j = ((long) readInt) * ((long) iArr[readUnsignedShort2]);
|
|
if (j < 0 || j > 2147483647L) {
|
|
if (z3) {
|
|
a.d0("Skip the tag entry since the number of components is invalid: ", readInt, "ExifInterface");
|
|
}
|
|
z2 = false;
|
|
if (z2) {
|
|
byteOrderedDataInputStream.seek(peek);
|
|
} else {
|
|
if (j > 4) {
|
|
int readInt2 = byteOrderedDataInputStream.readInt();
|
|
if (z3) {
|
|
a.d0("seek to data offset: ", readInt2, "ExifInterface");
|
|
}
|
|
i3 = readUnsignedShort2;
|
|
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);
|
|
exifTag = exifTag2;
|
|
ExifAttribute createULong = ExifAttribute.createULong((long) this.mOrfThumbnailOffset, this.mExifByteOrder);
|
|
i2 = readInt;
|
|
ExifAttribute createULong2 = ExifAttribute.createULong((long) this.mOrfThumbnailLength, this.mExifByteOrder);
|
|
this.mAttributes[4].put("Compression", createUShort);
|
|
this.mAttributes[4].put("JPEGInterchangeFormat", createULong);
|
|
this.mAttributes[4].put("JPEGInterchangeFormatLength", createULong2);
|
|
j4 = (long) readInt2;
|
|
j2 = j;
|
|
if (j4 + j > ((long) byteOrderedDataInputStream.mLength)) {
|
|
byteOrderedDataInputStream.seek(j4);
|
|
} else {
|
|
if (z3) {
|
|
a.d0("Skip the tag entry since data offset is invalid: ", readInt2, "ExifInterface");
|
|
}
|
|
byteOrderedDataInputStream.seek(peek);
|
|
}
|
|
}
|
|
}
|
|
i2 = readInt;
|
|
exifTag = exifTag2;
|
|
j4 = (long) readInt2;
|
|
j2 = j;
|
|
if (j4 + j > ((long) byteOrderedDataInputStream.mLength)) {
|
|
}
|
|
} else {
|
|
j2 = j;
|
|
i3 = readUnsignedShort2;
|
|
i2 = readInt;
|
|
exifTag = exifTag2;
|
|
}
|
|
Integer num = sExifPointerTagMap.get(Integer.valueOf(readUnsignedShort));
|
|
if (z3) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("nextIfdType: ");
|
|
sb.append(num);
|
|
sb.append(" byteCount: ");
|
|
j3 = j2;
|
|
sb.append(j3);
|
|
Log.d("ExifInterface", sb.toString());
|
|
} else {
|
|
j3 = j2;
|
|
}
|
|
if (num != null) {
|
|
long j5 = -1;
|
|
if (i3 != 3) {
|
|
if (i3 == 4) {
|
|
j5 = byteOrderedDataInputStream.readUnsignedInt();
|
|
} else if (i3 == 8) {
|
|
i4 = byteOrderedDataInputStream.readShort();
|
|
} else if (i3 == 9 || i3 == 13) {
|
|
i4 = byteOrderedDataInputStream.readInt();
|
|
}
|
|
if (z3) {
|
|
Log.d("ExifInterface", String.format("Offset: %d, tagName: %s", Long.valueOf(j5), exifTag.name));
|
|
}
|
|
if (j5 > 0 || j5 >= ((long) byteOrderedDataInputStream.mLength)) {
|
|
if (z3) {
|
|
Log.d("ExifInterface", "Skip jump into the IFD since its offset is invalid: " + j5);
|
|
}
|
|
} else if (!this.mAttributesOffsets.contains(Integer.valueOf((int) j5))) {
|
|
byteOrderedDataInputStream.seek(j5);
|
|
readImageFileDirectory(byteOrderedDataInputStream, num.intValue());
|
|
} else if (z3) {
|
|
Log.d("ExifInterface", "Skip jump into the IFD since it has already been read: IfdType " + num + " (at " + j5 + ")");
|
|
}
|
|
byteOrderedDataInputStream.seek(peek);
|
|
} else {
|
|
i4 = byteOrderedDataInputStream.readUnsignedShort();
|
|
}
|
|
j5 = (long) i4;
|
|
if (z3) {
|
|
}
|
|
if (j5 > 0) {
|
|
}
|
|
if (z3) {
|
|
}
|
|
byteOrderedDataInputStream.seek(peek);
|
|
} else {
|
|
int peek2 = byteOrderedDataInputStream.peek() + this.mOffsetToExifData;
|
|
byte[] bArr = new byte[((int) j3)];
|
|
byteOrderedDataInputStream.readFully(bArr);
|
|
ExifAttribute exifAttribute = new ExifAttribute(i3, i2, (long) peek2, bArr);
|
|
this.mAttributes[i].put(exifTag.name, exifAttribute);
|
|
if ("DNGVersion".equals(exifTag.name)) {
|
|
this.mMimeType = 3;
|
|
}
|
|
if ((("Make".equals(exifTag.name) || "Model".equals(exifTag.name)) && exifAttribute.getStringValue(this.mExifByteOrder).contains("PENTAX")) || ("Compression".equals(exifTag.name) && exifAttribute.getIntValue(this.mExifByteOrder) == 65535)) {
|
|
this.mMimeType = 8;
|
|
}
|
|
if (((long) byteOrderedDataInputStream.peek()) != peek) {
|
|
byteOrderedDataInputStream.seek(peek);
|
|
}
|
|
}
|
|
}
|
|
s4 = (short) (s2 + 1);
|
|
c2 = 0;
|
|
i5 = i;
|
|
readShort = s3;
|
|
} else {
|
|
z2 = true;
|
|
if (z2) {
|
|
}
|
|
s4 = (short) (s2 + 1);
|
|
c2 = 0;
|
|
i5 = i;
|
|
readShort = s3;
|
|
}
|
|
} else if (z3) {
|
|
StringBuilder L = a.L("Skip the tag entry since data format (");
|
|
L.append(IFD_FORMAT_NAMES[readUnsignedShort2]);
|
|
L.append(") is unexpected for tag: ");
|
|
L.append(exifTag2.name);
|
|
Log.d("ExifInterface", L.toString());
|
|
}
|
|
}
|
|
}
|
|
s3 = readShort;
|
|
s2 = s4;
|
|
if (z3) {
|
|
a.d0("Skip the tag entry since data format is invalid: ", readUnsignedShort2, "ExifInterface");
|
|
}
|
|
j = 0;
|
|
z2 = false;
|
|
if (z2) {
|
|
}
|
|
s4 = (short) (s2 + 1);
|
|
c2 = 0;
|
|
i5 = i;
|
|
readShort = s3;
|
|
} else if (z3) {
|
|
a.d0("Skip the tag entry since tag number is not defined: ", readUnsignedShort, "ExifInterface");
|
|
}
|
|
s3 = readShort;
|
|
s2 = s4;
|
|
j = 0;
|
|
z2 = false;
|
|
if (z2) {
|
|
}
|
|
s4 = (short) (s2 + 1);
|
|
c2 = 0;
|
|
i5 = i;
|
|
readShort = s3;
|
|
}
|
|
if (byteOrderedDataInputStream.peek() + 4 <= byteOrderedDataInputStream.mLength) {
|
|
int readInt3 = byteOrderedDataInputStream.readInt();
|
|
boolean z4 = DEBUG;
|
|
if (z4) {
|
|
Log.d("ExifInterface", String.format("nextIfdOffset: %d", Integer.valueOf(readInt3)));
|
|
}
|
|
long j6 = (long) readInt3;
|
|
if (j6 <= 0 || readInt3 >= byteOrderedDataInputStream.mLength) {
|
|
if (z4) {
|
|
a.d0("Stop reading file since a wrong offset may cause an infinite loop: ", readInt3, "ExifInterface");
|
|
}
|
|
} else if (!this.mAttributesOffsets.contains(Integer.valueOf(readInt3))) {
|
|
byteOrderedDataInputStream.seek(j6);
|
|
if (this.mAttributes[4].isEmpty()) {
|
|
readImageFileDirectory(byteOrderedDataInputStream, 4);
|
|
} else if (this.mAttributes[5].isEmpty()) {
|
|
readImageFileDirectory(byteOrderedDataInputStream, 5);
|
|
}
|
|
} else if (z4) {
|
|
a.d0("Stop reading file since re-reading an IFD may cause an infinite loop: ", readInt3, "ExifInterface");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void removeAttribute(String str) {
|
|
for (int i = 0; i < EXIF_TAGS.length; i++) {
|
|
this.mAttributes[i].remove(str);
|
|
}
|
|
}
|
|
|
|
private void retrieveJpegImageSize(ByteOrderedDataInputStream byteOrderedDataInputStream, int i) throws IOException {
|
|
ExifAttribute exifAttribute = this.mAttributes[i].get("ImageLength");
|
|
ExifAttribute exifAttribute2 = this.mAttributes[i].get("ImageWidth");
|
|
if (exifAttribute == null || exifAttribute2 == null) {
|
|
ExifAttribute exifAttribute3 = this.mAttributes[i].get("JPEGInterchangeFormat");
|
|
ExifAttribute exifAttribute4 = this.mAttributes[i].get("JPEGInterchangeFormatLength");
|
|
if (exifAttribute3 != null && exifAttribute4 != null) {
|
|
int intValue = exifAttribute3.getIntValue(this.mExifByteOrder);
|
|
int intValue2 = exifAttribute3.getIntValue(this.mExifByteOrder);
|
|
byteOrderedDataInputStream.seek((long) intValue);
|
|
byte[] bArr = new byte[intValue2];
|
|
byteOrderedDataInputStream.read(bArr);
|
|
getJpegAttributes(new ByteOrderedDataInputStream(bArr), intValue, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void saveJpegAttributes(InputStream inputStream, OutputStream outputStream) throws IOException {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "saveJpegAttributes starting with (inputStream: " + inputStream + ", outputStream: " + outputStream + ")");
|
|
}
|
|
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 i = readUnsignedShort - 2;
|
|
if (i >= 0) {
|
|
while (i > 0) {
|
|
int read = dataInputStream.read(bArr, 0, Math.min(i, 4096));
|
|
if (read < 0) {
|
|
break;
|
|
}
|
|
byteOrderedDataOutputStream.write(bArr, 0, read);
|
|
i -= read;
|
|
}
|
|
} else {
|
|
throw new IOException("Invalid length");
|
|
}
|
|
} else {
|
|
int readUnsignedShort2 = dataInputStream.readUnsignedShort() - 2;
|
|
if (readUnsignedShort2 >= 0) {
|
|
byte[] bArr2 = new byte[6];
|
|
if (readUnsignedShort2 >= 6) {
|
|
if (dataInputStream.read(bArr2) != 6) {
|
|
throw new IOException("Invalid exif");
|
|
} else if (Arrays.equals(bArr2, IDENTIFIER_EXIF_APP1)) {
|
|
int i2 = readUnsignedShort2 - 6;
|
|
if (dataInputStream.skipBytes(i2) != i2) {
|
|
throw new IOException("Invalid length");
|
|
}
|
|
}
|
|
}
|
|
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) {
|
|
break;
|
|
}
|
|
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 {
|
|
Throwable th;
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "savePngAttributes starting with (inputStream: " + inputStream + ", outputStream: " + outputStream + ")");
|
|
}
|
|
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 i = this.mOffsetToExifData;
|
|
if (i == 0) {
|
|
int readInt = dataInputStream.readInt();
|
|
byteOrderedDataOutputStream.writeInt(readInt);
|
|
copy(dataInputStream, byteOrderedDataOutputStream, readInt + 4 + 4);
|
|
} else {
|
|
copy(dataInputStream, byteOrderedDataOutputStream, ((i - bArr.length) - 4) - 4);
|
|
dataInputStream.skipBytes(dataInputStream.readInt() + 4 + 4);
|
|
}
|
|
ByteArrayOutputStream byteArrayOutputStream = null;
|
|
try {
|
|
ByteArrayOutputStream byteArrayOutputStream2 = new ByteArrayOutputStream();
|
|
try {
|
|
ByteOrderedDataOutputStream byteOrderedDataOutputStream2 = new ByteOrderedDataOutputStream(byteArrayOutputStream2, 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(byteArrayOutputStream2);
|
|
copy(dataInputStream, byteOrderedDataOutputStream);
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
byteArrayOutputStream = byteArrayOutputStream2;
|
|
closeQuietly(byteArrayOutputStream);
|
|
throw th;
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
closeQuietly(byteArrayOutputStream);
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:58:0x01ac A[Catch:{ Exception -> 0x01f1, all -> 0x01ee }] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:59:0x01b8 A[Catch:{ Exception -> 0x01f1, all -> 0x01ee }] */
|
|
private void saveWebpAttributes(InputStream inputStream, OutputStream outputStream) throws IOException {
|
|
Throwable th;
|
|
Exception e;
|
|
int i;
|
|
int i2;
|
|
int i3;
|
|
int i4;
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "saveWebpAttributes starting with (inputStream: " + inputStream + ", outputStream: " + outputStream + ")");
|
|
}
|
|
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 byteArrayOutputStream = null;
|
|
try {
|
|
ByteArrayOutputStream byteArrayOutputStream2 = new ByteArrayOutputStream();
|
|
try {
|
|
ByteOrderedDataOutputStream byteOrderedDataOutputStream2 = new ByteOrderedDataOutputStream(byteArrayOutputStream2, byteOrder);
|
|
int i5 = this.mOffsetToExifData;
|
|
if (i5 != 0) {
|
|
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream2, ((i5 - ((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 z2 = 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) {
|
|
z2 = false;
|
|
}
|
|
byteOrderedDataOutputStream2.write(bArr4);
|
|
byteOrderedDataOutputStream2.writeInt(readInt);
|
|
byteOrderedDataOutputStream2.write(bArr5);
|
|
if (z2) {
|
|
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 i6 = 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)) {
|
|
throw new IOException("Encountered error while checking VP8 signature");
|
|
}
|
|
i4 = byteOrderedDataInputStream.readInt();
|
|
i3 = (i4 << 18) >> 18;
|
|
i2 = (i4 << 2) >> 18;
|
|
i6 -= 10;
|
|
} else if (!Arrays.equals(bArr3, WEBP_CHUNK_TYPE_VP8L)) {
|
|
i4 = 0;
|
|
i3 = 0;
|
|
i2 = 0;
|
|
} else if (byteOrderedDataInputStream.readByte() == 47) {
|
|
i4 = byteOrderedDataInputStream.readInt();
|
|
i = i4 & 8;
|
|
i6 -= 5;
|
|
i2 = ((i4 << 4) >> 18) + 1;
|
|
i3 = ((i4 << 18) >> 18) + 1;
|
|
byteOrderedDataOutputStream2.write(bArr4);
|
|
byteOrderedDataOutputStream2.writeInt(10);
|
|
byte[] bArr10 = new byte[10];
|
|
bArr10[0] = (byte) (bArr10[0] | 8);
|
|
bArr10[0] = (byte) (bArr10[0] | (i << 4));
|
|
int i7 = i3 - 1;
|
|
int i8 = i2 - 1;
|
|
bArr10[4] = (byte) i7;
|
|
bArr10[5] = (byte) (i7 >> 8);
|
|
bArr10[6] = (byte) (i7 >> 16);
|
|
bArr10[7] = (byte) i8;
|
|
bArr10[8] = (byte) (i8 >> 8);
|
|
bArr10[9] = (byte) (i8 >> 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(i4);
|
|
} else if (Arrays.equals(bArr3, WEBP_CHUNK_TYPE_VP8L)) {
|
|
byteOrderedDataOutputStream2.write(47);
|
|
byteOrderedDataOutputStream2.writeInt(i4);
|
|
}
|
|
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream2, i6);
|
|
writeExifSegment(byteOrderedDataOutputStream2);
|
|
} else {
|
|
throw new IOException("Encountered error while checking VP8L signature");
|
|
}
|
|
i = 0;
|
|
byteOrderedDataOutputStream2.write(bArr4);
|
|
byteOrderedDataOutputStream2.writeInt(10);
|
|
byte[] bArr10 = new byte[10];
|
|
bArr10[0] = (byte) (bArr10[0] | 8);
|
|
bArr10[0] = (byte) (bArr10[0] | (i << 4));
|
|
int i7 = i3 - 1;
|
|
int i8 = i2 - 1;
|
|
bArr10[4] = (byte) i7;
|
|
bArr10[5] = (byte) (i7 >> 8);
|
|
bArr10[6] = (byte) (i7 >> 16);
|
|
bArr10[7] = (byte) i8;
|
|
bArr10[8] = (byte) (i8 >> 8);
|
|
bArr10[9] = (byte) (i8 >> 16);
|
|
byteOrderedDataOutputStream2.write(bArr10);
|
|
byteOrderedDataOutputStream2.write(bArr3);
|
|
byteOrderedDataOutputStream2.writeInt(readInt2);
|
|
if (!Arrays.equals(bArr3, bArr7)) {
|
|
}
|
|
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream2, i6);
|
|
writeExifSegment(byteOrderedDataOutputStream2);
|
|
}
|
|
}
|
|
} else {
|
|
throw new IOException("Encountered invalid length while parsing WebP chunk type");
|
|
}
|
|
}
|
|
copy(byteOrderedDataInputStream, byteOrderedDataOutputStream2);
|
|
int size = byteArrayOutputStream2.size();
|
|
byte[] bArr11 = WEBP_SIGNATURE_2;
|
|
byteOrderedDataOutputStream.writeInt(size + bArr11.length);
|
|
byteOrderedDataOutputStream.write(bArr11);
|
|
byteArrayOutputStream2.writeTo(byteOrderedDataOutputStream);
|
|
closeQuietly(byteArrayOutputStream2);
|
|
} catch (Exception e2) {
|
|
e = e2;
|
|
byteArrayOutputStream = byteArrayOutputStream2;
|
|
try {
|
|
throw new IOException("Failed to save WebP file", e);
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
closeQuietly(byteArrayOutputStream);
|
|
throw th;
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
byteArrayOutputStream = byteArrayOutputStream2;
|
|
closeQuietly(byteArrayOutputStream);
|
|
throw th;
|
|
}
|
|
} catch (Exception e3) {
|
|
e = e3;
|
|
throw new IOException("Failed to save WebP file", e);
|
|
}
|
|
}
|
|
|
|
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 i = 0; i < bArr2.length; i++) {
|
|
if (bArr[i] != bArr2[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void swapBasedOnImageSize(int i, int i2) throws IOException {
|
|
if (!this.mAttributes[i].isEmpty() && !this.mAttributes[i2].isEmpty()) {
|
|
ExifAttribute exifAttribute = this.mAttributes[i].get("ImageLength");
|
|
ExifAttribute exifAttribute2 = this.mAttributes[i].get("ImageWidth");
|
|
ExifAttribute exifAttribute3 = this.mAttributes[i2].get("ImageLength");
|
|
ExifAttribute exifAttribute4 = this.mAttributes[i2].get("ImageWidth");
|
|
if (exifAttribute == null || exifAttribute2 == null) {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "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) {
|
|
HashMap<String, ExifAttribute>[] hashMapArr = this.mAttributes;
|
|
HashMap<String, ExifAttribute> hashMap = hashMapArr[i];
|
|
hashMapArr[i] = hashMapArr[i2];
|
|
hashMapArr[i2] = hashMap;
|
|
}
|
|
} else if (DEBUG) {
|
|
Log.d("ExifInterface", "Second image does not contain valid size information");
|
|
}
|
|
} else if (DEBUG) {
|
|
Log.d("ExifInterface", "Cannot perform swap since only one image data exists");
|
|
}
|
|
}
|
|
|
|
private void updateImageSizeValues(ByteOrderedDataInputStream byteOrderedDataInputStream, int i) throws IOException {
|
|
ExifAttribute exifAttribute;
|
|
ExifAttribute exifAttribute2;
|
|
ExifAttribute exifAttribute3 = this.mAttributes[i].get("DefaultCropSize");
|
|
ExifAttribute exifAttribute4 = this.mAttributes[i].get("SensorTopBorder");
|
|
ExifAttribute exifAttribute5 = this.mAttributes[i].get("SensorLeftBorder");
|
|
ExifAttribute exifAttribute6 = this.mAttributes[i].get("SensorBottomBorder");
|
|
ExifAttribute exifAttribute7 = this.mAttributes[i].get("SensorRightBorder");
|
|
if (exifAttribute3 != null) {
|
|
if (exifAttribute3.format == 5) {
|
|
Rational[] rationalArr = (Rational[]) exifAttribute3.getValue(this.mExifByteOrder);
|
|
if (rationalArr == null || rationalArr.length != 2) {
|
|
StringBuilder L = a.L("Invalid crop size values. cropSize=");
|
|
L.append(Arrays.toString(rationalArr));
|
|
Log.w("ExifInterface", L.toString());
|
|
return;
|
|
}
|
|
exifAttribute2 = ExifAttribute.createURational(rationalArr[0], this.mExifByteOrder);
|
|
exifAttribute = ExifAttribute.createURational(rationalArr[1], this.mExifByteOrder);
|
|
} else {
|
|
int[] iArr = (int[]) exifAttribute3.getValue(this.mExifByteOrder);
|
|
if (iArr == null || iArr.length != 2) {
|
|
StringBuilder L2 = a.L("Invalid crop size values. cropSize=");
|
|
L2.append(Arrays.toString(iArr));
|
|
Log.w("ExifInterface", L2.toString());
|
|
return;
|
|
}
|
|
exifAttribute2 = ExifAttribute.createUShort(iArr[0], this.mExifByteOrder);
|
|
exifAttribute = ExifAttribute.createUShort(iArr[1], this.mExifByteOrder);
|
|
}
|
|
this.mAttributes[i].put("ImageWidth", exifAttribute2);
|
|
this.mAttributes[i].put("ImageLength", exifAttribute);
|
|
} else if (exifAttribute4 == null || exifAttribute5 == null || exifAttribute6 == null || exifAttribute7 == null) {
|
|
retrieveJpegImageSize(byteOrderedDataInputStream, i);
|
|
} else {
|
|
int intValue = exifAttribute4.getIntValue(this.mExifByteOrder);
|
|
int intValue2 = exifAttribute6.getIntValue(this.mExifByteOrder);
|
|
int intValue3 = exifAttribute7.getIntValue(this.mExifByteOrder);
|
|
int intValue4 = exifAttribute5.getIntValue(this.mExifByteOrder);
|
|
if (intValue2 > intValue && intValue3 > intValue4) {
|
|
ExifAttribute createUShort = ExifAttribute.createUShort(intValue2 - intValue, this.mExifByteOrder);
|
|
ExifAttribute createUShort2 = ExifAttribute.createUShort(intValue3 - intValue4, this.mExifByteOrder);
|
|
this.mAttributes[i].put("ImageLength", createUShort);
|
|
this.mAttributes[i].put("ImageWidth", 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])) {
|
|
Log.d("ExifInterface", "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 i = 0; i < EXIF_TAGS.length; i++) {
|
|
for (Object obj : this.mAttributes[i].entrySet().toArray()) {
|
|
Map.Entry entry = (Map.Entry) obj;
|
|
if (entry.getValue() == null) {
|
|
this.mAttributes[i].remove(entry.getKey());
|
|
}
|
|
}
|
|
}
|
|
if (!this.mAttributes[1].isEmpty()) {
|
|
this.mAttributes[0].put(EXIF_POINTER_TAGS[1].name, ExifAttribute.createULong(0, this.mExifByteOrder));
|
|
}
|
|
if (!this.mAttributes[2].isEmpty()) {
|
|
this.mAttributes[0].put(EXIF_POINTER_TAGS[2].name, ExifAttribute.createULong(0, this.mExifByteOrder));
|
|
}
|
|
if (!this.mAttributes[3].isEmpty()) {
|
|
this.mAttributes[1].put(EXIF_POINTER_TAGS[3].name, ExifAttribute.createULong(0, this.mExifByteOrder));
|
|
}
|
|
if (this.mHasThumbnail) {
|
|
this.mAttributes[4].put(JPEG_INTERCHANGE_FORMAT_TAG.name, ExifAttribute.createULong(0, this.mExifByteOrder));
|
|
this.mAttributes[4].put(JPEG_INTERCHANGE_FORMAT_LENGTH_TAG.name, ExifAttribute.createULong((long) this.mThumbnailLength, this.mExifByteOrder));
|
|
}
|
|
for (int i2 = 0; i2 < EXIF_TAGS.length; i2++) {
|
|
int i3 = 0;
|
|
for (Map.Entry<String, ExifAttribute> entry2 : this.mAttributes[i2].entrySet()) {
|
|
int size = entry2.getValue().size();
|
|
if (size > 4) {
|
|
i3 += size;
|
|
}
|
|
}
|
|
iArr2[i2] = iArr2[i2] + i3;
|
|
}
|
|
int i4 = 8;
|
|
for (int i5 = 0; i5 < EXIF_TAGS.length; i5++) {
|
|
if (!this.mAttributes[i5].isEmpty()) {
|
|
iArr[i5] = i4;
|
|
i4 = (this.mAttributes[i5].size() * 12) + 2 + 4 + iArr2[i5] + i4;
|
|
}
|
|
}
|
|
if (this.mHasThumbnail) {
|
|
this.mAttributes[4].put(JPEG_INTERCHANGE_FORMAT_TAG.name, ExifAttribute.createULong((long) i4, this.mExifByteOrder));
|
|
this.mThumbnailOffset = i4;
|
|
i4 += this.mThumbnailLength;
|
|
}
|
|
if (this.mMimeType == 4) {
|
|
i4 += 8;
|
|
}
|
|
if (DEBUG) {
|
|
for (int i6 = 0; i6 < EXIF_TAGS.length; i6++) {
|
|
Log.d("ExifInterface", String.format("index: %d, offsets: %d, tag count: %d, data sizes: %d, total size: %d", Integer.valueOf(i6), Integer.valueOf(iArr[i6]), Integer.valueOf(this.mAttributes[i6].size()), Integer.valueOf(iArr2[i6]), Integer.valueOf(i4)));
|
|
}
|
|
}
|
|
if (!this.mAttributes[1].isEmpty()) {
|
|
this.mAttributes[0].put(EXIF_POINTER_TAGS[1].name, ExifAttribute.createULong((long) iArr[1], this.mExifByteOrder));
|
|
}
|
|
if (!this.mAttributes[2].isEmpty()) {
|
|
this.mAttributes[0].put(EXIF_POINTER_TAGS[2].name, ExifAttribute.createULong((long) iArr[2], this.mExifByteOrder));
|
|
}
|
|
if (!this.mAttributes[3].isEmpty()) {
|
|
this.mAttributes[1].put(EXIF_POINTER_TAGS[3].name, ExifAttribute.createULong((long) iArr[3], this.mExifByteOrder));
|
|
}
|
|
int i7 = this.mMimeType;
|
|
if (i7 == 4) {
|
|
byteOrderedDataOutputStream.writeUnsignedShort(i4);
|
|
byteOrderedDataOutputStream.write(IDENTIFIER_EXIF_APP1);
|
|
} else if (i7 == 13) {
|
|
byteOrderedDataOutputStream.writeInt(i4);
|
|
byteOrderedDataOutputStream.write(PNG_CHUNK_TYPE_EXIF);
|
|
} else if (i7 == 14) {
|
|
byteOrderedDataOutputStream.write(WEBP_CHUNK_TYPE_EXIF);
|
|
byteOrderedDataOutputStream.writeInt(i4);
|
|
}
|
|
byteOrderedDataOutputStream.writeShort(this.mExifByteOrder == ByteOrder.BIG_ENDIAN ? (short) 19789 : 18761);
|
|
byteOrderedDataOutputStream.setByteOrder(this.mExifByteOrder);
|
|
byteOrderedDataOutputStream.writeUnsignedShort(42);
|
|
byteOrderedDataOutputStream.writeUnsignedInt(8);
|
|
for (int i8 = 0; i8 < EXIF_TAGS.length; i8++) {
|
|
if (!this.mAttributes[i8].isEmpty()) {
|
|
byteOrderedDataOutputStream.writeUnsignedShort(this.mAttributes[i8].size());
|
|
int size2 = (this.mAttributes[i8].size() * 12) + iArr[i8] + 2 + 4;
|
|
for (Map.Entry<String, ExifAttribute> entry3 : this.mAttributes[i8].entrySet()) {
|
|
int i9 = sExifTagMapsForWriting[i8].get(entry3.getKey()).number;
|
|
ExifAttribute value = entry3.getValue();
|
|
int size3 = value.size();
|
|
byteOrderedDataOutputStream.writeUnsignedShort(i9);
|
|
byteOrderedDataOutputStream.writeUnsignedShort(value.format);
|
|
byteOrderedDataOutputStream.writeInt(value.numberOfComponents);
|
|
if (size3 > 4) {
|
|
byteOrderedDataOutputStream.writeUnsignedInt((long) size2);
|
|
size2 += size3;
|
|
} else {
|
|
byteOrderedDataOutputStream.write(value.bytes);
|
|
if (size3 < 4) {
|
|
while (size3 < 4) {
|
|
byteOrderedDataOutputStream.writeByte(0);
|
|
size3++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (i8 != 0 || this.mAttributes[4].isEmpty()) {
|
|
byteOrderedDataOutputStream.writeUnsignedInt(0);
|
|
} else {
|
|
byteOrderedDataOutputStream.writeUnsignedInt((long) iArr[4]);
|
|
}
|
|
for (Map.Entry<String, ExifAttribute> entry4 : this.mAttributes[i8].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 && i4 % 2 == 1) {
|
|
byteOrderedDataOutputStream.writeByte(0);
|
|
}
|
|
byteOrderedDataOutputStream.setByteOrder(ByteOrder.BIG_ENDIAN);
|
|
return i4;
|
|
}
|
|
|
|
public void flipHorizontally() {
|
|
int i = 1;
|
|
switch (getAttributeInt("Orientation", 1)) {
|
|
case 1:
|
|
i = 2;
|
|
break;
|
|
case 2:
|
|
break;
|
|
case 3:
|
|
i = 4;
|
|
break;
|
|
case 4:
|
|
i = 3;
|
|
break;
|
|
case 5:
|
|
i = 6;
|
|
break;
|
|
case 6:
|
|
i = 5;
|
|
break;
|
|
case 7:
|
|
i = 8;
|
|
break;
|
|
case 8:
|
|
i = 7;
|
|
break;
|
|
default:
|
|
i = 0;
|
|
break;
|
|
}
|
|
setAttribute("Orientation", Integer.toString(i));
|
|
}
|
|
|
|
public void flipVertically() {
|
|
int i = 1;
|
|
switch (getAttributeInt("Orientation", 1)) {
|
|
case 1:
|
|
i = 4;
|
|
break;
|
|
case 2:
|
|
i = 3;
|
|
break;
|
|
case 3:
|
|
i = 2;
|
|
break;
|
|
case 4:
|
|
break;
|
|
case 5:
|
|
i = 8;
|
|
break;
|
|
case 6:
|
|
i = 7;
|
|
break;
|
|
case 7:
|
|
i = 6;
|
|
break;
|
|
case 8:
|
|
i = 5;
|
|
break;
|
|
default:
|
|
i = 0;
|
|
break;
|
|
}
|
|
setAttribute("Orientation", Integer.toString(i));
|
|
}
|
|
|
|
public double getAltitude(double d) {
|
|
double attributeDouble = getAttributeDouble("GPSAltitude", -1.0d);
|
|
int i = -1;
|
|
int attributeInt = getAttributeInt("GPSAltitudeRef", -1);
|
|
if (attributeDouble < 0.0d || attributeInt < 0) {
|
|
return d;
|
|
}
|
|
if (attributeInt != 1) {
|
|
i = 1;
|
|
}
|
|
return attributeDouble * ((double) i);
|
|
}
|
|
|
|
@Nullable
|
|
public String getAttribute(@NonNull 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 i = exifAttribute.format;
|
|
if (i == 5 || i == 10) {
|
|
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))));
|
|
}
|
|
StringBuilder L = a.L("Invalid GPS Timestamp array. array=");
|
|
L.append(Arrays.toString(rationalArr));
|
|
Log.w("ExifInterface", L.toString());
|
|
return null;
|
|
}
|
|
StringBuilder L2 = a.L("GPS Timestamp format is not rational. format=");
|
|
L2.append(exifAttribute.format);
|
|
Log.w("ExifInterface", L2.toString());
|
|
return null;
|
|
}
|
|
try {
|
|
return Double.toString(exifAttribute.getDoubleValue(this.mExifByteOrder));
|
|
} catch (NumberFormatException unused) {
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Nullable
|
|
public byte[] getAttributeBytes(@NonNull 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(@NonNull String str, double d) {
|
|
Objects.requireNonNull(str, "tag shouldn't be null");
|
|
ExifAttribute exifAttribute = getExifAttribute(str);
|
|
if (exifAttribute == null) {
|
|
return d;
|
|
}
|
|
try {
|
|
return exifAttribute.getDoubleValue(this.mExifByteOrder);
|
|
} catch (NumberFormatException unused) {
|
|
return d;
|
|
}
|
|
}
|
|
|
|
public int getAttributeInt(@NonNull String str, int i) {
|
|
Objects.requireNonNull(str, "tag shouldn't be null");
|
|
ExifAttribute exifAttribute = getExifAttribute(str);
|
|
if (exifAttribute == null) {
|
|
return i;
|
|
}
|
|
try {
|
|
return exifAttribute.getIntValue(this.mExifByteOrder);
|
|
} catch (NumberFormatException unused) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public long[] getAttributeRange(@NonNull 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, (long) exifAttribute.bytes.length};
|
|
}
|
|
return null;
|
|
}
|
|
throw new IllegalStateException("The underlying file has been modified since being parsed");
|
|
}
|
|
|
|
@Nullable
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public Long getDateTime() {
|
|
return parseDateTime(getAttribute("DateTime"), getAttribute("SubSecTime"), getAttribute("OffsetTime"));
|
|
}
|
|
|
|
@Nullable
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public Long getDateTimeDigitized() {
|
|
return parseDateTime(getAttribute("DateTimeDigitized"), getAttribute("SubSecTimeDigitized"), getAttribute("OffsetTimeDigitized"));
|
|
}
|
|
|
|
@Nullable
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public Long getDateTimeOriginal() {
|
|
return parseDateTime(getAttribute("DateTimeOriginal"), getAttribute("SubSecTimeOriginal"), getAttribute("OffsetTimeOriginal"));
|
|
}
|
|
|
|
@Nullable
|
|
@SuppressLint({"AutoBoxing"})
|
|
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;
|
|
}
|
|
|
|
@Nullable
|
|
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) {
|
|
StringBuilder L = a.L("Latitude/longitude values are not parsable. ");
|
|
L.append(String.format("latValue=%s, latRef=%s, lngValue=%s, lngRef=%s", attribute, attribute2, attribute3, attribute4));
|
|
Log.w("ExifInterface", L.toString());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public byte[] getThumbnail() {
|
|
int i = this.mThumbnailCompression;
|
|
if (i == 6 || i == 7) {
|
|
return getThumbnailBytes();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Nullable
|
|
public Bitmap getThumbnailBitmap() {
|
|
if (!this.mHasThumbnail) {
|
|
return null;
|
|
}
|
|
if (this.mThumbnailBytes == null) {
|
|
this.mThumbnailBytes = getThumbnailBytes();
|
|
}
|
|
int i = this.mThumbnailCompression;
|
|
if (i == 6 || i == 7) {
|
|
return BitmapFactory.decodeByteArray(this.mThumbnailBytes, 0, this.mThumbnailLength);
|
|
}
|
|
if (i == 1) {
|
|
int length = this.mThumbnailBytes.length / 3;
|
|
int[] iArr = new int[length];
|
|
for (int i2 = 0; i2 < length; i2++) {
|
|
byte[] bArr = this.mThumbnailBytes;
|
|
int i3 = i2 * 3;
|
|
iArr[i2] = (bArr[i3] << 16) + 0 + (bArr[i3 + 1] << 8) + bArr[i3 + 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;
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:29:0x0051 A[SYNTHETIC, Splitter:B:29:0x0051] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:44:0x008c */
|
|
/* JADX WARNING: Removed duplicated region for block: B:59:0x00ab */
|
|
/* JADX WARNING: Removed duplicated region for block: B:65:0x00b6 */
|
|
@Nullable
|
|
public byte[] getThumbnailBytes() {
|
|
FileDescriptor fileDescriptor;
|
|
Throwable th;
|
|
InputStream inputStream;
|
|
Exception e;
|
|
InputStream inputStream2 = null;
|
|
if (!this.mHasThumbnail) {
|
|
return null;
|
|
}
|
|
byte[] bArr = this.mThumbnailBytes;
|
|
if (bArr != null) {
|
|
return bArr;
|
|
}
|
|
try {
|
|
inputStream = this.mAssetInputStream;
|
|
if (inputStream != null) {
|
|
try {
|
|
if (inputStream.markSupported()) {
|
|
inputStream.reset();
|
|
} else {
|
|
Log.d("ExifInterface", "Cannot read thumbnail from inputstream without mark/reset support");
|
|
closeQuietly(inputStream);
|
|
return null;
|
|
}
|
|
} catch (Exception e2) {
|
|
e = e2;
|
|
fileDescriptor = null;
|
|
try {
|
|
Log.d("ExifInterface", "Encountered exception while getting thumbnail", e);
|
|
closeQuietly(inputStream);
|
|
if (fileDescriptor != null) {
|
|
}
|
|
return null;
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
inputStream2 = inputStream;
|
|
closeQuietly(inputStream2);
|
|
if (fileDescriptor != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
fileDescriptor = null;
|
|
inputStream2 = inputStream;
|
|
closeQuietly(inputStream2);
|
|
if (fileDescriptor != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
} else if (this.mFilename != null) {
|
|
inputStream = new FileInputStream(this.mFilename);
|
|
} else {
|
|
FileDescriptor dup = Os.dup(this.mSeekableFileDescriptor);
|
|
try {
|
|
Os.lseek(dup, 0, OsConstants.SEEK_SET);
|
|
fileDescriptor = dup;
|
|
inputStream = new FileInputStream(dup);
|
|
if (inputStream == null) {
|
|
try {
|
|
if (inputStream.skip((long) (this.mThumbnailOffset + this.mOffsetToExifData)) == ((long) (this.mThumbnailOffset + this.mOffsetToExifData))) {
|
|
byte[] bArr2 = new byte[this.mThumbnailLength];
|
|
if (inputStream.read(bArr2) == this.mThumbnailLength) {
|
|
this.mThumbnailBytes = bArr2;
|
|
closeQuietly(inputStream);
|
|
if (fileDescriptor != null) {
|
|
closeFileDescriptor(fileDescriptor);
|
|
}
|
|
return bArr2;
|
|
}
|
|
throw new IOException("Corrupted image");
|
|
}
|
|
throw new IOException("Corrupted image");
|
|
} catch (Exception e3) {
|
|
e = e3;
|
|
Log.d("ExifInterface", "Encountered exception while getting thumbnail", e);
|
|
closeQuietly(inputStream);
|
|
if (fileDescriptor != null) {
|
|
}
|
|
return null;
|
|
}
|
|
} else {
|
|
throw new FileNotFoundException();
|
|
}
|
|
} catch (Exception e4) {
|
|
e = e4;
|
|
fileDescriptor = dup;
|
|
inputStream = null;
|
|
Log.d("ExifInterface", "Encountered exception while getting thumbnail", e);
|
|
closeQuietly(inputStream);
|
|
if (fileDescriptor != null) {
|
|
}
|
|
return null;
|
|
} catch (Throwable th4) {
|
|
th = th4;
|
|
fileDescriptor = dup;
|
|
closeQuietly(inputStream2);
|
|
if (fileDescriptor != null) {
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
fileDescriptor = null;
|
|
if (inputStream == null) {
|
|
}
|
|
} catch (Exception e5) {
|
|
inputStream = null;
|
|
e = e5;
|
|
fileDescriptor = null;
|
|
Log.d("ExifInterface", "Encountered exception while getting thumbnail", e);
|
|
closeQuietly(inputStream);
|
|
if (fileDescriptor != null) {
|
|
closeFileDescriptor(fileDescriptor);
|
|
}
|
|
return null;
|
|
} catch (Throwable th5) {
|
|
th = th5;
|
|
fileDescriptor = null;
|
|
closeQuietly(inputStream2);
|
|
if (fileDescriptor != null) {
|
|
closeFileDescriptor(fileDescriptor);
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public long[] getThumbnailRange() {
|
|
if (this.mModified) {
|
|
throw new IllegalStateException("The underlying file has been modified since being parsed");
|
|
} else if (!this.mHasThumbnail) {
|
|
return null;
|
|
} else {
|
|
if (!this.mHasThumbnailStrips || this.mAreThumbnailStripsConsecutive) {
|
|
return new long[]{(long) (this.mThumbnailOffset + this.mOffsetToExifData), (long) this.mThumbnailLength};
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public boolean hasAttribute(@NonNull 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) {
|
|
return false;
|
|
}
|
|
int i = this.mThumbnailCompression;
|
|
return i == 6 || i == 7;
|
|
}
|
|
|
|
public void resetOrientation() {
|
|
setAttribute("Orientation", Integer.toString(1));
|
|
}
|
|
|
|
public void rotate(int i) {
|
|
if (i % 90 == 0) {
|
|
int attributeInt = getAttributeInt("Orientation", 1);
|
|
List<Integer> list = ROTATION_ORDER;
|
|
int i2 = 0;
|
|
if (list.contains(Integer.valueOf(attributeInt))) {
|
|
int indexOf = ((i / 90) + list.indexOf(Integer.valueOf(attributeInt))) % 4;
|
|
if (indexOf < 0) {
|
|
i2 = 4;
|
|
}
|
|
i2 = list.get(indexOf + i2).intValue();
|
|
} else {
|
|
List<Integer> list2 = FLIPPED_ROTATION_ORDER;
|
|
if (list2.contains(Integer.valueOf(attributeInt))) {
|
|
int indexOf2 = ((i / 90) + list2.indexOf(Integer.valueOf(attributeInt))) % 4;
|
|
if (indexOf2 < 0) {
|
|
i2 = 4;
|
|
}
|
|
i2 = list2.get(indexOf2 + i2).intValue();
|
|
}
|
|
}
|
|
setAttribute("Orientation", Integer.toString(i2));
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("degree should be a multiple of 90");
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:48:0x00b2, code lost:
|
|
r8 = move-exception;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:49:0x00b3, code lost:
|
|
r9 = null;
|
|
r1 = r6;
|
|
r6 = r8;
|
|
r8 = null;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:50:0x00b8, code lost:
|
|
r7 = e;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:51:0x00b9, code lost:
|
|
r8 = null;
|
|
r9 = null;
|
|
r1 = r6;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:52:0x00bd, code lost:
|
|
r0 = th;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:53:0x00be, code lost:
|
|
r9 = null;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:62:0x00cf, code lost:
|
|
android.system.Os.lseek(r13.mSeekableFileDescriptor, 0, android.system.OsConstants.SEEK_SET);
|
|
r1 = new java.io.FileOutputStream(r13.mSeekableFileDescriptor);
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:63:0x00de, code lost:
|
|
r1 = new java.io.FileOutputStream(r13.mFilename);
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:85:0x0131, code lost:
|
|
r2.delete();
|
|
*/
|
|
/* JADX WARNING: Failed to process nested try/catch */
|
|
/* JADX WARNING: Removed duplicated region for block: B:52:0x00bd A[ExcHandler: all (th java.lang.Throwable), Splitter:B:19:0x0056] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:62:0x00cf A[Catch:{ Exception -> 0x00fa, all -> 0x00f7 }] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:63:0x00de A[Catch:{ Exception -> 0x00fa, all -> 0x00f7 }] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:85:0x0131 */
|
|
public void saveAttributes() throws IOException {
|
|
FileOutputStream fileOutputStream;
|
|
Throwable th;
|
|
Exception e;
|
|
FileInputStream fileInputStream;
|
|
BufferedOutputStream bufferedOutputStream;
|
|
Throwable th2;
|
|
BufferedInputStream bufferedInputStream;
|
|
BufferedOutputStream bufferedOutputStream2;
|
|
Exception exc;
|
|
Throwable th3;
|
|
FileInputStream fileInputStream2;
|
|
Exception e2;
|
|
FileOutputStream fileOutputStream2;
|
|
if (!isSupportedFormatForSavingAttributes()) {
|
|
throw new IOException("ExifInterface only supports saving attributes on JPEG, PNG, or WebP formats.");
|
|
} else if (this.mSeekableFileDescriptor == null && this.mFilename == null) {
|
|
throw new IOException("ExifInterface does not support saving attributes for the current input.");
|
|
} else {
|
|
this.mModified = true;
|
|
this.mThumbnailBytes = getThumbnail();
|
|
FileInputStream fileInputStream3 = null;
|
|
try {
|
|
File createTempFile = File.createTempFile("temp", "tmp");
|
|
if (this.mFilename != null) {
|
|
fileInputStream = new FileInputStream(this.mFilename);
|
|
} else {
|
|
Os.lseek(this.mSeekableFileDescriptor, 0, OsConstants.SEEK_SET);
|
|
fileInputStream = new FileInputStream(this.mSeekableFileDescriptor);
|
|
}
|
|
try {
|
|
fileOutputStream = new FileOutputStream(createTempFile);
|
|
try {
|
|
copy(fileInputStream, fileOutputStream);
|
|
closeQuietly(fileInputStream);
|
|
closeQuietly(fileOutputStream);
|
|
try {
|
|
FileInputStream fileInputStream4 = new FileInputStream(createTempFile);
|
|
if (this.mFilename != null) {
|
|
bufferedOutputStream2 = new FileOutputStream(this.mFilename);
|
|
} else {
|
|
Os.lseek(this.mSeekableFileDescriptor, 0, OsConstants.SEEK_SET);
|
|
bufferedOutputStream2 = new FileOutputStream(this.mSeekableFileDescriptor);
|
|
}
|
|
bufferedInputStream = new BufferedInputStream(fileInputStream4);
|
|
try {
|
|
bufferedOutputStream = new BufferedOutputStream(bufferedOutputStream2);
|
|
try {
|
|
int i = this.mMimeType;
|
|
if (i == 4) {
|
|
saveJpegAttributes(bufferedInputStream, bufferedOutputStream);
|
|
} else if (i == 13) {
|
|
savePngAttributes(bufferedInputStream, bufferedOutputStream);
|
|
} else if (i == 14) {
|
|
saveWebpAttributes(bufferedInputStream, bufferedOutputStream);
|
|
}
|
|
closeQuietly(bufferedInputStream);
|
|
closeQuietly(bufferedOutputStream);
|
|
createTempFile.delete();
|
|
this.mThumbnailBytes = null;
|
|
} catch (Exception e3) {
|
|
exc = e3;
|
|
fileInputStream3 = fileInputStream4;
|
|
try {
|
|
fileInputStream2 = new FileInputStream(createTempFile);
|
|
try {
|
|
if (this.mFilename == null) {
|
|
}
|
|
copy(fileInputStream2, fileOutputStream2);
|
|
} catch (Exception e4) {
|
|
e2 = e4;
|
|
try {
|
|
throw new IOException("Failed to save new file. Original file is stored in " + createTempFile.getAbsolutePath(), e2);
|
|
} catch (Throwable th4) {
|
|
th3 = th4;
|
|
fileInputStream3 = fileInputStream2;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(bufferedOutputStream2);
|
|
throw th3;
|
|
}
|
|
} catch (Throwable th5) {
|
|
th3 = th5;
|
|
fileInputStream3 = fileInputStream2;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(bufferedOutputStream2);
|
|
throw th3;
|
|
}
|
|
try {
|
|
closeQuietly(fileInputStream2);
|
|
closeQuietly(fileOutputStream2);
|
|
throw new IOException("Failed to save new file", exc);
|
|
} catch (Throwable th6) {
|
|
th2 = th6;
|
|
fileInputStream3 = bufferedInputStream;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(bufferedOutputStream);
|
|
if (0 == 0) {
|
|
}
|
|
throw th2;
|
|
}
|
|
} catch (Exception e5) {
|
|
fileInputStream2 = fileInputStream3;
|
|
e2 = e5;
|
|
throw new IOException("Failed to save new file. Original file is stored in " + createTempFile.getAbsolutePath(), e2);
|
|
} catch (Throwable th7) {
|
|
th3 = th7;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(bufferedOutputStream2);
|
|
throw th3;
|
|
}
|
|
}
|
|
} catch (Exception e6) {
|
|
bufferedOutputStream = null;
|
|
fileInputStream3 = fileInputStream4;
|
|
exc = e6;
|
|
fileInputStream2 = new FileInputStream(createTempFile);
|
|
if (this.mFilename == null) {
|
|
}
|
|
copy(fileInputStream2, fileOutputStream2);
|
|
closeQuietly(fileInputStream2);
|
|
closeQuietly(fileOutputStream2);
|
|
throw new IOException("Failed to save new file", exc);
|
|
} catch (Throwable th8) {
|
|
th2 = th8;
|
|
bufferedOutputStream = null;
|
|
fileInputStream3 = bufferedInputStream;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(bufferedOutputStream);
|
|
if (0 == 0) {
|
|
}
|
|
throw th2;
|
|
}
|
|
} catch (Exception e7) {
|
|
Exception e8 = e7;
|
|
bufferedInputStream = null;
|
|
bufferedOutputStream = null;
|
|
exc = e8;
|
|
bufferedOutputStream2 = bufferedOutputStream;
|
|
fileInputStream2 = new FileInputStream(createTempFile);
|
|
if (this.mFilename == null) {
|
|
}
|
|
copy(fileInputStream2, fileOutputStream2);
|
|
closeQuietly(fileInputStream2);
|
|
closeQuietly(fileOutputStream2);
|
|
throw new IOException("Failed to save new file", exc);
|
|
} catch (Throwable th9) {
|
|
}
|
|
} catch (Exception e9) {
|
|
e = e9;
|
|
fileInputStream3 = fileInputStream;
|
|
try {
|
|
throw new IOException("Failed to copy original file to temp file", e);
|
|
} catch (Throwable th10) {
|
|
th = th10;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(fileOutputStream);
|
|
throw th;
|
|
}
|
|
} catch (Throwable th11) {
|
|
th = th11;
|
|
fileInputStream3 = fileInputStream;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(fileOutputStream);
|
|
throw th;
|
|
}
|
|
} catch (Exception e10) {
|
|
e = e10;
|
|
fileOutputStream = null;
|
|
fileInputStream3 = fileInputStream;
|
|
throw new IOException("Failed to copy original file to temp file", e);
|
|
} catch (Throwable th12) {
|
|
th = th12;
|
|
fileOutputStream = null;
|
|
fileInputStream3 = fileInputStream;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(fileOutputStream);
|
|
throw th;
|
|
}
|
|
} catch (Exception e11) {
|
|
e = e11;
|
|
fileOutputStream = null;
|
|
throw new IOException("Failed to copy original file to temp file", e);
|
|
} catch (Throwable th13) {
|
|
th = th13;
|
|
fileOutputStream = null;
|
|
closeQuietly(fileInputStream3);
|
|
closeQuietly(fileOutputStream);
|
|
throw th;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setAltitude(double d) {
|
|
String str = d >= 0.0d ? "0" : "1";
|
|
setAttribute("GPSAltitude", new Rational(Math.abs(d)).toString());
|
|
setAttribute("GPSAltitudeRef", str);
|
|
}
|
|
|
|
public void setAttribute(@NonNull String str, @Nullable String str2) {
|
|
ExifTag exifTag;
|
|
int i;
|
|
String str3;
|
|
String str4 = str;
|
|
String str5 = str2;
|
|
Objects.requireNonNull(str4, "tag shouldn't be null");
|
|
if (("DateTime".equals(str4) || "DateTimeOriginal".equals(str4) || "DateTimeDigitized".equals(str4)) && str5 != null) {
|
|
boolean find = DATETIME_PRIMARY_FORMAT_PATTERN.matcher(str5).find();
|
|
boolean find2 = DATETIME_SECONDARY_FORMAT_PATTERN.matcher(str5).find();
|
|
if (str2.length() != 19 || (!find && !find2)) {
|
|
Log.w("ExifInterface", "Invalid value for " + str4 + " : " + str5);
|
|
return;
|
|
} else if (find2) {
|
|
str5 = str5.replaceAll("-", ":");
|
|
}
|
|
}
|
|
if ("ISOSpeedRatings".equals(str4)) {
|
|
if (DEBUG) {
|
|
Log.d("ExifInterface", "setAttribute: Replacing TAG_ISO_SPEED_RATINGS with TAG_PHOTOGRAPHIC_SENSITIVITY.");
|
|
}
|
|
str4 = "PhotographicSensitivity";
|
|
}
|
|
int i2 = 2;
|
|
int i3 = 1;
|
|
if (str5 != null && sTagSetForCompatibility.contains(str4)) {
|
|
if (str4.equals("GPSTimeStamp")) {
|
|
Matcher matcher = GPS_TIMESTAMP_PATTERN.matcher(str5);
|
|
if (!matcher.find()) {
|
|
Log.w("ExifInterface", "Invalid value for " + str4 + " : " + str5);
|
|
return;
|
|
}
|
|
str5 = Integer.parseInt(matcher.group(1)) + "/1," + Integer.parseInt(matcher.group(2)) + "/1," + Integer.parseInt(matcher.group(3)) + "/1";
|
|
} else {
|
|
try {
|
|
str5 = new Rational(Double.parseDouble(str5)).toString();
|
|
} catch (NumberFormatException unused) {
|
|
Log.w("ExifInterface", "Invalid value for " + str4 + " : " + str5);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
char c2 = 0;
|
|
int i4 = 0;
|
|
while (i4 < EXIF_TAGS.length) {
|
|
if ((i4 != 4 || this.mHasThumbnail) && (exifTag = sExifTagMapsForWriting[i4].get(str4)) != null) {
|
|
if (str5 == null) {
|
|
this.mAttributes[i4].remove(str4);
|
|
} else {
|
|
Pair<Integer, Integer> guessDataFormat = guessDataFormat(str5);
|
|
int i5 = -1;
|
|
if (exifTag.primaryFormat == ((Integer) guessDataFormat.first).intValue() || exifTag.primaryFormat == ((Integer) guessDataFormat.second).intValue()) {
|
|
i = exifTag.primaryFormat;
|
|
} else {
|
|
int i6 = exifTag.secondaryFormat;
|
|
if (i6 == -1 || !(i6 == ((Integer) guessDataFormat.first).intValue() || exifTag.secondaryFormat == ((Integer) guessDataFormat.second).intValue())) {
|
|
int i7 = exifTag.primaryFormat;
|
|
if (i7 == i3 || i7 == 7 || i7 == i2) {
|
|
i = i7;
|
|
} else if (DEBUG) {
|
|
StringBuilder Q = a.Q("Given tag (", str4, ") value didn't match with one of expected formats: ");
|
|
String[] strArr = IFD_FORMAT_NAMES;
|
|
Q.append(strArr[exifTag.primaryFormat]);
|
|
String str6 = "";
|
|
if (exifTag.secondaryFormat == -1) {
|
|
str3 = str6;
|
|
} else {
|
|
StringBuilder L = a.L(", ");
|
|
L.append(strArr[exifTag.secondaryFormat]);
|
|
str3 = L.toString();
|
|
}
|
|
Q.append(str3);
|
|
Q.append(" (guess: ");
|
|
Q.append(strArr[((Integer) guessDataFormat.first).intValue()]);
|
|
if (((Integer) guessDataFormat.second).intValue() != -1) {
|
|
StringBuilder L2 = a.L(", ");
|
|
L2.append(strArr[((Integer) guessDataFormat.second).intValue()]);
|
|
str6 = L2.toString();
|
|
}
|
|
Q.append(str6);
|
|
Q.append(")");
|
|
Log.d("ExifInterface", Q.toString());
|
|
}
|
|
} else {
|
|
i = exifTag.secondaryFormat;
|
|
}
|
|
}
|
|
switch (i) {
|
|
case 1:
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createByte(str5));
|
|
continue;
|
|
case 2:
|
|
case 7:
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createString(str5));
|
|
continue;
|
|
case 3:
|
|
String[] split = str5.split(",", -1);
|
|
int[] iArr = new int[split.length];
|
|
for (int i8 = 0; i8 < split.length; i8++) {
|
|
iArr[i8] = Integer.parseInt(split[i8]);
|
|
}
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createUShort(iArr, this.mExifByteOrder));
|
|
continue;
|
|
case 4:
|
|
String[] split2 = str5.split(",", -1);
|
|
long[] jArr = new long[split2.length];
|
|
for (int i9 = 0; i9 < split2.length; i9++) {
|
|
jArr[i9] = Long.parseLong(split2[i9]);
|
|
}
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createULong(jArr, this.mExifByteOrder));
|
|
continue;
|
|
case 5:
|
|
String[] split3 = str5.split(",", -1);
|
|
Rational[] rationalArr = new Rational[split3.length];
|
|
int i10 = 0;
|
|
while (i10 < split3.length) {
|
|
String[] split4 = split3[i10].split("/", i5);
|
|
rationalArr[i10] = new Rational((long) Double.parseDouble(split4[0]), (long) Double.parseDouble(split4[1]));
|
|
i10++;
|
|
i5 = -1;
|
|
}
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createURational(rationalArr, this.mExifByteOrder));
|
|
continue;
|
|
case 6:
|
|
case 8:
|
|
case 11:
|
|
default:
|
|
if (DEBUG) {
|
|
a.d0("Data format isn't one of expected formats: ", i, "ExifInterface");
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
case 9:
|
|
String[] split5 = str5.split(",", -1);
|
|
int[] iArr2 = new int[split5.length];
|
|
for (int i11 = 0; i11 < split5.length; i11++) {
|
|
iArr2[i11] = Integer.parseInt(split5[i11]);
|
|
}
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createSLong(iArr2, this.mExifByteOrder));
|
|
continue;
|
|
case 10:
|
|
String[] split6 = str5.split(",", -1);
|
|
Rational[] rationalArr2 = new Rational[split6.length];
|
|
int i12 = 0;
|
|
while (i12 < split6.length) {
|
|
String[] split7 = split6[i12].split("/", -1);
|
|
rationalArr2[i12] = new Rational((long) Double.parseDouble(split7[c2]), (long) Double.parseDouble(split7[i3]));
|
|
i12++;
|
|
c2 = 0;
|
|
i3 = 1;
|
|
split6 = split6;
|
|
}
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createSRational(rationalArr2, this.mExifByteOrder));
|
|
continue;
|
|
case 12:
|
|
String[] split8 = str5.split(",", -1);
|
|
double[] dArr = new double[split8.length];
|
|
for (int i13 = 0; i13 < split8.length; i13++) {
|
|
dArr[i13] = Double.parseDouble(split8[i13]);
|
|
}
|
|
this.mAttributes[i4].put(str4, ExifAttribute.createDouble(dArr, this.mExifByteOrder));
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
i4++;
|
|
i2 = 2;
|
|
c2 = 0;
|
|
i3 = 1;
|
|
}
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public void setDateTime(@NonNull Long l) {
|
|
setAttribute("DateTime", sFormatterPrimary.format(new Date(l.longValue())));
|
|
setAttribute("SubSecTime", Long.toString(l.longValue() % 1000));
|
|
}
|
|
|
|
public void setGpsInfo(Location location) {
|
|
if (location != null) {
|
|
setAttribute("GPSProcessingMethod", location.getProvider());
|
|
setLatLong(location.getLatitude(), location.getLongitude());
|
|
setAltitude(location.getAltitude());
|
|
setAttribute("GPSSpeedRef", "K");
|
|
setAttribute("GPSSpeed", new Rational((double) ((location.getSpeed() * ((float) TimeUnit.HOURS.toSeconds(1))) / 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 d, double d2) {
|
|
if (d < -90.0d || d > 90.0d || Double.isNaN(d)) {
|
|
throw new IllegalArgumentException("Latitude value " + d + " is not valid.");
|
|
} else if (d2 < -180.0d || d2 > 180.0d || Double.isNaN(d2)) {
|
|
throw new IllegalArgumentException("Longitude value " + d2 + " is not valid.");
|
|
} else {
|
|
setAttribute("GPSLatitudeRef", d >= 0.0d ? "N" : "S");
|
|
setAttribute("GPSLatitude", convertDecimalDegree(Math.abs(d)));
|
|
setAttribute("GPSLongitudeRef", d2 >= 0.0d ? "E" : "W");
|
|
setAttribute("GPSLongitude", convertDecimalDegree(Math.abs(d2)));
|
|
}
|
|
}
|
|
}
|