To start build go to tiffbitmapfactory folder and run
``` Gradle ndk-build NDK_PROJECT_PATH=src/main ``` ### Usage #### Opening tiff file Starting Android-Q we can't open any file from sdcar, just files from scoped storage of application If you need open file somewhere in sdcardm you should use [Storage Access Framework](https://android-doc.github.io/guide/topics/providers/document-provider.html) Request document chooser(Android system don't know image/tiff type so using */*): ```Java Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT); intent.addCategory(Intent.CATEGORY_OPENABLE); intent.setType("*/*"); startActivityForResult(intent, requestCode); ``` Getting answer from chooser: ```Java @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if (requestCode == REQUEST_CODE) { try { ParcelFileDescriptor parcelFileDescriptor = getContentResolver().openFileDescriptor(data.getData(), "r"); Bitmap bmp = TiffBitmapFactory.decodeFileDescriptor(parcelFileDescriptor.getFd()); } catch (FileNotFoundException e) { e.printStackTrace(); } } } ``` Same method used also for TiffSaver and TiffConverter classes For pre Q devices and for scoped storage you can use old api: ```Java File file = new File("/sdcard/image.tif"); //Read data about image to Options object TiffBitmapFactory.Options options = new TiffBitmapFactory.Options(); options.inJustDecodeBounds = true; TiffBitmapFactory.decodeFile(file, options); int dirCount = options.outDirectoryCount; //Read and process all images in file for (int i = 0; i < dirCount; i++) { options.inDirectoryNumber = i; TiffBitmapFactory.decodeFile(file, options); int curDir = options.outCurDirectoryNumber; int width = options.outWidth; int height = options.outHeight; //Change sample size if width or height bigger than required width or height int inSampleSize = 1; if (height > reqHeight || width > reqWidth) { final int halfHeight = height / 2; final int halfWidth = width / 2; // Calculate the largest inSampleSize value that is a power of 2 and keeps both // height and width larger than the requested height and width. while ((halfHeight / inSampleSize) > reqHeight && (halfWidth / inSampleSize) > reqWidth) { inSampleSize *= 2; } } options.inJustDecodeBounds = false; options.inSampleSize = inSampleSize; // Specify the amount of memory available for the final bitmap and temporary storage. options.inAvailableMemory = 20000000; // bytes Bitmap bmp = TiffBitmapFactory.decodeFile(file, options); processBitmap(bmp); } ``` ##### Memory processing While decoding images library use native memory mechanism, so it could use all memory available for operating system. This could produce crash of your app and close other applications which are running on the device. Also in some cases it could crash operating system. Also in case of using more than one thread for decoding images every thread could try to use all device memory. For avoiding of memory errors, library now has option called inAvailableMemory. Default value for this variable is 8000x8000x4 that equal to 244Mb. -1 means that decoder could use all available memory, but also it could be root of application crashes. Each separate thread that decoding tiff image will estimate how many memory it will use in decoding process. If estimate memory is less than available memory, decoder will decode image. Otherwise decoder will throw error or just return NULL(see inThrowException option). #### Stop decoding that runs in separate thread ```Java //Running decoding of big image in separate thread Thread thread = new Thread(new Runnable() { @Override public void run() { Bitmap bitmap = TiffBitmapFactory.decodePath("/sdcard/big_tiff_image.tif"); } }); thread.start(); //To stop thread just interrupt thread as usual thread.interrupt(); ``` #### Saving tiff file ```Java //Open some image Bitmap bitmap = BitmapFactory.decodeFile("sdcard/image.png"); //Create options for saving TiffSaver.SaveOptions options = new TiffSaver.SaveOptions(); //By default compression mode is none options.compressionScheme = CompressionScheme.COMPRESSION_LZW; //By default orientation is top left options.orientation = Orientation.ORIENTATION_LEFTTOP; //Add author tag to output file options.author = "beyka"; //Add copyright tag to output file options.copyright = "Some copyright"; //Save image as tif. If image saved succesfull true will be returned boolean saved = TiffSaver.saveBitmap("/sdcard/out.tif", bitmap, options); ``` #### Adding page to existing tiff file ```Java //Open some image Bitmap bitmap = BitmapFactory.decodeFile("sdcard/image.png"); //Create options for saving TiffSaver.SaveOptions options = new TiffSaver.SaveOptions(); //By default compression mode is none options.compressionScheme = CompressionScheme.COMPRESSION_LZW; //By default orientation is top left options.orientation = Orientation.ORIENTATION_LEFTTOP; //Add author tag to output file options.author = "beyka"; //Add copyright tag to output file options.copyright = "Some copyright"; //Add new directory to existing file or create new file. If image saved succesfull true will be returned boolean saved = TiffSaver.appendBitmap("/sdcard/out.tif", bitmap, options); ``` Every new page will be added as new directory to the end of file. If you trying to append directory to non-exisiting file - new file will be created #### Converting to tiff There is possibility for dirrect convert from some formats to TIFF. This method uses as less memory as possible. Use this method if you want create TIFF form realy big image file. ```Java TiffConverter.ConverterOptions options = new TiffConverter.ConverterOptions(); options.throwExceptions = false; //Set to true if you want use java exception mechanism; options.availableMemory = 128 * 1024 * 1024; //Available 128Mb for work; options.compressionScheme = CompressionScheme.LZW; //compression scheme for tiff options.appendTiff = false;//If set to true - will be created one more tiff directory, otherwise file will be overwritten TiffConverter.convertToTiff("/sdcard/some_image.jpg", "/sdcard/out.tif", options, progressListener); ``` If you need convert tiff to some other format: ```Java TiffConverter.ConverterOptions options = new TiffConverter.ConverterOptions(); options.throwExceptions = false; //Set to true if you want use java exception mechanism; options.availableMemory = 128 * 1024 * 1024; //Available 128Mb for work; options.readTiffDirectory = 1; //Number of tiff directory to convert; //Convert to JPEG TiffConverter.convertTiffJpg("/sdcard/in.tif", "/sdcard/out.jpg", options, progressListener); //Convert to PNG TiffConverter.convertTiffPng("/sdcard/in.tif", "/sdcard/out.png", options, progressListener); //Convert to BMP TiffConverter.convertTiffBmp("/sdcard/in.tif", "/sdcard/out.bmp", options, progressListener); ``` For now library support JPEG, PNG and BMP formats for converting. #### Progress listener All operations(read, create, convert) have support for progress reporting. ```Java IProgressListener progressListener = new IProgressListener() { @Override public void reportProgress(long processedPixels, long totalPixels) { Log.v("Progress reporter", String.format("Processed %d pixels from %d", processedPixels, totalPixels); } }; ``` ### Proguard If you use proguard add this to you config file: ```Gradle -keep class org.beyka.tiffbitmapfactory.**{ *; } ``` ### This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Special thanks to [dennis508](https://github.com/dennis508) for providing of incremental reading of TIFF file ### Applications that use library: * [B Tiff Viewer](https://play.google.com/store/apps/details?id=com.beyka.btiffviewer) * Image Converter [[GitHub](https://github.com/vbresan/Image_Converter)] [[Google Play](https://play.google.com/store/apps/details?id=biz.binarysolutions.imageconverter.ggl)] ================================================ FILE: build.gradle ================================================ plugins { id "com.android.library" } android { compileSdkVersion 30 buildToolsVersion '30.0.3' def softwareName defaultConfig { minSdkVersion 16 targetSdkVersion 30 versionCode 987 versionName "0.9.9.0" softwareName = "\"" + project.name + "-" + versionName + "\"" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' buildConfigField("String", "softwarename", softwareName) } debug { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' buildConfigField("String", "softwarename", softwareName) } } ndkVersion "21.3.6528147" sourceSets.main { jni.srcDirs = [] jniLibs.srcDir 'src/main/libs' } } android { lintOptions { abortOnError false } } dependencies { } ext { PUBLISH_GROUP_ID = 'io.github.beyka' PUBLISH_VERSION = '0.9.9.0' PUBLISH_ARTIFACT_ID = 'Android-TiffBitmapFactory' } apply from: "${rootProject.projectDir}/publish-module.gradle" ================================================ FILE: license.txt ================================================ The MIT License (MIT) Copyright © «2018» «Oleksii Bei aka Beyka» Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: proguard-rules.pro ================================================ # Add project specific ProGuard rules here. # By default, the flags in this file are appended to flags specified # in /home/alexeyba/android-sdk-linux/tools/proguard/proguard-android.txt # You can edit the include path and order by changing the proguardFiles # directive in build.gradle. # # For more details, see # http://developer.android.com/guide/developing/tools/proguard.html # Add any project specific keep options here: # If your project uses WebView with JS, uncomment the following # and specify the fully qualified class name to the JavaScript interface # class: #-keepclassmembers class fqcn.of.javascript.interface.for.webview { # public *; #} ================================================ FILE: src/androidTest/java/org/beyka/tiffbitmapfactory/ApplicationTest.java ================================================ package org.beyka.tiffbitmapfactory; import android.app.Application; import android.test.ApplicationTestCase; /** * Testing Fundamentals */ public class ApplicationTest extends ApplicationTestCaseThe specification considers this a baseline tag, but does add that support for orientations other than 1 is not a Baseline TIFF requirement.
* So for almost all cases this variable may be false. *Default value is false
*/ public boolean inUseOrientationTag; /** * If set to true, decoder will throw exceptions if some errors appeared while decoding. * Otherwise decoder will just return null. * Default value is false */ public boolean inThrowException; /** * If set to true, the decoder will swap red and blue colors. *Note: If you use this option then your image has wrong encoding
*Default value is false
*/ public boolean inSwapRedBlueColors; /** * If set to true, the decoder will return null (no bitmap), but * the out... fields will still be set, allowing the caller to query * the bitmap without having to allocate the memory for its pixels. */ public boolean inJustDecodeBounds; /** * If set to a value > 1, requests the decoder to subsample the original * image, returning a smaller image to save memory. The sample size is * the number of pixels in either dimension that correspond to a single * pixel in the decoded bitmap. For example, inSampleSize == 4 returns * an image that is 1/4 the width/height of the original, and 1/16 the * number of pixels. Any value <= 1 is treated the same as 1. Note: the * decoder uses a final value based on powers of 2, any other value will * be rounded down to the nearest power of 2. */ public int inSampleSize; /** * Set directory to extract from image. Default value is 0. * To get number of directories in file see {@link #outDirectoryCount} */ public int inDirectoryNumber; /** * Number of bytes that may be allocated during the Tiff file operations. *-1 means memory is unlimited.
*Default value is 244Mb
*/ public long inAvailableMemory; /** * If this is non-null, the decoder will try to decode into this * internal configuration. If it is null, or the request cannot be met, * the decoder will use {@link ImageConfig#ARGB_8888} configuration. * *Numeration starts with 0
* *Image are loaded with the {@link ImageConfig#ARGB_8888} config by * default.
* *In current version supported are {@link ImageConfig#ARGB_8888}, {@link ImageConfig#ALPHA_8} and {@link ImageConfig#RGB_565}
*/ public ImageConfig inPreferredConfig = ImageConfig.ARGB_8888; /** * If this field is non-null - Decoder will decode and return only area specified in {@link DecodeArea} object * For decoding not full bitmap, but only part of it - create new {@link DecodeArea} object and specify: *{@link DecodeArea#x x}, {@link DecodeArea#y y} - left top corner of decoding area
*{@link DecodeArea#width width} - width of decoding area
*{@link DecodeArea#height height} - height of decoding area
*/ public DecodeArea inDecodeArea; /** * The resulting width of the bitmap. If {@link #inJustDecodeBounds} is * set to false, this will be width of the output bitmap after any * scaling is applied. If true, it will be the width of the input image * without any accounting for scaling. * *outWidth will be set to -1 if there is an error trying to decode.
*/ public int outWidth; /** * The resulting height of the bitmap. If {@link #inJustDecodeBounds} is * set to false, this will be height of the output bitmap after any * scaling is applied. If true, it will be the height of the input image * without any accounting for scaling. * *outHeight will be set to -1 if there is an error trying to decode.
*/ public int outHeight; /** * The number of current directory. *curDirectoryNumber will be set to -1 if there is an error trying to decode.
*/ public int outCurDirectoryNumber; /** * The count of directory in image file. *outDirectoryCount will be set to -1 if there is an error trying to decode.
*/ public int outDirectoryCount; /** * This parameter returns orientation of decoded image *For storing orientation uses {@link org.beyka.tiffbitmapfactory.Orientation ImageOrientation} enum
*If image wasn't decoded successful this parameter will be equal to {@link Orientation#UNAVAILABLE}
*This parameter is link to TIFFTAG_ORIENTATION tag
*/ public Orientation outImageOrientation; /** * This parameter returns compression scheme of decoded image *For storing compression mode uses {@link CompressionScheme CompressionScheme} enum
*This parameter is link to TIFFTAG_COMPRESSION tag
*/ public CompressionScheme outCompressionScheme; /** * How the components of each pixel are stored. *The specification defines these values:
*This parameter is link to TIFFTAG_PLANARCONFIG tag
*/ public PlanarConfig outPlanarConfig; /** * The number of components per pixel. *SamplesPerPixel is usually 1 for bilevel, grayscale, and palette-color images. SamplesPerPixel is usually 3 for RGB images. If this value is higher, ExtraSamples should give an indication of the meaning of the additional channels.
*/ public int outSamplePerPixel; /** * Number of bits per component. */ public int outBitsPerSample; /** * The number of pixels per {@link org.beyka.tiffbitmapfactory.TiffBitmapFactory.Options#outResolutionUnit} in the ImageWidth direction. */ public float outXResolution; /** * The number of pixels per {@link org.beyka.tiffbitmapfactory.TiffBitmapFactory.Options#outResolutionUnit} in the ImageHeight direction. */ public float outYResolution; /** * The unit of measurement for XResolution and YResolution. *The specification defines these values:
*This parameter is link to TIFFTAG_RESOLUTIONUNIT tag
*/ public ResolutionUnit outResolutionUnit; /** * The tile width in pixels. This is the number of columns in each tile. */ public int outTileWidth; /** * The tile height in pixels. This is the number of rows in each tile. */ public int outTileHeight; /** * The number of rows per strip. *RowsPerStrip and ImageLength together tell us the number of strips in the entire image.
*/ public int outRowPerStrip; /** * Size for a strip of data in bytes. */ public int outStripSize; /** * Number of strips in the image. */ public int outNumberOfStrips; /** * The color space of the image data. *This parameter is link to TIFFTAG_PHOTOMETRIC tag
*/ public Photometric outPhotometric; /** * The logical order of bits within a byte. *The specification defines these values:
*This parameter is link to TIFFTAG_PLANARCONFIG tag
*/ public FillOrder outFillOrder; /** * Author of file. *This parameter is link to TIFFTAG_ARTIST tag
*/ public String outAuthor = ""; /** * Copyright of file *This parameter is link to TIFFTAG_COPYRIGHT tag
*/ public String outCopyright = ""; /** * A string that describes the subject of the image. *This parameter is link to TIFFTAG_IMAGEDESCRIPTION tag
*/ public String outImageDescription = ""; /** * Name and version number of the software package(s) used to create the image. *This parameter is link to TIFFTAG_SOFTWARE tag
*/ public String outSoftware = ""; /** * Date and time of image creation. The format is: "YYYY:MM:DD HH:MM:SS", with hours like those on a 24-hour clock. *This parameter is link to TIFFTAG_DATETIME tag
*/ public String outDatetime = ""; /** * The computer and/or operating system in use at the time of image creation. *This parameter is link to TIFFTAG_HOSTCOMPUTER tag
*/ public String outHostComputer = ""; } } ================================================ FILE: src/main/java/org/beyka/tiffbitmapfactory/TiffConverter.java ================================================ package org.beyka.tiffbitmapfactory; import org.beyka.tiffbitmapfactory.exceptions.CantOpenFileException; import org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException; import org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException; import java.io.File; /** * Created by beyka on 5/9/17. */ public class TiffConverter { static { System.loadLibrary("tiff"); System.loadLibrary("tiffconverter"); } /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertToTiff(int, int, ConverterOptions, IProgressListener)}. * * Convert any of supported formats from {@link ImageFormat} to tiff * @param inFile path to income tiff file * @param outFile path to outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * * @return true if convert process have been successful */ public static boolean convertToTiff(File inFile, File outFile, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException { return convertToTiff(inFile.getAbsolutePath(), outFile.getAbsolutePath(), options, listener); } /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertToTiff(int, int, ConverterOptions, IProgressListener)}. * * Convert any of supported formats from {@link ImageFormat} to tiff * @param inPath path to income tiff file * @param outPath path to outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * * @return true if convert process have been successful */ public static boolean convertToTiff(String inPath, String outPath, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException { switch (getImageType(inPath)) { case JPEG: return convertJpgTiff(inPath, outPath, options, listener); case PNG: return convertPngTiff(inPath, outPath, options, listener); case BMP: return convertBmpTiff(inPath, outPath, options, listener); case TIFF: // TODO: 9/19/17 make convert tiff to tiff method break; } return false; } /** * Convert any of supported formats from {@link ImageFormat} to tiff * This method don't close file descriptor * @param inFd file descriptor that represent income file * @param outFd file descriptor that represent outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * * @return true if convert process have been successful */ public static boolean convertToTiff(int inFd, int outFd, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException { switch (getImageTypeFd(inFd)) { case JPEG: return convertJpgTiffFd(inFd, outFd, options, listener); case PNG: return convertPngTiffFd(inFd, outFd, options, listener); case BMP: return convertBmpTiffFd(inFd, outFd, options, listener); case TIFF: // TODO: 9/19/17 make convert tiff to tiff method break; } return false; } /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertTiffPngFd(int, int, ConverterOptions, IProgressListener)}. * * Convert tiff to png file. Uses direct data read method, that decrease memory usage * @param tiff path to income tiff file * @param png path to outcome png file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertTiffPng(String tiff, String png, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * Convert tiff to png file. Uses direct data read method, that decrease memory usage * @param tiff file descriptor that represent income tiff file * @param png file descriptor that represent outcome png file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertTiffPngFd(int tiff, int png, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertPngTiffFd(int, int, ConverterOptions, IProgressListener)}. * * Convert png to tiff file. Uses direct data read method, that decrease memory usage. * @param png path to income png file * @param tiff path to outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertPngTiff(String png, String tiff, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * Convert png to tiff file. Uses direct data read method, that decrease memory usage. * This method don't close file descriptor * @param png file descriptor that represent income png file * @param tiff file descriptor that represent outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertPngTiffFd(int png, int tiff, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertTiffJpgFd(int, int, ConverterOptions, IProgressListener)}. * * Convert tiff to jpeg file. Uses direct data read method, that decrease memory usage * @param tiff path to income tiff file * @param jpg path to outcome jpeg file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertTiffJpg(String tiff, String jpg, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * Convert tiff to jpg file. Uses direct data read method, that decrease memory usage * @param tiff file descriptor that represent income tiff file * @param jpg file descriptor that represent outcome jpg file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertTiffJpgFd(int tiff, int jpg, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertJpgTiffFd(int, int, ConverterOptions, IProgressListener)}. * * Convert jpeg to tiff file. Uses direct data read method, that decrease memory usage. * @param jpg path to income jpeg file * @param tiff path to outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertJpgTiff(String jpg, String tiff, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * Convert jpeg to tiff file. Uses direct data read method, that decrease memory usage. * This method don't close file descriptor * @param jpg file descriptor that represent income jpeg file * @param tiff file descriptor that represent outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertJpgTiffFd(int jpg, int tiff, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertTiffBmpFd(int, int, ConverterOptions, IProgressListener)}. * * Convert tiff to bmp file. Uses direct data read method, that decrease memory usage * @param tiff path to income tiff file * @param bmp path to outcome jpeg file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertTiffBmp(String tiff, String bmp, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * Convert tiff to bmp file. Uses direct data read method, that decrease memory usage * @param tiff file descriptor that represent income tiff file * @param bmp file descriptor that represent outcome bmp file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertTiffBmpFd(int tiff, int bmp, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#convertBmpTiffFd(int, int, ConverterOptions, IProgressListener)}. * * Convert bmp to tiff file. Uses direct data read method, that decrease memory usage. * @param bmp path to income bmp file * @param tiff path to outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertBmpTiff(String bmp, String tiff, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * Convert bmp to tiff file. Uses direct data read method, that decrease memory usage. * This method don't close file descriptor * @param bmp file descriptor that represent income bmp file * @param tiff file descriptor that represent outcome tiff file * @param options converter options * @param listener listener which will receive converting progress * @return true if convert process have been successful */ public static native boolean convertBmpTiffFd(int bmp, int tiff, ConverterOptions options, IProgressListener listener) throws CantOpenFileException, DecodeTiffException, NotEnoughtMemoryException; /** * @deprecated Since Android Q is released. You can use this method with scoped storage. * Otherwise use {@link TiffConverter#getImageTypeFd(int)}. * * Return type of file. * @param path - file path * @return one of {@link ImageFormat} or {@link ImageFormat#UNKNOWN} */ public static native ImageFormat getImageType(String path); /** * Return type of file. This method don't close file descriptor * @param fd - file descriptor for file * @return one of {@link ImageFormat} or {@link ImageFormat#UNKNOWN} */ public static native ImageFormat getImageTypeFd(int fd); /** * Close detached file descriptor * @param fd */ public static native void closeFd(int fd); public static final class ConverterOptions { public ConverterOptions() { availableMemory = 8000*8000*4; appendTiff = false; resUnit = ResolutionUnit.NONE; compressionScheme = CompressionScheme.NONE; //orientation = Orientation.TOP_LEFT; throwExceptions = false; isStoped = false; } /** * Uses for stoping of native thread * @deprecated As of release 0.9.8.4, replaced by {@link Thread#interrupt()} */ private volatile boolean isStoped; /** * Stop native convert thread * If converting is started in any thread except main, calling of this method will cause force stop of converting and returning of false. * @deprecated As of release 0.9.8.4, replaced by {@link Thread#interrupt()} */ public void stop() { isStoped = true; } /** * Number of bytes that may be allocated during the file operations. *-1 means memory is unlimited.
*Default value is 244Mb
*/ public long availableMemory; /** * If set to true, converter will throw exceptions if some errors appeared while converting. * Otherwise converter will just return false. * Default value is false */ public boolean throwExceptions; /** * For converting from TIFF to ANY cases *Tiff directory that should be converted
*/ public int readTiffDirectory; /** * For converting from ANY to TIFF cases *If this value set to true while converting any to tiff - new tiff directory will be created * and added to existed tiff file.
* Otherwise file will be overwritten. *Default value is false
*/ public boolean appendTiff; /** * For converting from ANY to TIFF cases * Compression scheme used on the image data. *Default value is {@link CompressionScheme#NONE COMPRESSION_NONE}
*This parameter is link to TIFFTAG_COMPRESSION tag
*/ public CompressionScheme compressionScheme; /** * For converting from ANY to TIFF cases * {@link org.beyka.tiffbitmapfactory.Orientation Orientation} that will used for saving image *By default uses {@link org.beyka.tiffbitmapfactory.Orientation#TOP_LEFT ORIENTATION_TOPLEFT}
*This parameter is link to TIFFTAG_ORIENTATION tag
*/ //public Orientation orientation; /** * If this field is non-null - Converter will use only area specified in {@link DecodeArea} object to convert. *This field works only when convert from TIFF.
*For decoding not full bitmap, but only part of it - create new {@link DecodeArea} object and specify:
*{@link DecodeArea#x x}, {@link DecodeArea#y y} - left top corner of decoding area
*{@link DecodeArea#width width} - width of decoding area
*{@link DecodeArea#height height} - height of decoding area
*/ public DecodeArea inTiffDecodeArea; /** * For converting from ANY to TIFF cases * The number of pixels per {@link org.beyka.tiffbitmapfactory.TiffConverter.ConverterOptions#resUnit} in the ImageWidth direction. *It is not mandatory that the image be actually displayed or printed at the size implied by this parameter. * It is up to the application to use this information as it wishes.
*Defualt value is 0
*/ public float xResolution; /** * For converting from ANY to TIFF cases * The number of pixels per {@link org.beyka.tiffbitmapfactory.TiffConverter.ConverterOptions#resUnit} in the ImageHeight direction. *It is not mandatory that the image be actually displayed or printed at the size implied by this parameter. * It is up to the application to use this information as it wishes.
*Defualt value is 0
*/ public float yResolution; /** * For converting from ANY to TIFF cases * The unit of measurement for XResolution and YResolution. *To be used with xResolution and yResolution.
*The specification defines these values:
*Default value is {@link org.beyka.tiffbitmapfactory.ResolutionUnit#NONE}
*/ public ResolutionUnit resUnit; /** * For converting from ANY to TIFF cases * A string that describes the subject of the image. *This parameter is link to TIFFTAG_IMAGEDESCRIPTION tag
*/ public String imageDescription; /** * For converting from ANY to TIFF cases * Software that used for creating of image. *This parameter is link to TIFFTAG_SOFTWARE tag
*/ public String software; } } ================================================ FILE: src/main/java/org/beyka/tiffbitmapfactory/TiffSaver.java ================================================ package org.beyka.tiffbitmapfactory; import android.graphics.Bitmap; import org.beyka.tiffbitmapfactory.exceptions.CantOpenFileException; import org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException; import java.io.File; /** * Created by beyka on 18.2.16. */ public class TiffSaver { static { System.loadLibrary("tiff"); System.loadLibrary("tiffsaver"); } /** * Save bitmap to file with default {@link TiffSaver.SaveOptions options}. * * @param destination - file to write bitmap * @param bmp - Bitmap for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destination} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean saveBitmap(File destination, Bitmap bmp) throws CantOpenFileException, NotEnoughtMemoryException { return saveBitmap(destination.getAbsolutePath(), bmp, new SaveOptions()); } /** * Save bitmap to file. * * @param destination - file to write bitmap * @param bmp - Bitmap for saving * @param options - options for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destinationPath} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean saveBitmap(File destination, Bitmap bmp, SaveOptions options) throws CantOpenFileException { return saveBitmap(destination.getAbsolutePath(), bmp, options); } /** * Save bitmap to file with default {@link TiffSaver.SaveOptions options}. * * @param destinationPath - file path to write bitmap * @param bmp - Bitmap for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destinationPath} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean saveBitmap(String destinationPath, Bitmap bmp) throws CantOpenFileException { return saveBitmap(destinationPath, bmp, new SaveOptions()); } /** * Save bitmap to file. * * @param destinationPath - file path to write bitmap * @param bmp - Bitmap for saving * @param options - options for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destinationPath} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean saveBitmap(String destinationPath, Bitmap bmp, SaveOptions options) throws CantOpenFileException { // int pixels[] = new int[bmp.getWidth() * bmp.getHeight()]; // bmp.getPixels(pixels, 0, bmp.getWidth(), 0, 0, bmp.getWidth(), bmp.getHeight()); return save(destinationPath, -1, bmp, options, false); } /** * Append bitmap to the end of existing file or create new file with default {@link TiffSaver.SaveOptions options}. * * @param destination - file to write bitmap * @param bmp - Bitmap for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destination} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean appendBitmap(File destination, Bitmap bmp) throws CantOpenFileException, NotEnoughtMemoryException { return appendBitmap(destination.getAbsolutePath(), bmp, new SaveOptions()); } /** * append bitmap to the end of existing file or create new file. * * @param destination - file to write bitmap * @param bmp - Bitmap for saving * @param options - options for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destinationPath} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean appendBitmap(File destination, Bitmap bmp, SaveOptions options) throws CantOpenFileException { return appendBitmap(destination.getAbsolutePath(), bmp, options); } /** * append bitmap to the end of existing file or create new file with default {@link TiffSaver.SaveOptions options}. * * @param destinationPath - file path to write bitmap * @param bmp - Bitmap for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destinationPath} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean appendBitmap(String destinationPath, int page, Bitmap bmp) throws CantOpenFileException { return appendBitmap(destinationPath, bmp, new SaveOptions()); } /** * append bitmap to the end of existing file or create new file. * * @param destinationPath - file path to write bitmap * @param bmp - Bitmap for saving * @param options - options for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destinationPath} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean appendBitmap(String destinationPath, Bitmap bmp,SaveOptions options) throws CantOpenFileException { // int pixels[] = new int[bmp.getWidth() * bmp.getHeight()]; // bmp.getPixels(pixels, 0, bmp.getWidth(), 0, 0, bmp.getWidth(), bmp.getHeight()); return save(destinationPath, -1, bmp, options, true); } /** * Save bitmap to file with default {@link TiffSaver.SaveOptions options}. * * @param fileDescriptor - file descriptor that represent file to write bitmap * @param bmp - Bitmap for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destination} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean saveBitmap(int fileDescriptor, Bitmap bmp) throws CantOpenFileException, NotEnoughtMemoryException { return saveBitmap(fileDescriptor, bmp, new SaveOptions()); } /** * Save bitmap to file with default {@link TiffSaver.SaveOptions options}. * * @param fileDescriptor - file descriptor that represent file to write bitmap * @param bmp - Bitmap for saving * @param options - options for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destination} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean saveBitmap(int fileDescriptor, Bitmap bmp, SaveOptions options) throws CantOpenFileException, NotEnoughtMemoryException { return save(null, fileDescriptor, bmp, options, false); } /** * Save bitmap to file with default {@link TiffSaver.SaveOptions options}. * * @param fileDescriptor - file descriptor that represent file to write bitmap * @param bmp - Bitmap for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destination} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean appendBitmap(int fileDescriptor, Bitmap bmp) throws CantOpenFileException, NotEnoughtMemoryException { return appendBitmap(fileDescriptor, bmp, new SaveOptions()); } /** * Save bitmap to file with default {@link TiffSaver.SaveOptions options}. * * @param fileDescriptor - file descriptor that represent file to write bitmap * @param bmp - Bitmap for saving * @param options - options for saving * @return true if bitmap was saved successful or false otherwise * @throws CantOpenFileException when {@code destination} not exist or can't be opened for writing * @throws org.beyka.tiffbitmapfactory.exceptions.NotEnoughtMemoryException when there is no avalable memory for processing bitmap * @throws org.beyka.tiffbitmapfactory.exceptions.DecodeTiffException when error occure while saving image */ public static boolean appendBitmap(int fileDescriptor, Bitmap bmp, SaveOptions options) throws CantOpenFileException, NotEnoughtMemoryException { return save(null, fileDescriptor, bmp, options, true); } private static synchronized native boolean save(String filePath, int fileDescriptor, Bitmap bmp, SaveOptions options, boolean append); /** * Close detached file descriptor * @param fd */ public static native void closeFd(int fd); /** * Options class to specify saving parameters */ public static final class SaveOptions { public SaveOptions() { inAvailableMemory = 8000*8000*4; inThrowException = false; compressionScheme = CompressionScheme.NONE; orientation = Orientation.TOP_LEFT; xResolution = 0; yResolution = 0; resUnit = ResolutionUnit.NONE; } /** * Number of bytes that may be allocated during the Tiff file operations. *-1 means memory is unlimited.
*Default value is 244Mb
*/ public long inAvailableMemory; /** * If set to true, saver will throw exceptions if some errors appeared while writing tiff. * Otherwise saver will just return false. * Default value is false */ public boolean inThrowException; /** * Compression scheme used on the image data. *Default value is {@link CompressionScheme#NONE COMPRESSION_NONE}
*This parameter is link to TIFFTAG_COMPRESSION tag
*/ public CompressionScheme compressionScheme; /** * {@link org.beyka.tiffbitmapfactory.Orientation Orientation} that will used for saving image *By default uses {@link org.beyka.tiffbitmapfactory.Orientation#TOP_LEFT ORIENTATION_TOPLEFT}
*This parameter is link to TIFFTAG_ORIENTATION tag
*/ public Orientation orientation; /** * The number of pixels per {@link org.beyka.tiffbitmapfactory.TiffSaver.SaveOptions#resUnit} in the ImageWidth direction. *It is not mandatory that the image be actually displayed or printed at the size implied by this parameter. * It is up to the application to use this information as it wishes.
*Defualt value is 0
*/ public float xResolution; /** * The number of pixels per {@link org.beyka.tiffbitmapfactory.TiffSaver.SaveOptions#resUnit} in the ImageHeight direction. *It is not mandatory that the image be actually displayed or printed at the size implied by this parameter. * It is up to the application to use this information as it wishes.
*Defualt value is 0
*/ public float yResolution; /** * The unit of measurement for XResolution and YResolution. *To be used with xResolution and yResolution.
*The specification defines these values:
*Default value is {@link org.beyka.tiffbitmapfactory.ResolutionUnit#NONE}
*/ public ResolutionUnit resUnit; /** * Author for writing to file. *This parameter is link to TIFFTAG_ARTIST tag
*/ public String author; /** * Copyright for writing to file *This parameter is link to TIFFTAG_COPYRIGHT tag
*/ public String copyright; /** * A string that describes the subject of the image. *This parameter is link to TIFFTAG_IMAGEDESCRIPTION tag
*/ public String imageDescription; } } ================================================ FILE: src/main/java/org/beyka/tiffbitmapfactory/exceptions/CantOpenFileException.java ================================================ package org.beyka.tiffbitmapfactory.exceptions; /** * Created by alexeyba on 09.11.15. */ public class CantOpenFileException extends RuntimeException { private String fileName; private int fileDescriptor = -1; public CantOpenFileException(String fileName){ super("Can\'t open file " + fileName); this.fileName = fileName; } public CantOpenFileException(int fileDescriptor){ super("Can\'t open file with file descriptor " + fileDescriptor); this.fileDescriptor = fileDescriptor; } public String getFileName(){ return fileName; } public int getFileDescriptor() { return fileDescriptor; } } ================================================ FILE: src/main/java/org/beyka/tiffbitmapfactory/exceptions/DecodeTiffException.java ================================================ package org.beyka.tiffbitmapfactory.exceptions; /** * Created by alexeyba on 09.11.15. */ public class DecodeTiffException extends RuntimeException { private String fileName; private String aditionalInfo; private int fileDescriptor = -1; public DecodeTiffException(String fileName){ super("Could not decode tiff file " + fileName); this.fileName = fileName; } public DecodeTiffException(int fileDescriptor) { super("Could not decode tiff file with file descriptor " + fileDescriptor); this.fileDescriptor = fileDescriptor; } public DecodeTiffException(String fileName, String aditionaInfo){ super("Could not decode tiff file " + fileName + "\n" + aditionaInfo); this.fileName = fileName; this.aditionalInfo = aditionaInfo; } public DecodeTiffException(int fileDescriptor, String aditionaInfo){ super("Could not decode tiff file with file descriptor" + fileDescriptor + "\n" + aditionaInfo); this.fileDescriptor = fileDescriptor; this.aditionalInfo = aditionaInfo; } public String getFileName(){ return fileName; } public String getAditionalInfo() { return aditionalInfo; } public int getFileDescriptor() { return fileDescriptor; } } ================================================ FILE: src/main/java/org/beyka/tiffbitmapfactory/exceptions/NotEnoughtMemoryException.java ================================================ package org.beyka.tiffbitmapfactory.exceptions; /** * Created by alexeyba on 09.11.15. */ public class NotEnoughtMemoryException extends RuntimeException { private int availableMemory; private int needMemory; public NotEnoughtMemoryException(int availableMemory, int needMemory){ super("Available memory is not enought to decode image. Available " + availableMemory + " bytes. Need " + needMemory + " bytes."); this.availableMemory = availableMemory; this.needMemory = needMemory; } public int getAvailableMemory() { return availableMemory; } public int getNeedMemory() { return needMemory; } } ================================================ FILE: src/main/jni/Android.mk ================================================ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_ARM_MODE := arm LOCAL_TIFF_SRC_FILES := \ tiff/libtiff/tif_dirread.c \ tiff/libtiff/tif_zip.c \ tiff/libtiff/tif_flush.c \ tiff/libtiff/tif_next.c \ tiff/libtiff/tif_ojpeg.c \ tiff/libtiff/tif_dirwrite.c \ tiff/libtiff/tif_dirinfo.c \ tiff/libtiff/tif_dir.c \ tiff/libtiff/tif_compress.c \ tiff/libtiff/tif_close.c \ tiff/libtiff/tif_tile.c \ tiff/libtiff/tif_open.c \ tiff/libtiff/tif_getimage.c \ tiff/libtiff/tif_pixarlog.c \ tiff/libtiff/tif_warning.c \ tiff/libtiff/tif_dumpmode.c \ tiff/libtiff/tif_jpeg.c \ tiff/libtiff/tif_jbig.c \ tiff/libtiff/tif_predict.c \ tiff/libtiff/mkg3states.c \ tiff/libtiff/tif_write.c \ tiff/libtiff/tif_error.c \ tiff/libtiff/tif_version.c \ tiff/libtiff/tif_print.c \ tiff/libtiff/tif_color.c \ tiff/libtiff/tif_read.c \ tiff/libtiff/tif_extension.c \ tiff/libtiff/tif_thunder.c \ tiff/libtiff/tif_lzw.c \ tiff/libtiff/tif_fax3.c \ tiff/libtiff/tif_luv.c \ tiff/libtiff/tif_codec.c \ tiff/libtiff/tif_unix.c \ tiff/libtiff/tif_packbits.c \ tiff/libtiff/tif_aux.c \ tiff/libtiff/tif_fax3sm.c \ tiff/libtiff/tif_swab.c \ tiff/libtiff/tif_strip.c LOCAL_TIFF_SRC_FILES += tiff/port/lfind.c #######################LIBTIFF################################# LOCAL_SRC_FILES:= $(LOCAL_TIFF_SRC_FILES) LOCAL_C_INCLUDES += \ $(LOCAL_PATH)/tiff/libtiff \ $(LOCAL_PATH)/jpeg LOCAL_CFLAGS += -DAVOID_TABLES LOCAL_CFLAGS += -O3 -fstrict-aliasing -fprefetch-loop-arrays LOCAL_MODULE:= libtiff LOCAL_LDLIBS := -lz LOCAL_LDLIBS += $(LOCAL_PATH)/libs/$(TARGET_ARCH_ABI)/libjpeg.a include $(BUILD_SHARED_LIBRARY) ############################################################### include $(CLEAR_VARS) LOCAL_MODULE := libpng LOCAL_SRC_FILES := libs/$(TARGET_ARCH_ABI)/libpng.a include $(PREBUILT_STATIC_LIBRARY) ############################################################### include $(CLEAR_VARS) LOCAL_MODULE := libjpeg LOCAL_SRC_FILES := libs/$(TARGET_ARCH_ABI)/libjpeg.a include $(PREBUILT_STATIC_LIBRARY) ############################################################### include $(CLEAR_VARS) LOCAL_MODULE := tifffactory LOCAL_CFLAGS := -DANDROID_NDK LOCAL_SRC_FILES := \ NativeExceptions.cpp \ NativeTiffBitmapFactory.cpp \ NativeDecoder.cpp LOCAL_LDLIBS := -ldl -llog -ljnigraphics LOCAL_LDFLAGS +=-ljnigraphics LOCAL_SHARED_LIBRARIES := tiff include $(BUILD_SHARED_LIBRARY) ############################################################### include $(CLEAR_VARS) LOCAL_MODULE := tiffsaver LOCAL_CFLAGS := -DANDROID_NDK LOCAL_SRC_FILES := \ NativeExceptions.cpp \ NativeTiffSaver.cpp LOCAL_LDLIBS := -ldl -llog -ljnigraphics LOCAL_LDFLAGS +=-ljnigraphics LOCAL_SHARED_LIBRARIES := tiff include $(BUILD_SHARED_LIBRARY) ############################################################### include $(CLEAR_VARS) LOCAL_MODULE := tiffconverter LOCAL_CFLAGS := -DANDROID_NDK LOCAL_SRC_FILES := \ NativeExceptions.cpp \ NativeTiffConverter.cpp \ TiffToPngConverter.cpp \ TiffToJpgConverter.cpp \ BaseTiffConverter.cpp \ PngToTiffConverter.cpp \ JpgToTiffConverter.cpp \ BmpToTiffConverter.cpp \ TiffToBmpConverter.cpp \ BitmapReader.cpp #LOCAL_C_INCLUDES := libs/$(TARGET_ARCH_ABI)/libpng.a LOCAL_C_INCLUDES := \ $(LOCAL_PATH)/png \ $(LOCAL_PATH)/jpeg LOCAL_LDLIBS := -lz -ldl -llog -ljnigraphics LOCAL_LDFLAGS +=-ljnigraphics LOCAL_STATIC_LIBRARIES := png LOCAL_STATIC_LIBRARIES += jpeg LOCAL_SHARED_LIBRARIES := tiff include $(BUILD_SHARED_LIBRARY) ================================================ FILE: src/main/jni/Application.mk ================================================ APP_STL := c++_static APP_MODULES := tiff png jpeg tifffactory tiffsaver tiffconverter APP_PLATFORM=android-16 APP_ABI := arm64-v8a, armeabi-v7a #APP_OPTIM := debug ================================================ FILE: src/main/jni/BMP.h ================================================ // // Created by beyka on 9/21/17. // #ifndef __BMP_H_INCLUDED__ // if x.h hasn't been included yet... #define __BMP_H_INCLUDED__ #pragma pack(2) typedef struct BITMAPFILEHEADER { BITMAPFILEHEADER() : bfReserved1(0), bfReserved2(0) {} unsigned char bfType[2]; unsigned int bfSize; unsigned short bfReserved1; unsigned short bfReserved2; unsigned int bfOffBits; } BITMAPFILEHEADER; typedef struct /**** BMP file info structure ****/ { unsigned int biSize; /* Size of info header */ int biWidth; /* Width of image */ int biHeight; /* Height of image */ unsigned short biPlanes; /* Number of color planes */ unsigned short biBitCount; /* Number of bits per pixel */ unsigned int biCompression; /* Type of compression to use 0 - none, 1 - rle 8 bit, 2 - rle 4 but, 3 - bi_bitfields*/ unsigned int biSizeImage; /* Size of image data */ int biXPelsPerMeter; /* X pixels per meter */ int biYPelsPerMeter; /* Y pixels per meter */ unsigned int biClrUsed; /* Number of colors used */ unsigned int biClrImportant; /* Number of important colors */ unsigned int biPalete[3] ; unsigned char reserved[56]; /* Palete (masks for 16 bit bmps)*/ /*a 5-5-5 16-bit image, where the blue mask is 0x001f, the green mask is 0x03e0, and the red mask is 0x7c00; and a 5-6-5 16-bit image, where the blue mask is 0x001f, the green mask is 0x07e0, and the red mask is 0xf800*/ } BITMAPINFOHEADER; #pragma pack() #endif ================================================ FILE: src/main/jni/BaseTiffConverter.cpp ================================================ // // Created by beyka on 5/11/17. // #include "BaseTiffConverter.h" BaseTiffConverter::BaseTiffConverter(JNIEnv *e, jclass clazz, jstring in, jstring out, jobject opts, jobject listener) { boundX = boundY = boundWidth = boundHeight = -1; hasBounds = 0; availableMemory = 8000 * 8000 * 4; env = e; inPath = in; outPath = out; optionsObj = opts; this->listener = listener; throwException = JNI_FALSE; appendTiff = JNI_FALSE; tiffDirectory = 0; jIProgressListenerClass = env->FindClass("org/beyka/tiffbitmapfactory/IProgressListener"); jConvertOptionsClass = env->FindClass("org/beyka/tiffbitmapfactory/TiffConverter$ConverterOptions"); jThreadClass = env->FindClass("java/lang/Thread"); compressionInt = 5; inFd = -1; outFd = -1; } BaseTiffConverter::BaseTiffConverter(JNIEnv *e, jclass clazz, jint in, jint out, jobject opts, jobject listener) { boundX = boundY = boundWidth = boundHeight = -1; hasBounds = 0; availableMemory = 8000 * 8000 * 4; env = e; inFd = in; outFd = out; optionsObj = opts; this->listener = listener; throwException = JNI_FALSE; appendTiff = JNI_FALSE; tiffDirectory = 0; jIProgressListenerClass = env->FindClass("org/beyka/tiffbitmapfactory/IProgressListener"); jConvertOptionsClass = env->FindClass("org/beyka/tiffbitmapfactory/TiffConverter$ConverterOptions"); jThreadClass = env->FindClass("java/lang/Thread"); compressionInt = 5; } BaseTiffConverter::~BaseTiffConverter() { LOGI("base destructor"); if (cdescription) { env->ReleaseStringUTFChars(description, cdescription); } if (csoftware) { env->ReleaseStringUTFChars(software, csoftware); } if (jIProgressListenerClass) { env->DeleteLocalRef(jIProgressListenerClass); jIProgressListenerClass = NULL; } if (jThreadClass) { env->DeleteLocalRef(jThreadClass); jThreadClass = NULL; } } void BaseTiffConverter::readOptions() { if (optionsObj == NULL) return; jfieldID tiffdirfield = env->GetFieldID(jConvertOptionsClass, "readTiffDirectory", "I"); tiffDirectory = env->GetIntField(optionsObj, tiffdirfield); jfieldID availablememfield = env->GetFieldID(jConvertOptionsClass, "availableMemory", "J"); jlong am = env->GetLongField(optionsObj, availablememfield); if (am > 0 || am == -1) availableMemory = am; jfieldID throwexceptionsfield = env->GetFieldID(jConvertOptionsClass, "throwExceptions", "Z"); throwException = env->GetBooleanField(optionsObj, throwexceptionsfield); jfieldID appentifffield = env->GetFieldID(jConvertOptionsClass, "appendTiff", "Z"); appendTiff = env->GetBooleanField(optionsObj, appentifffield); //read compression jfieldID gOptions_CompressionModeFieldID = env->GetFieldID(jConvertOptionsClass, "compressionScheme", "Lorg/beyka/tiffbitmapfactory/CompressionScheme;"); jobject compressionMode = env->GetObjectField(optionsObj, gOptions_CompressionModeFieldID); jclass compressionModeClass = env->FindClass("org/beyka/tiffbitmapfactory/CompressionScheme"); jfieldID ordinalFieldID = env->GetFieldID(compressionModeClass, "ordinal", "I"); jint ci = env->GetIntField(compressionMode, ordinalFieldID); LOGII("ci", ci); //check is compression scheme is right. if not - set default LZW if (ci == 1 || ci == 2 || ci == 3 || ci == 4 || ci == 5 || ci == 7 || ci == 8 || ci == 32773 || ci == 32946) compressionInt = ci; else compressionInt = 5; LOGII("compressionInt ", compressionInt ); env->DeleteLocalRef(compressionModeClass); //Get image orientation from options object /*jfieldID orientationFieldID = env->GetFieldID(jConvertOptionsClass, "orientation", "Lorg/beyka/tiffbitmapfactory/Orientation;"); jobject orientation = env->GetObjectField(optionsObj, orientationFieldID); jclass orientationClass = env->FindClass("org/beyka/tiffbitmapfactory/Orientation"); jfieldID orientationOrdinalFieldID = env->GetFieldID(orientationClass, "ordinal", "I"); orientationInt = env->GetIntField(orientation, orientationOrdinalFieldID); env->DeleteLocalRef(orientationClass);*/ orientationInt = ORIENTATION_TOPLEFT; //Get image description field if exist jfieldID imgDescrFieldID = env->GetFieldID(jConvertOptionsClass, "imageDescription", "Ljava/lang/String;"); description = (jstring)env->GetObjectField(optionsObj, imgDescrFieldID); if (description) { cdescription = env->GetStringUTFChars(description, 0); LOGIS("Image Description: ", cdescription); } //Get software field if exist jfieldID softwareFieldID = env->GetFieldID(jConvertOptionsClass, "software", "Ljava/lang/String;"); software = (jstring)env->GetObjectField(optionsObj, softwareFieldID); if (software) { csoftware = env->GetStringUTFChars(software, 0); LOGIS("Software tag: ", csoftware); } // variables for resolution jfieldID gOptions_xResolutionFieldID = env->GetFieldID(jConvertOptionsClass, "xResolution", "F"); xRes = env->GetFloatField(optionsObj, gOptions_xResolutionFieldID); jfieldID gOptions_yResolutionFieldID = env->GetFieldID(jConvertOptionsClass, "yResolution", "F"); yRes = env->GetFloatField(optionsObj, gOptions_yResolutionFieldID); jfieldID gOptions_resUnitFieldID = env->GetFieldID(jConvertOptionsClass, "resUnit", "Lorg/beyka/tiffbitmapfactory/ResolutionUnit;"); jobject resUnitObject = env->GetObjectField(optionsObj, gOptions_resUnitFieldID); //Get res int from resUnitObject jclass resolutionUnitClass = env->FindClass("org/beyka/tiffbitmapfactory/ResolutionUnit"); jfieldID resUnitOrdinalFieldID = env->GetFieldID(resolutionUnitClass, "ordinal", "I"); resUnit = env->GetIntField(resUnitObject, resUnitOrdinalFieldID); env->DeleteLocalRef(resolutionUnitClass); //Get decode are jfieldID gOptions_decodeAreaFieldID = env->GetFieldID(jConvertOptionsClass, "inTiffDecodeArea", "Lorg/beyka/tiffbitmapfactory/DecodeArea;"); jobject decodeAreaObj = env->GetObjectField(optionsObj, gOptions_decodeAreaFieldID); if (decodeAreaObj) { LOGI("Decode bounds present"); jclass decodeAreaClass = env->FindClass("org/beyka/tiffbitmapfactory/DecodeArea"); jfieldID xFieldID = env->GetFieldID(decodeAreaClass, "x", "I"); jfieldID yFieldID = env->GetFieldID(decodeAreaClass, "y", "I"); jfieldID widthFieldID = env->GetFieldID(decodeAreaClass, "width", "I"); jfieldID heightFieldID = env->GetFieldID(decodeAreaClass, "height", "I"); boundX = env->GetIntField(decodeAreaObj, xFieldID); boundY = env->GetIntField(decodeAreaObj, yFieldID); boundWidth = env->GetIntField(decodeAreaObj, widthFieldID); boundHeight = env->GetIntField(decodeAreaObj, heightFieldID); LOGII("Decode X", boundX); LOGII("Decode Y", boundY); LOGII("Decode width", boundWidth); LOGII("Decode height", boundHeight); hasBounds = 1; env->DeleteLocalRef(decodeAreaClass); } } char BaseTiffConverter::normalizeDecodeArea() { if (hasBounds) { if (boundX >= width-1) { const char *message = "X of left top corner of decode area should be less than image width"; LOGE(*message); if (throwException) { jstring adinf = env->NewStringUTF(message); if (inPath) { throw_decode_file_exception(env, inPath, adinf); } else { throw_decode_file_exception_fd(env, inFd, adinf); } env->DeleteLocalRef(adinf); } return 0; } if (boundY >= height-1) { const char *message = "Y of left top corner of decode area should be less than image height"; LOGE(*message); if (throwException) { jstring adinf = env->NewStringUTF(message); if (inPath) { throw_decode_file_exception(env, inPath, adinf); } else { throw_decode_file_exception_fd(env, inFd, adinf); } env->DeleteLocalRef(adinf); } return 0; } if (boundX < 0) boundX = 0; if (boundY < 0) boundY = 0; if (boundX + boundWidth >= width) boundWidth = width - boundX -1; if (boundY + boundHeight >= height) boundHeight = height - boundY -1; if (boundWidth < 1) { const char *message = "Width of decode area can\'t be less than 1"; LOGE(*message); if (throwException) { jstring adinf = env->NewStringUTF(message); if (inPath) { throw_decode_file_exception(env, inPath, adinf); } else { throw_decode_file_exception_fd(env, inFd, adinf); } env->DeleteLocalRef(adinf); } return 0; } if (boundHeight < 1) { const char *message = "Height of decode area can\'t be less than 1"; LOGE(*message); if (throwException) { jstring adinf = env->NewStringUTF(message); if (inPath) { throw_decode_file_exception(env, inPath, adinf); } else { throw_decode_file_exception_fd(env, inFd, adinf); } env->DeleteLocalRef(adinf); } return 0; } outWidth = boundWidth; outHeight = boundHeight; outStartX = boundX; outStartY = boundY; return 1; } else { outWidth = width; outHeight = height; outStartX = 0; outStartY = 0; return 1; } } char *BaseTiffConverter::getCreationDate() { char * datestr = (char *) malloc(sizeof(char) * 20); time_t rawtime; struct tm * timeinfo; time (&rawtime); timeinfo = localtime (&rawtime); strftime (datestr,20,/*"Now it's %I:%M%p."*/"%Y:%m:%d %H:%M:%S",timeinfo); return datestr; } void BaseTiffConverter::sendProgress(jlong current, jlong total) { if (listener != NULL) { jmethodID methodid = env->GetMethodID(jIProgressListenerClass, "reportProgress", "(JJ)V"); env->CallVoidMethod(listener, methodid, current, total); } } jboolean BaseTiffConverter::checkStop() { jmethodID methodID = env->GetStaticMethodID(jThreadClass, "interrupted", "()Z"); jboolean interupted = env->CallStaticBooleanMethod(jThreadClass, methodID); jboolean stop; if (optionsObj) { jfieldID stopFieldId = env->GetFieldID(jConvertOptionsClass, "isStoped", "Z"); stop = env->GetBooleanField(optionsObj, stopFieldId); } else { stop = JNI_FALSE; } return interupted || stop; } void BaseTiffConverter::rotateTileLinesVertical(uint32 tileHeight, uint32 tileWidth, uint32* whatRotate, uint32 *bufferLine) { for (int line = 0; line < tileHeight / 2; line++) { unsigned int *top_line, *bottom_line; top_line = whatRotate + tileWidth * line; bottom_line = whatRotate + tileWidth * (tileHeight - line -1); _TIFFmemcpy(bufferLine, top_line, sizeof(unsigned int) * tileWidth); _TIFFmemcpy(top_line, bottom_line, sizeof(unsigned int) * tileWidth); _TIFFmemcpy(bottom_line, bufferLine, sizeof(unsigned int) * tileWidth); } } void BaseTiffConverter::rotateTileLinesHorizontal(uint32 tileHeight, uint32 tileWidth, uint32* whatRotate, uint32 *bufferLine) { uint32 buf; for (int y = 0; y < tileHeight; y++) { for (int x = 0; x < tileWidth / 2; x++) { buf = whatRotate[y * tileWidth + x]; whatRotate[y * tileWidth + x] = whatRotate[y * tileWidth + tileWidth - x - 1]; whatRotate[y * tileWidth + tileWidth - x - 1] = buf; } } } void BaseTiffConverter::normalizeTile(uint32 tileHeight, uint32 tileWidth, uint32* rasterTile) { //normalize tile //find start and end pixels int sx = -1, ex= -1, sy= -1, ey= -1; for (int y = 0; y < tileHeight; y++) { for (int x = 0; x < tileWidth; x++) { if (rasterTile[y * tileWidth + x] != 0) { sx = x; sy = y; break; } } if (sx != -1) break; } for (int y = tileHeight -1; y >= 0; y--) { for (int x = tileWidth -1; x >= 0; x--) { if (rasterTile[y * tileWidth + x] != 0) { ex = x; ey = y; break; } } if (ex != -1) break; } if (sy != 0) { for (int y = 0; y < tileHeight - sy -1; y++) { memcpy(rasterTile + (y * tileWidth), rasterTile + ((y+sy)*tileWidth), tileWidth * sizeof(uint32)); } } if (sx != 0) { for (int y = 0; y < tileHeight; y++) { for (int x = 0; x < tileWidth - sx -1; x++) { rasterTile[y * tileWidth + x] = rasterTile[y * tileWidth + x + sx]; } } } } ================================================ FILE: src/main/jni/BaseTiffConverter.h ================================================ // // Created by beyka on 5/11/17. // #ifndef TIFFSAMPLE_BASETIFFCONVERTER_H #define TIFFSAMPLE_BASETIFFCONVERTER_H #include