vanitasvitae/DepthMapNeedle
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Added Base64Wrapper to support different Base64 Implementaions (like android). Also added some functionality for android compatibility

Browse source
This commit is contained in:
vanitasvitae 2015-04-28 22:47:56 +02:00
parent d7ccf6883c
commit 7cf965b1f5
9 changed files with 480 additions and 309 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
DepthMapNeedle.jar
View file

Binary file not shown.

13
src/ArrayUtils.java
View file

@ -1,9 +1,9 @@
public class ArrayUtils
{
/**
* Return true, if the array part is sub array of src from offset
*
* @param src array
* @param part array
* @param offset int
@ -21,6 +21,7 @@ public class ArrayUtils
/**
* converts the byte array b into a char array by casting all the bytes into chars
*
* @param b byte array
* @return char array
*/
@ -34,6 +35,7 @@ public class ArrayUtils
/**
* converts the char array into a byte array by casting all the chars into bytes
*
* @param c char array
* @return byte array
*/
@ -47,11 +49,13 @@ public class ArrayUtils
/**
* concatenate two byte arrays
*
* @param first first byte array
* @param second second byte array
* @return first + second
*/
public static byte[] concatenate (byte[] first, byte[] second) {
public static byte[] concatenate(byte[] first, byte[] second)
{
if (first == null) return second;
if (second == null) return first;
int aLen = first.length;
@ -64,10 +68,12 @@ public class ArrayUtils
/**
* convert an integer into a 32 bit byte array
*
* @param value integer
* @return byte array
*/
public static final byte[] intToByteArray(int value) {
public static final byte[] intToByteArray(int value)
{
return new byte[]{
(byte) (value >>> 24),
(byte) (value >>> 16),
@ -77,6 +83,7 @@ public class ArrayUtils
/**
* convert a signed byte array into an unsigned byte array (sort of)
*
* @param b byte array of signed bytes
* @return byte array of unsigned bytes
*/

9
src/Base64Wrapper.java Normal file
View file

@ -0,0 +1,9 @@
/**
* Created by vanitas on 28.04.15.
*/
public abstract class Base64Wrapper
{
public abstract byte[] decode(byte[] data);
public abstract byte[] encode(byte[] data);
}

10
src/Const.java
View file

@ -1,5 +1,4 @@
public class Const
{
/**
@ -7,7 +6,9 @@ public class Const
*/
public static final int CHUNKSIZE = 65400;
/** Strings for JPEGUtils.decorate() */
/**
* Strings for JPEGUtils.decorate()
*/
public static final String EXIF = "EXIF";
public static final String STANDARDXMP = "StandardXMP";
@ -18,6 +19,11 @@ public class Const
*/
public static byte[] markJPG = {(byte) 0xFF, (byte) 0xD8};
/**
* Magical bytes that idetify the file as PNG. (0x89 P N G) (length: 4)
*/
public static byte[] markPNG = {(byte) 0x89, (byte) 0x50, (byte) 0x4E, (byte) 0x47};
/**
* Marker that defines the beginning of a new block of metadata (FF E1) (length: 2)
*/

61
src/DepthMapNeedle.java
View file

@ -1,23 +1,39 @@
import java.util.Base64;
public class DepthMapNeedle
{
/**
* Interprete the arguments and execute the programm
*
* @param args
*/
public static void main(String[] args)
{
Base64Wrapper wrapper = new Base64Wrapper(){
@Override
public byte[] decode(byte[] data)
{
return Base64.getDecoder().decode(data);
}
@Override
public byte[] encode(byte[] data)
{
return Base64.getEncoder().encode(data);
}
};
//No arguments given or '-h' as first argument -> show help text
if (args.length == 0 || args[0].equals("-h")) help();
//export depthmap
if(args.length >= 2 && args[0].equals("-e"))
if (args.length >= 2 && args[0].equals("-d"))
{
for (int i = 1; i < args.length; i++)
{
JPEG image = new JPEG(args[i]);
if(image.exportDepthMap()) System.out.println("Depthmap extracted for file " + args[i]+".");
JPEG image = new JPEG(args[i], wrapper);
if (image.exportDepthMap())
System.out.println("Depthmap extracted for file "+args[i]+".");
else System.err.println("There is no Depthmap in file "+args[i]);
}
}
@ -27,21 +43,39 @@ public class DepthMapNeedle
{
for (int i = 1; i < args.length; i++)
{
JPEG image = new JPEG(args[i]);
if(image.exportSourceImage()) System.out.println("Unblurred source image extracted for file "+args[i]+".");
else System.err.println("There is no unblurred source image in file "+args[i]+". Maybe this photo has not been taken with the blur function?");
JPEG image = new JPEG(args[i], wrapper);
if (image.exportSourceImage())
System.out.println("Unblurred source image extracted for file "+args[i]+".");
else
System.err.println("There is no unblurred source image in file "+args[i]+". Maybe this photo has not been taken with the blur function?");
}
}
//inject depthmap
else if(args.length >= 3 && args[0].equals("-i"))
else if (args.length >= 3 && args[0].equals("-D"))
{
String depthmap = args[1];
for (int i = 2; i < args.length; i++)
{
JPEG image = new JPEG(args[i]);
if(image.injectDepthMap(depthmap)) System.out.println("Depthmap injected into file "+args[i]+".");
else System.err.println("Something went wrong while injecting "+depthmap+" into "+args[i]+".\nRemember: The first argument has to be a png and the following arguments must be jpgs shot with the blur function.");
JPEG image = new JPEG(args[i], wrapper);
if (image.injectDepthMap(depthmap))
System.out.println("Depthmap injected into file "+args[i]+".");
else
System.err.println("Something went wrong while injecting "+depthmap+" into "+args[i]+".\nRemember: The first argument has to be a png and the following arguments must be jpgs shot with the blur function.");
image.save();
}
}
//inject source image
else if (args.length >= 3 && args[0].equals("-S"))
{
String source = args[1];
for (int i = 2; i < args.length; i++)
{
JPEG image = new JPEG(args[i], wrapper);
if (image.injectSourceImage(source))
System.out.println("Source image injected into file "+args[i]+".");
else
System.err.println("Something went wrong while injecting "+source+" into "+args[i]+".\nRemember: The first argument has to be a jpg and the following arguments must be jpgs shot with the blur function.");
image.save();
}
}
@ -56,12 +90,15 @@ public class DepthMapNeedle
+"\nDepthMapNeedle is a tool to inject or extract depth information in form of depthmaps from photos shot using Google Cameras Blur function."
+"\n"
+"\nAvailable Options:"
+ "\n'-e <file1>.jpg ... <fileN>.jpg':"
+"\n'-d <file1>.jpg ... <fileN>.jpg':"
+"\n Extract the depthmap from the specified photo(s). The depthmaps will be stored with the suffix \"_d.png\"."
+"\n'-s <file1>.jpg ... <fileN>.jpg':"
+"\n Extract the unblurred source image from the photo(s). These files will be stored with the suffix \"_s.jpg\"."
+ "\n'-i <depthmap>.png <file1>.jpg <fileN>.jpg':"
+"\n'-D <depthmap>.png <file1>.jpg ... <fileN>.jpg':"
+"\n Inject a png file as Depthmap into the following specified jpg files."
+"\n'-S <unblurred>.jpg <file1>.jpg ... <fileN>.jpg':"
+"\n Inject an unblurred source image into the following specified jpg files. "
+"\n Note: The unblurred source image is a simple jpg file of the same dimensions as the photos."
+"\n'-h':"
+"\n Show this help text.");
}

17
src/HexUtil.java
View file

@ -1,5 +1,4 @@
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
@ -7,6 +6,7 @@ public class HexUtil
{
/**
* Print out a byte array in hexadecimal
*
* @param bytes array
*/
public static void printHex(byte[] bytes)
@ -16,10 +16,12 @@ public class HexUtil
/**
* convert a byte to a hex string
*
* @param data array
* @return String representation in hex
*/
public static String byteToHexString(byte data) {
public static String byteToHexString(byte data)
{
StringBuffer buf = new StringBuffer();
buf.append(toHexChar((data >>> 4) & 0x0F));
@ -30,19 +32,24 @@ public class HexUtil
/**
* convert a integer into a hexadecimal character
*
* @param i integer
* @return hex char
*/
public static char toHexChar(int i) {
if ((0 <= i) && (i <= 9)) {
public static char toHexChar(int i)
{
if ((0 <= i) && (i <= 9))
{
return (char) ('0'+i);
} else {
} else
{
return (char) ('a'+(i-10));
}
}
/**
* Generate the md5 digest of the byte array data in hexadecimal
*
* @param data array
* @return byte array of the md5 digest in hex
*/

9
src/IO.java
View file

@ -1,5 +1,4 @@
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
@ -10,10 +9,12 @@ public class IO
{
/**
* Read file from disk to byte array
*
* @param file path to file
* @return byte array
*/
public static byte[] read(File file) {
public static byte[] read(File file)
{
try
{
InputStream is = new FileInputStream(file);
@ -21,8 +22,7 @@ public class IO
is.read(b);
is.close();
return b;
}
catch (IOException e)
} catch (IOException e)
{
System.err.println("Couldn't read file "+file.getAbsolutePath());
e.printStackTrace();
@ -32,6 +32,7 @@ public class IO
/**
* Write byte array to file on disk
*
* @param b byte array
* @param filepath path to outputfile
*/

189
src/JPEG.java
View file

@ -1,6 +1,5 @@
import java.io.File;
import java.util.Base64;
public class JPEG extends Const
{
@ -10,50 +9,56 @@ public class JPEG extends Const
/**
* location of the source file
*/
private String filename;
private String m_Filename;
/**
* byte array containing the actual file
*/
private byte[] rawData;
private byte[] m_RawData;
/**
* byte array containing EXIF block information without header
*/
private byte[] exif;
private byte[] m_Exif;
/**
* byte array containing StandardXMP block information without header
*/
private byte[] xmpSta;
private byte[] m_StandardXMP;
/**
* byte array containing ExtendedXMP block information without header
*/
private byte[] xmpExt;
private byte[] m_ExtendedXMP;
/**
* byte array conatining the trailing headless data block conatining the blurred jpeg image
* byte array containing the trailing headless data block containing the blurred jpeg image
*/
private byte[] tail;
private byte[] m_ImageTail;
private Base64Wrapper base64;
/** METHODS */
/**
* Constructor
* @param rawData
*
* @param rawData raw byte array
*/
public JPEG(byte[] rawData)
public JPEG(byte[] rawData, Base64Wrapper wrapper)
{
this.base64 = wrapper;
this.init(rawData, null);
}
/**
* Constructor, that reads a byte array from file
* @param filename
*
* @param filename raw byte array
*/
public JPEG(String filename)
public JPEG(String filename, Base64Wrapper wrapper)
{
this.base64 = wrapper;
this.init(IO.read(new File(filename)), filename);
}
@ -62,246 +67,311 @@ public class JPEG extends Const
*/
public void disassemble()
{
exif = this.getEXIFBlock();
xmpSta = this.getStandardXMPBlockContent();
xmpExt = this.getExtendedXMPContent();
tail = this.getImageTail();
m_Exif = this.getEXIFBlock();
m_StandardXMP = this.getStandardXMPBlockContent();
m_ExtendedXMP = this.getExtendedXMPContent();
m_ImageTail = this.getImageTail();
}
/**
* extract the depth map from the jpeg and store it in the same location as the jpeg itself but with the suffix _d.png
*
* @return
*/
public boolean exportDepthMap()
{
String out = filename;
String out = m_Filename;
if (out.endsWith(".jpg") || out.endsWith(".JPG")) out = out.substring(0, out.length()-4);
return this.exportDepthMap(out+"_d.png");
}
/**
* extract the depthmap from the jpeg and store it under the location specified in "file"
*
* @param file String of the output location
* @return success
*/
public boolean exportDepthMap(String file)
{
byte[] b64 = ArrayUtils.unsign(extractDepthMap());
byte[] depth = Base64.getDecoder().decode(b64);
byte[] depth = base64.decode(b64);
if (depth != null)
{
IO.write(depth, file);
return true;
}
else return false;
} else return false;
}
/**
* Extract and save the unblurred source image. The image will be saved in the same location as the jpeg itself, but with the suffix "_s.jpg"
*
* @return success
*/
public boolean exportSourceImage()
{
String out = filename;
String out = m_Filename;
if (out.endsWith(".jpg") || out.endsWith(".JPG")) out = out.substring(0, out.length()-4);
return this.exportSourceImage(out+"_s.jpg");
}
/**
* Extract the unblurred source image and save it under the location specified in "file"
*
* @param file String of the location
* @return success
*/
public boolean exportSourceImage(String file)
{
byte[] b64 = ArrayUtils.unsign(extractSourceImage());
byte[] src = Base64.getDecoder().decode(b64);
byte[] src = base64.decode(b64);
if (src != null)
{
IO.write(src, file);
return true;
}
else return false;
} else return false;
}
/**
* Extract and return the depthmap information
*
* @return depthmap as byte array
*/
public byte[] extractDepthMap()
{
return JPEGUtils.extractDepthMap(rawData);
return JPEGUtils.extractDepthMap(m_RawData);
}
/**
* Extract and return the unblurred source image
*
* @return source image as byte array
*/
public byte[] extractSourceImage()
{
return JPEGUtils.extractSourceImage(rawData);
return JPEGUtils.extractSourceImage(m_RawData);
}
/**
* Find all indizes of APP1 markers in the jpegs byte array
*
* @return integer array of all positions of the APP1 marker in the rawData array
*/
public int[] getBoundaries()
{
return JPEGUtils.getBoundaries(rawData);
return JPEGUtils.getBoundaries(m_RawData);
}
/**
* return the exif block of the jpeg as a byte array
*
* @return exifblock (member)
*/
public byte[] getExif()
{
return exif;
return m_Exif;
}
/**
* Gets the exif block from the rawData array instead from the member
*
* @return the exif block from rawData
*/
public byte[] getEXIFBlock()
{
return JPEGUtils.getEXIFBlock(rawData);
return JPEGUtils.getEXIFBlock(m_RawData);
}
/**
* Extract and return the content of all the ExtendedXMP blocks concatenated.
*
* @return content of the ExtendedXMP blocks
*/
public byte[] getExtendedXMPContent()
{
return JPEGUtils.getExtendedXMPBlockContent(rawData);
return JPEGUtils.getExtendedXMPBlockContent(m_RawData);
}
/**
* return the filename and path
* @return
*
* @return member filename
*/
public String getFilename()
{
return filename;
return m_Filename;
}
/**
* Return the headless block of data in the image (this contains the JPEG you see when opening the file)
*
* @return headless JPEG tail
*/
public byte[] getImageTail()
{
return JPEGUtils.getImageTail(rawData);
return JPEGUtils.getImageTail(m_RawData);
}
/**
* Return the Metadata of the image (content of all APP1 marked blocks)
*
* @return metadata
*/
public byte[] getMetadata()
{
return JPEGUtils.getMetadata(rawData);
return JPEGUtils.getMetadata(m_RawData);
}
/**
* Returns the byte array that IO.read(image) returned
*
* @return byte array of the image file
*/
public byte[] getRawData()
{
return this.rawData;
return this.m_RawData;
}
/**
* Extracts and returns the content of the StandardXMP block
*
* @return content of the StandardXMP block
*/
public byte[] getStandardXMPBlockContent()
{
return JPEGUtils.getStandardXMPBlockContent(rawData);
return JPEGUtils.getStandardXMPBlockContent(m_RawData);
}
/**
* Returns the Image tail (member)
*
* @return member image tail
*/
public byte[] getTail()
{
return tail;
return m_ImageTail;
}
/**
* Extracts and returns the content of all XMP blocks concatenated (StandardXMP + ExtendedXMPs)
*
* @return content of the XMP blocks
*/
public byte[] getXMPBlocksContent()
{
return JPEGUtils.getXMPBlocksContent(rawData);
return JPEGUtils.getXMPBlocksContent(m_RawData);
}
/**
* Return the member containing the ExtendedXMP information
*
* @return XmpExt (member)
*/
public byte[] getXmpExt()
{
return xmpExt;
return m_ExtendedXMP;
}
/**
* Return the member containing the StandardXMP information
*
* @return xmpSta (member)
*/
public byte[] getXmpSta()
{
return xmpSta;
return m_StandardXMP;
}
/**
* initializes the JPEG object.
* set the array containing the image as member rawData, set filename
* disassemble the Image and set the other members with content.
*
* @param raw byte array of the image
* @param filename location
*/
private void init(byte[] raw, String filename)
{
this.rawData = raw;
this.filename = filename;
if(ArrayUtils.arrayIsPartOfOtherArrayOnOffset(raw, Const.markJPG,0))
{
this.m_RawData = raw;
this.m_Filename = filename;
this.disassemble();
}
}
/**
* Inject a new depthmap into the jpeg ("replace" the old GDepth:Data value with the Base64 encoded png file)
*
* @param filename location of the new depthmap png
* @return success
*/
public boolean injectDepthMap(String filename)
{
byte[] depth = Base64.getEncoder().encode(IO.read(new File(filename)));
xmpExt = JPEGUtils.replace(xmpExt, keyGDepthData, depth);
if(xmpExt != null) return true;
else return false;
byte[] depth = base64.encode(IO.read(new File(filename)));
byte[] newExtendedXMP = JPEGUtils.replace(m_ExtendedXMP, keyGDepthData, depth);
if (newExtendedXMP != null)
{
m_ExtendedXMP = newExtendedXMP;
return true;
} else return false;
}
public boolean injectDepthMap(byte[] data)
{
byte[] depth = base64.encode(data);
byte[] newExtendedXMP = JPEGUtils.replace(m_ExtendedXMP, keyGDepthData, depth);
if (newExtendedXMP != null)
{
m_ExtendedXMP = newExtendedXMP;
return true;
} else return false;
}
/**
* Inject a new unblurred source image into the jpeg ("replace" the old GImage:Data value with the Base64 encoded jpg file)
*
* @param filename location of the new unblurred source image jpg
* @return success
*/
public boolean injectSourceImage(String filename)
{
byte[] image = base64.encode(IO.read(new File(filename)));
byte[] newExtendedXMP = JPEGUtils.replace(m_ExtendedXMP, keyGImageData, image);
if (newExtendedXMP != null)
{
m_ExtendedXMP = newExtendedXMP;
return true;
} else return false;
}
public boolean injectSourceImage(byte[] data)
{
byte[] image = base64.encode(data);
byte[] newExtendedXMP = JPEGUtils.replace(m_ExtendedXMP, keyGImageData, image);
if (newExtendedXMP != null)
{
m_ExtendedXMP = newExtendedXMP;
return true;
} else return false;
}
/**
* Reassemble a functional jpeg byte array from block data.
* Set rawData to the new array and also return it
*
* @return reassembled jpeg byte array
*/
public byte[] reassemble()
{
byte[] md5 = HexUtil.generateMD5(xmpExt);
byte[] md5 = HexUtil.generateMD5(m_ExtendedXMP);
byte[] out = markJPG;
out = ArrayUtils.concatenate(out, JPEGUtils.decorateBlock(exif,EXIF));
out = ArrayUtils.concatenate(out, JPEGUtils.decorateBlock(xmpSta, STANDARDXMP));
out = ArrayUtils.concatenate(out, JPEGUtils.decorateBlock(xmpExt, EXTENDEDXMP));
out = ArrayUtils.concatenate(out, tail);
out = ArrayUtils.concatenate(out, JPEGUtils.decorateBlock(m_Exif, EXIF));
out = ArrayUtils.concatenate(out, JPEGUtils.decorateBlock(m_StandardXMP, STANDARDXMP));
out = ArrayUtils.concatenate(out, JPEGUtils.decorateBlock(m_ExtendedXMP, EXTENDEDXMP));
out = ArrayUtils.concatenate(out, m_ImageTail);
out = JPEGUtils.replace(out, keyHasExtendedXMP, md5);
this.rawData = out;
this.m_RawData = out;
return out;
}
@ -310,11 +380,12 @@ public class JPEG extends Const
*/
public void save()
{
this.save(filename);
this.save(m_Filename);
}
/**
* Write the image to the file specified in "file"
*
* @param file
*/
public void save(String file)
@ -324,37 +395,41 @@ public class JPEG extends Const
/**
* Set the exif member to a new byte array
*
* @param exif new array
*/
public void setExif(byte[] exif)
{
this.exif=exif;
this.m_Exif = exif;
}
/**
* Set the tail member array to a new byte array
*
* @param tail new array
*/
public void setTail(byte[] tail)
{
this.tail=tail;
this.m_ImageTail = tail;
}
/**
* set the xmpExt member array to a new byte array
*
* @param xmpExt new array
*/
public void setXmpExt(byte[] xmpExt)
{
this.xmpExt=xmpExt;
this.m_ExtendedXMP = xmpExt;
}
/**
* set the xmpSta member array to a new byte array
*
* @param xmpSta new array
*/
public void setXmpSta(byte[] xmpSta)
{
this.xmpSta=xmpSta;
this.m_StandardXMP = xmpSta;
}
}

65
src/JPEGUtils.java
View file

@ -1,5 +1,4 @@
import java.util.Arrays;
import java.util.Vector;
@ -7,6 +6,7 @@ public class JPEGUtils extends Const
{
/**
* Read the length of the block from the two bytes after the APP1 Marker
*
* @param boundaryPos position of the APP1 Marker in the byte array
* @param data byte array containing the block WITH APP1 Marker
* @return length of the block
@ -24,8 +24,7 @@ public class JPEGUtils extends Const
try
{
o = 256 * (data[boundaryPos+2] & 0xFF)+(data[boundaryPos+3] & 0xFF);
}
catch(ArrayIndexOutOfBoundsException e)
} catch (ArrayIndexOutOfBoundsException e)
{
System.err.println("JPEGUtils blockLength threw ArrayIndexOutOfBoundsException. Maybe the block is cut after APP1 Marker?");
e.printStackTrace();
@ -39,6 +38,7 @@ public class JPEGUtils extends Const
* In case, type == EXTENDEDXMP and data.length > CHUNKSIZE multiple ExtendedXMPBlocks will be generated and concatenated.
* Available types:
* Const.EXIF, Const.STANDARDXMP, Const.EXTENDEDXMP
*
* @param data byte array of data that will be decorated
* @param type String declaring the type of header for the block.
* @return decorated block
@ -101,6 +101,7 @@ public class JPEGUtils extends Const
* Extract the value of a key from the data Array.
* For Example: data = 'blabalkey="Hallo"blabla', key = 'key'
* Output of extract(data, key) will be 'Hallo'
*
* @param data array of bytes
* @param key array that contains the key
* @return the "value" of the key (the part after the key and the following '="' to the next '"'.
@ -132,6 +133,7 @@ public class JPEGUtils extends Const
/**
* Extract the depth information from a byte array (image as array)
*
* @param data array of a jpeg image
* @return the value of Const.keyGDepthData (GDepth:Data)
*/
@ -145,6 +147,7 @@ public class JPEGUtils extends Const
/**
* Extract the unblurred source image from a byte array (image as array)
*
* @param data array of a jpeg image
* @return the value of Const.keyGImageData (GImage:Data)
*/
@ -158,6 +161,7 @@ public class JPEGUtils extends Const
/**
* convert an integer into a two byte representation in base 256
*
* @param l integer
* @return byte array of length two containing two bytes representing l in base 256
*/
@ -171,6 +175,7 @@ public class JPEGUtils extends Const
/**
* Get a block of data from an array containing blocks
*
* @param data array of bytes
* @param boundary position of the APP1 marker of the targeted block
* @return the full targeted block
@ -181,8 +186,7 @@ public class JPEGUtils extends Const
{
System.err.println("JPEGUtils getBlock: Block is no APP1-block");
return data;
}
else
} else
{
return Arrays.copyOfRange(data, boundary, boundary+JPEGUtils.readBlockLength(boundary, data)+2);
}
@ -190,6 +194,7 @@ public class JPEGUtils extends Const
/**
* Same as getBlock, but returns the targeted block without the APP1 Marker and the two bytes containing the length of the block.
*
* @param data byte array
* @param boundary position of the APP1 marker of the targeted block
* @return the targeted block without the APP1 marker and the two bytes containing the length
@ -200,13 +205,14 @@ public class JPEGUtils extends Const
{
System.err.println("JPEGUtils getBlockWithoutAPP1: Block is no APP1-block");
return null;
}
else return Arrays.copyOfRange(data, boundary+4, boundary+JPEGUtils.readBlockLength(boundary,data)+2);
} else
return Arrays.copyOfRange(data, boundary+4, boundary+JPEGUtils.readBlockLength(boundary, data)+2);
}
/**
* Same as getBlock but returns the block without any header (APP1, length, EXIF, StandardXMP, ExtendedXMP)
*
* @param data
* @param boundary
* @return
@ -217,20 +223,24 @@ public class JPEGUtils extends Const
{
System.err.println("JPEGUtils getBlockWithoutHeader: Block is no APP1-block");
return null;
}
else
} else
{
int offset;
if(ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markStandardXMP, 4+boundary)) offset = 2 + 2 + markStandardXMP.length;
else if(ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markExtendedXMP, 4+boundary)) offset = 2 + 2 + markExtendedXMP.length + 32 + 4 + 4;
else if(ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markEXIF, 4+boundary)) offset = 2 + 2 + markEXIF.length;
if (ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markStandardXMP, 4+boundary))
offset = 2+2+markStandardXMP.length;
else if (ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markExtendedXMP, 4+boundary))
offset = 2+2+markExtendedXMP.length+32+4+4;
else if (ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markEXIF, 4+boundary))
offset = 2+2+markEXIF.length;
else offset = 4;
return Arrays.copyOfRange(data, boundary+offset, boundary+JPEGUtils.readBlockLength(boundary, data)+2);
}
}
/**
* Return all positions of "FF E1" in the byte[]
* These are the bytes marking h´the beginning of a block
*
* @param data byte array
* @return array of positions of APP1 marker
*/
@ -251,8 +261,10 @@ public class JPEGUtils extends Const
return out;
}
/**
* Return the exif block of the jpg. This is usually the first block of data, but this tolerates any position
*
* @param data array of bytes
* @return exif block
*/
@ -270,6 +282,7 @@ public class JPEGUtils extends Const
/**
* Gets the concatenated content of all ExtendedXMPBlocks in the data array without headers
*
* @param data array
* @return content of the blocks
*/
@ -283,7 +296,8 @@ public class JPEGUtils extends Const
if (JPEGUtils.isExtendedXMP(block))
{
byte[] part = JPEGUtils.getBlockWithoutHeader(block, 0);
if(part == null) System.err.println("JPEGUtils getExtendedXMPBlockContent part is null");
if (part == null)
System.err.println("JPEGUtils getExtendedXMPBlockContent part is null");
cont = ArrayUtils.concatenate(cont, part);
}
}
@ -292,22 +306,27 @@ public class JPEGUtils extends Const
/**
* Returns the tail of the data array that is not content of any block. In case of the google camera this contains the JPEG image data
*
* @param data byte array
* @return the trailing blockless imagedata
* @return the trailing headless imagedata
*/
public static byte[] getImageTail(byte[] data)
{
byte[] out;
int[] bounds = getBoundaries(data);
if (bounds.length != 0)
{
int offset = 256 * (data[bounds[bounds.length-1]+2] & 0xFF)+(data[bounds[bounds.length-1]+3] & 0xFF);
offset += bounds[bounds.length-1];
offset += 2;
out = Arrays.copyOfRange(data, offset, data.length);
return out;
} else return null;
}
/**
* Returns the concatenated contents of all APP1 Blocks without the APP1 Markers
*
* @param data byte array
* @return the concatenated contents of APP1 Blocks
*/
@ -324,6 +343,7 @@ public class JPEGUtils extends Const
/**
* Returns the content of the StandardXMPBlock without header.
*
* @param data byte array
* @return the content of the StandardXMPBlock
*/
@ -341,6 +361,7 @@ public class JPEGUtils extends Const
/**
* Returns the content of all XMPBlocks (StandardXMP + ExtendedXMP) without headers and concatenated.
*
* @param data byte array
* @return byte array with contents
*/
@ -356,6 +377,7 @@ public class JPEGUtils extends Const
/**
* Returns true, if there is a APP1 marker at the given offset in data.
*
* @param data byte array
* @param offset offset
* @return true, if there is an APP1 marker at offset in data, else false
@ -367,6 +389,7 @@ public class JPEGUtils extends Const
/**
* Returns true, if there is an Exif marker after the APP1 marker in this block.
*
* @param block byte array
* @return true, if there is an Exif marker at offset 4, else false.
*/
@ -377,6 +400,7 @@ public class JPEGUtils extends Const
/**
* Returns true, if there is an Exif marker at offset in data, else false
*
* @param data
* @param offset
* @return true, if there is an Exif marker at offset in data, else false
@ -388,6 +412,7 @@ public class JPEGUtils extends Const
/**
* Returns true, if block is an extendedXMPBlock.
*
* @param block the block with FFE1 and the two following bytes
* @return true, if there is an extendedXMPmarker at offset 4 in block, else false
*/
@ -398,6 +423,7 @@ public class JPEGUtils extends Const
/**
* Returns true, if data has the magical bytes of a jpeg file at the start
*
* @param data byte array
* @return true, if there is a jpegmarker at offset 0 (FFD8)
*/
@ -408,6 +434,7 @@ public class JPEGUtils extends Const
/**
* Returns true, if there is a jpegMarker at offset in data
*
* @param data byte array
* @param offset offset
* @return true, if there is a jpegMarker at offset in data, ellse false
@ -416,8 +443,10 @@ public class JPEGUtils extends Const
{
return ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markJPG, offset);
}
/**
* Returns true, if data is a standardXMPBlock
*
* @param block block with FFE1 and the two following bytes
* @return true, if the block is standardXMP (has standardXMP marker at offset 4), else false
*/
@ -428,6 +457,7 @@ public class JPEGUtils extends Const
/**
* Returns true, if data has a standardXMPMarker at offset offset
*
* @param block byte array
* @return true, if the block has standardXMPMarker at offset, else false
*/
@ -438,6 +468,7 @@ public class JPEGUtils extends Const
/**
* Replace the value of a key in data with another value value
*
* @param data byte array
* @param key key of the value that will be modified
* @param value new value of key
@ -472,10 +503,8 @@ public class JPEGUtils extends Const
byte[] out = ArrayUtils.concatenate(pre, value);
out = ArrayUtils.concatenate(out, post);
return out;
}
else System.err.println("JPEGUtils replace: No closing \" found in data");
}
else System.err.println("JPEGUtils replace: key not found in data");
} else System.err.println("JPEGUtils replace: No closing \" found in data");
} else System.err.println("JPEGUtils replace: key not found in data");
return null;
}
}