public void testRead() throws ExifInvalidFormatException, IOException {
   ExifReader reader = new ExifReader();
   ExifData exifData = reader.read(mImageInputStream);
   checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_0), mIfd0Value);
   checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_1), mIfd1Value);
   checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_EXIF), mExifIfdValue);
   checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_INTEROPERABILITY), mInteroperabilityIfdValue);
   checkThumbnail(exifData);
 }
  private void checkThumbnail(ExifData exifData) {
    IfdData ifd1 = exifData.getIfdData(IfdId.TYPE_IFD_1);
    if (ifd1 != null) {
      if (ifd1.getTag(ExifTag.TAG_COMPRESSION).getUnsignedShort(0) == ExifTag.Compression.JPEG) {
        assertTrue(exifData.hasCompressedThumbnail());
        byte[] thumbnail = exifData.getCompressedThumbnail();
        assertTrue(BitmapFactory.decodeByteArray(thumbnail, 0, thumbnail.length) != null);
      } else {
        // Try to check the strip count with the formula provided by EXIF spec.
        int planarType = ExifTag.PlanarConfiguration.CHUNKY;
        ExifTag planarTag = ifd1.getTag(ExifTag.TAG_PLANAR_CONFIGURATION);
        if (planarTag != null) {
          planarType = planarTag.getUnsignedShort(0);
        }

        ExifTag heightTag = ifd1.getTag(ExifTag.TAG_IMAGE_LENGTH);
        ExifTag rowPerStripTag = ifd1.getTag(ExifTag.TAG_ROWS_PER_STRIP);

        int imageLength = getUnsignedIntOrShort(heightTag);
        int rowsPerStrip = getUnsignedIntOrShort(rowPerStripTag);
        int stripCount = ifd1.getTag(ExifTag.TAG_STRIP_OFFSETS).getComponentCount();

        if (planarType == ExifTag.PlanarConfiguration.CHUNKY) {
          assertTrue(stripCount == (imageLength + rowsPerStrip - 1) / rowsPerStrip);
        } else {
          ExifTag samplePerPixelTag = ifd1.getTag(ExifTag.TAG_SAMPLES_PER_PIXEL);
          int samplePerPixel = samplePerPixelTag.getUnsignedShort(0);
          assertTrue(
              stripCount == (imageLength + rowsPerStrip - 1) / rowsPerStrip * samplePerPixel);
        }

        for (int i = 0; i < stripCount; i++) {
          ExifTag byteCountTag = ifd1.getTag(ExifTag.TAG_STRIP_BYTE_COUNTS);
          if (byteCountTag.getDataType() == ExifTag.TYPE_UNSIGNED_SHORT) {
            assertEquals(byteCountTag.getUnsignedShort(i), exifData.getStrip(i).length);
          } else {
            assertEquals(byteCountTag.getUnsignedLong(i), exifData.getStrip(i).length);
          }
        }
      }
    }
  }
  /**
   * Parses the inputStream and and returns the EXIF data in an {@link ExifData}.
   *
   * @throws ExifInvalidFormatException
   * @throws IOException
   */
  protected ExifData read(InputStream inputStream) throws ExifInvalidFormatException, IOException {
    ExifParser parser = ExifParser.parse(inputStream, mInterface);
    ExifData exifData = new ExifData(parser.getByteOrder());
    ExifTag tag = null;

    int event = parser.next();
    while (event != ExifParser.EVENT_END) {
      switch (event) {
        case ExifParser.EVENT_START_OF_IFD:
          exifData.addIfdData(new IfdData(parser.getCurrentIfd()));
          break;
        case ExifParser.EVENT_NEW_TAG:
          tag = parser.getTag();
          if (!tag.hasValue()) {
            parser.registerForTagValue(tag);
          } else {
            exifData.getIfdData(tag.getIfd()).setTag(tag);
          }
          break;
        case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG:
          tag = parser.getTag();
          if (tag.getDataType() == ExifTag.TYPE_UNDEFINED) {
            parser.readFullTagValue(tag);
          }
          exifData.getIfdData(tag.getIfd()).setTag(tag);
          break;
        case ExifParser.EVENT_COMPRESSED_IMAGE:
          byte buf[] = new byte[parser.getCompressedImageSize()];
          if (buf.length == parser.read(buf)) {
            exifData.setCompressedThumbnail(buf);
          } else {
            Log.w(TAG, "Failed to read the compressed thumbnail");
          }
          break;
        case ExifParser.EVENT_UNCOMPRESSED_STRIP:
          buf = new byte[parser.getStripSize()];
          if (buf.length == parser.read(buf)) {
            exifData.setStripBytes(parser.getStripIndex(), buf);
          } else {
            Log.w(TAG, "Failed to read the strip bytes");
          }
          break;
      }
      event = parser.next();
    }
    return exifData;
  }
Exemplo n.º 4
0
  /**
   * Parses the inputStream and and returns the EXIF data in an {@link ExifData}.
   *
   * @throws ExifInvalidFormatException
   * @throws java.io.IOException
   */
  protected ExifData read(InputStream inputStream, int options)
      throws ExifInvalidFormatException, IOException {
    ExifParser parser = ExifParser.parse(inputStream, options, mInterface);
    ExifData exifData = new ExifData(parser.getByteOrder());
    exifData.setSections(parser.getSections());
    exifData.mUncompressedDataPosition = parser.getUncompressedDataPosition();

    exifData.setQualityGuess(parser.getQualityGuess());
    exifData.setJpegProcess(parser.getJpegProcess());

    final int w = parser.getImageWidth();
    final int h = parser.getImageLength();

    if (w > 0 && h > 0) {
      exifData.setImageSize(w, h);
    }

    ExifTag tag;

    int event = parser.next();
    while (event != ExifParser.EVENT_END) {
      switch (event) {
        case ExifParser.EVENT_START_OF_IFD:
          exifData.addIfdData(new IfdData(parser.getCurrentIfd()));
          break;
        case ExifParser.EVENT_NEW_TAG:
          tag = parser.getTag();

          if (!tag.hasValue()) {
            parser.registerForTagValue(tag);
          } else {
            // Log.v(TAG, "parsing id " + tag.getTagId() + " = " + tag);
            if (parser.isDefinedTag(tag.getIfd(), tag.getTagId())) {
              exifData.getIfdData(tag.getIfd()).setTag(tag);
            } else {
              Log.w(TAG, "skip tag because not registered in the tag table:" + tag);
            }
          }
          break;
        case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG:
          tag = parser.getTag();
          if (tag.getDataType() == ExifTag.TYPE_UNDEFINED) {
            parser.readFullTagValue(tag);
          }
          exifData.getIfdData(tag.getIfd()).setTag(tag);
          break;
        case ExifParser.EVENT_COMPRESSED_IMAGE:
          byte buf[] = new byte[parser.getCompressedImageSize()];
          if (buf.length == parser.read(buf)) {
            exifData.setCompressedThumbnail(buf);
          } else {
            Log.w(TAG, "Failed to read the compressed thumbnail");
          }
          break;
        case ExifParser.EVENT_UNCOMPRESSED_STRIP:
          buf = new byte[parser.getStripSize()];
          if (buf.length == parser.read(buf)) {
            exifData.setStripBytes(parser.getStripIndex(), buf);
          } else {
            Log.w(TAG, "Failed to read the strip bytes");
          }
          break;
      }
      event = parser.next();
    }
    return exifData;
  }