diff --git a/src/ArrayUtils.java b/src/ArrayUtils.java
new file mode 100644
index 0000000..ba148bf
--- /dev/null
+++ b/src/ArrayUtils.java
@@ -0,0 +1,58 @@
+
+
+public class ArrayUtils
+{
+	public static boolean arrayIsPartOfOtherArrayOnOffset(byte[] src, byte[] part, int offset)
+	{
+		if(offset<0 || part.length+offset > src.length) return false;
+		for(int i=0; i<part.length; i++)
+		{
+			if(part[i] != src[i+offset]) return false;
+		}
+		return true;
+	}
+
+	public static char[] bytesToChars(byte[] b)
+	{
+		char[] c = new char[b.length];
+		for(int i=0; i<b.length; i++)
+			c[i] = (char) b[i];
+		return c;
+	}
+
+	public static byte[] charsToBytes(char[] c)
+	{
+		byte[] b = new byte[c.length];
+		for(int i=0; i<c.length; i++)
+			b[i] = (byte) c[i];
+		return b;
+	}
+
+	public static byte[] concatenate (byte[] out, byte[] bs) {
+		if(out == null) return bs;
+		if(bs == null) return out;
+		int aLen = out.length;
+		int bLen = bs.length;
+		byte[] c = new byte[aLen+bLen];
+		System.arraycopy(out, 0, c, 0, aLen);
+		System.arraycopy(bs, 0, c, aLen, bLen);
+		return c;
+	}
+
+	public static final byte[] intToByteArray(int value) {
+	    return new byte[] {
+	            (byte)(value >>> 24),
+	            (byte)(value >>> 16),
+	            (byte)(value >>> 8),
+	            (byte)value};
+	}
+
+	public static byte[] unsign(byte[] b)
+	{
+		byte[] u = new byte[b.length];
+		for(int i=0; i<b.length; i++)
+			u[i] = (byte) (b[i]&0xFF);
+		return u;
+	
+	}
+}
diff --git a/src/Const.java b/src/Const.java
new file mode 100644
index 0000000..525882b
--- /dev/null
+++ b/src/Const.java
@@ -0,0 +1,42 @@
+
+
+public class Const
+{
+	public static final int CHUNKSIZE = 65400;
+	
+	public static final String EXIF = "EXIF";
+	public static final String STANDARDXMP = "StandardXMP";
+	public static final String EXTENDEDXMP = "ExtendedXMP";
+	
+	public static byte[] markJPG = {(byte) 0xFF, (byte) 0xD8};				//FFD8
+	
+	public static byte[] markAPP1 = {(byte) 0xFF, (byte) 0xE1};				//FFE1
+	
+	public static byte[] markEXIF = {(byte) 0x45, (byte) 0x78, (byte) 0x69, (byte) 0x66, (byte) 0x00, (byte) 0x00};	//EXIF\0\0
+	
+	public static byte[] markStandardXMP = {										//Length: 29
+		(byte) 0x68, (byte) 0x74, (byte) 0x74, (byte) 0x70, 				//	http
+		(byte) 0x3A, (byte) 0x2F, (byte) 0x2F, (byte) 0x6E, (byte) 0x73, 	//	://ns
+		(byte) 0x2E, (byte) 0x61, (byte) 0x64, (byte) 0x6F, (byte) 0x62, 	//	.adob
+		(byte) 0x65, (byte) 0x2E, (byte) 0x63, (byte) 0x6F, (byte) 0x6D, 	//	e.com
+		(byte) 0x2F, (byte) 0x78, (byte) 0x61, (byte) 0x70, (byte) 0x2F, 	//	/xap/
+		(byte) 0x31, (byte) 0x2E, (byte) 0x30, (byte) 0x2F, (byte) 0x00};	//	1.0/\0
+	
+	public static byte[] markExtendedXMP = {										//Length: 35
+		(byte) 0x68, (byte) 0x74, (byte) 0x74, (byte) 0x70, 				//	http
+		(byte) 0x3A, (byte) 0x2F, (byte) 0x2F, (byte) 0x6E, (byte) 0x73, 	//	://ns
+		(byte) 0x2E, (byte) 0x61, (byte) 0x64, (byte) 0x6F, (byte) 0x62, 	//	.adob
+		(byte) 0x65, (byte) 0x2E, (byte) 0x63, (byte) 0x6F, (byte) 0x6D, 	//	e.com
+		(byte) 0x2F, (byte) 0x78, (byte) 0x6D, (byte) 0x70, (byte) 0x2F,	// 	/xmp/
+		(byte) 0x65, (byte) 0x78, (byte) 0x74, (byte) 0x65, (byte) 0x6e, 	//	exten
+		(byte) 0x73, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x2f, 	//	sion/
+		(byte) 0x00};														//	\0
+	
+	public static byte[] keyHasExtendedXMP = {								//xmpNote:HasExtendedXMP
+		0x78,0x6d,0x70,0x4e,0x6f,0x74,0x65,0x3a,0x48,0x61,0x73,0x45,0x78,0x74,0x65,0x6e,0x64,0x65,0x64,0x58,0x4d,0x50
+	};
+	
+	public static byte[] keyGDepthData = {0x47,0x44,0x65,0x70,0x74,0x68,0x3a,0x44,0x61,0x74,0x61};	//GDepth:Data
+	
+	public static byte[] keyGImageData = {0x47,0x49,0x6d,0x61,0x67,0x65,0x3a,0x44,0x61,0x74,0x61};	//GImage:Data
+}
diff --git a/src/DepthMapNeedle.java b/src/DepthMapNeedle.java
new file mode 100644
index 0000000..b37ed4c
--- /dev/null
+++ b/src/DepthMapNeedle.java
@@ -0,0 +1,51 @@
+
+
+public class DepthMapNeedle
+{
+	public static void main(String[] args)
+	{
+		if(args.length==0 || args[0].equals("-h")) help();
+		if(args.length >= 2 && args[0].equals("-e"))
+		{
+			for(int i=1; i<args.length; i++)
+			{
+				JPEG image = new JPEG(args[i]);
+				image.exportDepthMap();
+			}
+		}
+		else if(args.length >=2 && args[0].equals("-s"))
+		{
+			for(int i=1; i<args.length; i++)
+			{
+				JPEG image = new JPEG(args[i]);
+				image.exportSourceImage();
+			}
+		}
+		else if(args.length >= 3 && args[0].equals("-i"))
+		{
+			String depthmap = args[1];
+			for(int i=2; i<args.length; i++)
+			{
+				JPEG image = new JPEG(args[i]);
+				image.injectDepthMap(depthmap);
+				image.save();
+			}
+		}
+	}
+	
+	public static void help()
+	{
+		System.out.println("Welcome to 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   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   Inject a png file as Depthmap into the following specified jpg files."
+				+ "\n'-h':"
+				+ "\n   Show this help text.");
+	}
+}
diff --git a/src/Gui.java b/src/Gui.java
new file mode 100644
index 0000000..b2378b4
--- /dev/null
+++ b/src/Gui.java
@@ -0,0 +1,103 @@
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.UIManager;
+import javax.swing.UnsupportedLookAndFeelException;
+import javax.swing.table.DefaultTableModel;
+
+
+public class Gui extends JFrame
+{
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID=1L;
+	JTable images;
+	JButton execute;
+	JButton close;
+	
+	public Gui()
+	{
+		super();
+		this.setTitle("DepthMapExtractor");
+		this.setVisible(true);
+		this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+		this.setSize(new Dimension(600,400));
+		try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {}
+		JPanel content = new JPanel(new BorderLayout());
+		this.add(content);
+		DefaultTableModel model = new DefaultTableModel();
+		model.addColumn("filename");
+		this.images = new JTable(model);
+		JButton addBtn = new JButton("+");
+		addBtn.addActionListener(new ActionListener(){
+			@Override
+			public void actionPerformed(ActionEvent arg0)
+			{
+				//TODO: AddFilesDialog
+			}
+		});
+		JButton remBtn = new JButton("-");
+		remBtn.addActionListener(new ActionListener(){
+			@Override
+			public void actionPerformed(ActionEvent arg0)
+			{
+				//TODO: Remove selected files from table
+			}
+		});
+		JPanel tablePanel = new JPanel(new FlowLayout());
+		tablePanel.add(new JScrollPane(images));
+		JPanel tableButtons = new JPanel();
+		tableButtons.setLayout(new BoxLayout(tableButtons,BoxLayout.Y_AXIS));
+		tableButtons.add(addBtn);
+		tableButtons.add(remBtn);
+		tablePanel.add(tableButtons);
+		content.add(tablePanel, BorderLayout.NORTH);
+		
+		execute = new JButton("Execute");
+		execute.addActionListener(new ActionListener(){
+			@Override
+			public void actionPerformed(ActionEvent arg0)
+			{
+				//TODO: Actions
+			}
+		});
+		close = new JButton("Close");
+		close.addActionListener(new ActionListener(){
+			@Override
+			public void actionPerformed(ActionEvent arg0)
+			{
+				dispose();				
+			}
+		});
+		
+		JPanel buttons = new JPanel(new FlowLayout());
+		buttons.add(close); buttons.add(execute);
+		content.add(buttons,BorderLayout.SOUTH);
+		this.pack();
+	}
+	
+	public void executeExtraction()
+	{
+		DefaultTableModel model = (DefaultTableModel) images.getModel();
+		for(int i=0; i<model.getRowCount(); i++)
+		{
+			@SuppressWarnings("unused")
+			String filepath = (String) model.getValueAt(i, 0);
+			//DepthMapExtractor dme = new DepthMapExtractor(filepath);
+			//dme.extractDepthMap();
+			//TODO: check checkboxes etc.
+		}
+	}
+}
diff --git a/src/HexUtil.java b/src/HexUtil.java
new file mode 100644
index 0000000..eed7af0
--- /dev/null
+++ b/src/HexUtil.java
@@ -0,0 +1,48 @@
+
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+public class HexUtil
+{
+	public static void printHex(byte[] bytes)
+	{
+		for(byte b : bytes) System.out.print(byteToHex(b));
+	}
+
+	public static String byteToHex(byte data) {
+
+		StringBuffer buf = new StringBuffer();
+		buf.append(toHexChar((data >>> 4) & 0x0F));
+		buf.append(toHexChar(data & 0x0F));
+
+		return buf.toString();
+	}
+	
+	public static char toHexChar(int i) {
+		if ((0 <= i) && (i <= 9)) {
+			return (char) ('0' + i);
+		} else {
+			return (char) ('a' + (i - 10));
+		}
+	}
+	
+	public static byte[] generateMD5(byte[] data)
+	{
+		try
+		{
+			byte[] md5 = MessageDigest.getInstance("MD5").digest(data);
+			String m="";
+			for(int i=0; i<md5.length; i++)
+			{
+				m = m + byteToHex(md5[i]).toUpperCase();
+			}
+			return m.getBytes();
+		} catch (NoSuchAlgorithmException e)
+		{
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+			return null;
+		}
+	}
+}
diff --git a/src/IO.java b/src/IO.java
new file mode 100644
index 0000000..9b56554
--- /dev/null
+++ b/src/IO.java
@@ -0,0 +1,52 @@
+
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class IO
+{
+	/**
+	 * Read file from disk to byte array
+	 * @param file path to file
+	 * @return byte array
+	 */
+	public static byte[] read(File file) {
+		try
+		{
+			InputStream is = new FileInputStream(file);
+			byte[] b = new byte[(int) file.length()];
+			is.read(b);
+			is.close();
+			return b;
+		}
+		catch (IOException e)
+		{
+			System.err.println("Couldn't read file "+file.getAbsolutePath());
+			e.printStackTrace();
+			return null;
+		}
+	}
+	
+	/**
+	 * Write byte array to file on disk
+	 * @param b byte array
+	 * @param filepath path to outputfile
+	 */
+	public static void write(byte[] b, String filepath)
+	{
+		FileOutputStream fos;
+		try
+		{
+			fos=new FileOutputStream(filepath);
+			fos.write(b);
+			fos.close();
+		} catch (Exception e)
+		{
+			System.err.println("Couldn't write file "+filepath);
+			e.printStackTrace();
+		}	
+	}
+}
diff --git a/src/JPEG.java b/src/JPEG.java
new file mode 100644
index 0000000..2245cee
--- /dev/null
+++ b/src/JPEG.java
@@ -0,0 +1,190 @@
+
+
+import java.io.File;
+import java.util.Base64;
+
+public class JPEG extends Const
+{
+	private String filename;
+	private byte[] rawData;
+	private byte[] exif;
+	private byte[] xmpSta;
+	private byte[] xmpExt;
+	private byte[] tail;
+	
+	public JPEG(byte[] rawData)
+	{
+		this.init(rawData, null);
+	}
+	
+	public JPEG(String filename)
+	{
+		this.init(IO.read(new File(filename)), filename);
+	}
+	
+	public void disassemble()
+	{	
+		exif = this.getEXIFBlock();
+		xmpSta = this.getStandardXMPBlockContent();
+		xmpExt = this.getExtendedXMPContent();
+		tail = this.getImageTail();
+	}
+	
+	public void exportDepthMap()
+	{
+		String out = filename;
+		if(out.endsWith(".jpg") || out.endsWith(".JPG")) out = out.substring(0, out.length()-4);
+		this.exportDepthMap(out+"_d.png");
+	}
+	
+	public void exportDepthMap(String file)
+	{
+		byte[] b64 = ArrayUtils.unsign(extractDepthMap());
+		byte[] depth = Base64.getDecoder().decode(b64);
+		IO.write(depth, file);
+	}
+	
+	public void exportSourceImage()
+	{
+		String out = filename;
+		if(out.endsWith(".jpg") || out.endsWith(".JPG")) out = out.substring(0, out.length()-4);
+		this.exportSourceImage(out+"_s.jpg");
+	}
+	
+	public void exportSourceImage(String file)
+	{
+		byte[] b64 = ArrayUtils.unsign(extractSourceImage());
+		byte[] src = Base64.getDecoder().decode(b64);
+		IO.write(src, file);
+	}
+
+	public byte[] extractDepthMap()
+	{
+		return JPEGUtils.extractDepthMap(rawData);
+	}
+	
+	public byte[] extractSourceImage()
+	{
+		return JPEGUtils.extractSourceImage(rawData);
+	}
+
+	public int[] getBoundaries()
+	{
+		return JPEGUtils.getBoundaries(rawData);
+	}
+
+	public byte[] getExif()
+	{
+		return exif;
+	}
+
+	public byte[] getEXIFBlock()
+	{
+		return JPEGUtils.getEXIFBlock(rawData);
+	}
+	
+	public byte[] getExtendedXMPContent()
+	{
+		return JPEGUtils.getExtendedXMPBlockContent(rawData);
+	}
+	
+
+	public String getFilename()
+	{
+		return filename;
+	}
+
+	public byte[] getImageTail()
+	{
+		return JPEGUtils.getImageTail(rawData);
+	}
+
+	public byte[] getMetadata()
+	{
+		return JPEGUtils.getMetadata(rawData);
+	}
+	public byte[] getRawData()
+	{
+		return this.rawData;
+	}
+	public byte[] getStandardXMPBlockContent()
+	{
+		return JPEGUtils.getStandardXMPBlockContent(rawData);
+	}
+
+	public byte[] getTail()
+	{
+		return tail;
+	}
+
+	public byte[] getXMPBlocksContent()
+	{
+		return JPEGUtils.getXMPBlocksContent(rawData);
+	}
+
+	public byte[] getXmpExt()
+	{
+		return xmpExt;
+	}
+
+	public byte[] getXmpSta()
+	{
+		return xmpSta;
+	}
+
+	private void init(byte[] raw, String filename)
+	{
+		this.rawData = raw;
+		this.filename = filename;
+		this.disassemble();
+	}
+
+	public void injectDepthMap(String filename)
+	{
+		byte[] depth = Base64.getEncoder().encode(IO.read(new File(filename)));
+		xmpExt = JPEGUtils.replace(xmpExt, keyGDepthData, depth);
+	}
+
+	public byte[] reassemble()
+	{
+		byte[] md5 = HexUtil.generateMD5(xmpExt);
+		
+		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 = JPEGUtils.replace(out, keyHasExtendedXMP, md5);
+		this.rawData = out;
+		return out;
+	}
+
+	public void save()
+	{
+		this.save(filename);
+	}
+
+	public void save(String file)
+	{
+		IO.write(this.reassemble(), file);
+	}
+	
+	public void setExif(byte[] exif)
+	{
+		this.exif=exif;
+	}
+	
+	public void setTail(byte[] tail)
+	{
+		this.tail=tail;
+	}
+	public void setXmpExt(byte[] xmpExt)
+	{
+		this.xmpExt=xmpExt;
+	}
+
+	public void setXmpSta(byte[] xmpSta)
+	{
+		this.xmpSta=xmpSta;
+	}
+}
diff --git a/src/JPEGUtils.java b/src/JPEGUtils.java
new file mode 100644
index 0000000..ccfaf84
--- /dev/null
+++ b/src/JPEGUtils.java
@@ -0,0 +1,333 @@
+
+
+import java.util.Arrays;
+import java.util.Vector;
+
+public class JPEGUtils extends Const
+{
+
+	public static int blockLength(int boundaryPos, byte[] data)
+	{
+		if(!JPEGUtils.isAPP1Marker(data,boundaryPos))
+		{
+			System.err.println("JPEGUtils blockLength: Block is no APP1 Block!");
+			return -1;
+		}
+		int o;
+		try
+		{
+			o = 256*(data[boundaryPos+2]&0xFF) + (data[boundaryPos+3]&0xFF);
+		}
+		catch(ArrayIndexOutOfBoundsException e)
+		{
+			System.err.println("JPEGUtils blockLength got ArrayIndexOutOfBoundsException:");
+			e.printStackTrace();
+			return -1;
+		}
+		return o;
+	}
+	public static byte[] decorateBlock(byte[] data, String type)
+	{
+		if(type.equals(EXIF))
+		{
+			data = ArrayUtils.concatenate(markEXIF, data);
+			byte[] pre = ArrayUtils.concatenate(markAPP1, genLen(data.length+2));
+			return ArrayUtils.concatenate(pre, data);
+		}
+		else if(type.equals(STANDARDXMP))
+		{
+			data = ArrayUtils.concatenate(markStandardXMP, data);
+			byte[] pre = ArrayUtils.concatenate(markAPP1, genLen(data.length+2));
+			return ArrayUtils.concatenate(pre,data);
+		}
+		else if(type.equals(EXTENDEDXMP))
+		{
+			byte[] out = new byte[0];
+			byte[] md5 = HexUtil.generateMD5(data);
+			int i=0; 
+			int blockCount = data.length/CHUNKSIZE;
+			while (i<blockCount)
+			{
+				byte[] part = Arrays.copyOfRange(data, i*CHUNKSIZE, (i+1)*CHUNKSIZE);
+				byte[] pre = markAPP1;
+				pre = ArrayUtils.concatenate(pre, genLen(2+markExtendedXMP.length + 32 + 4 + 4 + part.length));
+				pre = ArrayUtils.concatenate(pre, markExtendedXMP);
+				pre = ArrayUtils.concatenate(pre, md5);
+				pre = ArrayUtils.concatenate(pre, ArrayUtils.intToByteArray(data.length));
+				pre = ArrayUtils.concatenate(pre, ArrayUtils.intToByteArray(i*CHUNKSIZE));
+				part = ArrayUtils.concatenate(pre, part);
+				out = ArrayUtils.concatenate(out, part);
+				i++;
+			}
+			//Rest
+			byte[] part = Arrays.copyOfRange(data, i*CHUNKSIZE, data.length);
+			byte[] pre = markAPP1;
+			pre = ArrayUtils.concatenate(pre, genLen(2+markExtendedXMP.length + 32 + 4 + 4 + part.length));
+			pre = ArrayUtils.concatenate(pre, markExtendedXMP);
+			pre = ArrayUtils.concatenate(pre, md5);
+			pre = ArrayUtils.concatenate(pre, ArrayUtils.intToByteArray(data.length));
+			pre = ArrayUtils.concatenate(pre, ArrayUtils.intToByteArray(i*CHUNKSIZE));
+			part = ArrayUtils.concatenate(pre, part);
+			out = ArrayUtils.concatenate(out, part);
+			return out;
+		}
+		return null;
+	}
+	public static byte[] extract(byte[] data, byte[] key)
+	{
+		int start = -1;
+		int end = -1;
+		for(int i=0; i<=data.length-key.length; i++)
+		{
+			if(ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, key, i) && data[i+key.length] == 0x3D && data[i+key.length+1] == 0x22)
+			{
+				start = i+key.length+2;
+				for(int j=i+key.length+2; j<data.length; j++)
+				{
+					if(data[j] == 0x22)
+					{
+						end = j;
+						return Arrays.copyOfRange(data, start, end);
+					}
+
+				}
+				System.err.println("JPEGUtils extract found end for \""+new String(key) +"\": false");
+			}
+		}
+		System.err.println("JPEGUtils extract found start for \""+new String(key) +"\": false");
+		return null;
+	}
+	public static byte[] extractDepthMap(byte[] data)
+	{
+		byte[] meta = getXMPBlocksContent(data);
+		byte[] depth = extract(meta, keyGDepthData);
+		if(depth == null) System.err.println("JPEGUtils extractDepthMap is null");
+		return depth;
+	}
+	public static byte[] extractSourceImage(byte[] data)
+	{
+		byte[] meta = getXMPBlocksContent(data);
+		byte[] src = extract(meta, keyGImageData);
+		if(src == null) System.err.println("JPEGUtils extractSourceImage is null");
+		return src;
+	}
+	public static byte[] genLen(int l)
+	{
+		byte[] o = new byte[2];
+		o[0] = (byte) (l/256);
+		o[1] = (byte) (l%256);
+		return o;
+	}
+	public static byte[] getBlock(byte[] data, int boundary)
+	{
+		if(!JPEGUtils.isAPP1Marker(data,boundary))
+		{
+			System.err.println("JPEGUtils getBlock: Block is no APP1-block");
+			return data;
+		}
+		else
+		{
+			return Arrays.copyOfRange(data, boundary, boundary+JPEGUtils.blockLength(boundary, data)+2);
+		}
+	}
+	public static byte[] getBlockWithoutAPP1(byte[] data, int boundary)
+	{
+		if(!JPEGUtils.isAPP1Marker(data,boundary))
+		{
+			System.err.println("JPEGUtils getBlockWithoutAPP1: Block is no APP1-block");
+			return null;
+		}
+		else return Arrays.copyOfRange(data, boundary+4, boundary+JPEGUtils.blockLength(boundary,data)+2);
+
+	}
+	public static byte[] getBlockWithoutHeader(byte[] data, int boundary)
+	{
+		if(!JPEGUtils.isAPP1Marker(data,boundary))
+		{
+			System.err.println("JPEGUtils getBlockWithoutHeader: Block is no APP1-block");
+			return null;
+		}
+		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;
+			else offset = 4;
+			return Arrays.copyOfRange(data, boundary+offset, boundary+JPEGUtils.blockLength(boundary,data)+2);
+		}
+	}
+	/**
+	 * Return all positions of "FF E1" in the byte[]
+	 * @param data byte array
+	 * @return array of positions
+	 */
+	public static int[] getBoundaries(byte[] data)
+	{
+		Vector<Integer> b = new Vector<Integer>();
+		for(int i=0; i<data.length; i++)
+		{
+			if(JPEGUtils.isAPP1Marker(data,i))
+			{
+				b.add(i);
+				i+=3;	//Skip E1 and length
+			}
+		}
+		int[] out = new int[b.size()];
+		for(int i=0; i<b.size(); i++)
+			out[i] = b.get(i);
+		return out;
+
+	}
+	/**
+	 * Return the exif block of the jpg. This is usually the first block of data
+	 * @param data
+	 * @return exif block 
+	 */
+	public static byte[] getEXIFBlock(byte[] data)
+	{
+		int[] bounds = getBoundaries(data);
+		for(int e : bounds)
+		{
+			byte[] block = getBlock(data, e);
+			if(isEXIFBlock(block)) return getBlockWithoutHeader(data,e);
+		}
+		System.err.println("JPEGUtils getEXIFBlock: No EXIF-block found");
+		return null;
+	}
+	public static byte[] getExtendedXMPBlockContent(byte[] data)
+	{
+		int[] bounds = JPEGUtils.getBoundaries(data);
+		byte[] cont = new byte[0];
+		for(int e : bounds)
+		{
+			byte[] block = JPEGUtils.getBlock(data,e);
+			if(JPEGUtils.isExtendedXMP(block))
+			{
+				byte[] part = JPEGUtils.getBlockWithoutHeader(block,0);
+				if(part == null) System.err.println("JPEGUtils getExtendedXMPBlockContent part is null");
+				cont = ArrayUtils.concatenate(cont, part);
+			}
+		}
+		return cont;
+	}
+
+	public static byte[] getImageTail(byte[] data)
+	{
+		byte[] out;
+		int[] bounds = getBoundaries(data);
+		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;
+	}
+	public static byte[] getMetadata(byte[] data)
+	{
+		int[] boundaries = getBoundaries(data);
+		byte[] out = new byte[0];
+		for(int e : boundaries)
+		{
+			out = ArrayUtils.concatenate(out, getBlockWithoutAPP1(data,e));
+		}
+		return out;
+	}
+	public static byte[] getStandardXMPBlockContent(byte[] data)
+	{
+		int[] bounds = JPEGUtils.getBoundaries(data);
+		for(int e : bounds)
+		{
+			byte[] block = JPEGUtils.getBlock(data, e);
+			if(JPEGUtils.isStandardXMP(block)) return JPEGUtils.getBlockWithoutHeader(data,e);
+		}
+		System.err.println("JPEGUtils getStandardXMPBlockContent is null");
+		return null;
+	}
+	public static byte[] getXMPBlocksContent(byte[] data)
+	{
+		byte[] stand = getStandardXMPBlockContent(data);
+		byte[] ext = getExtendedXMPBlockContent(data);
+
+		byte[] out = ArrayUtils.concatenate(stand, ext);
+		if(out==null) System.err.println("JPEGUtils getXMPBlocksContent is null");
+		return out;
+	}
+	public static boolean isAPP1Marker(byte[] data, int offset)
+	{
+		return ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markAPP1, offset);
+	}
+	public static boolean isEXIFBlock(byte[] block)
+	{
+		return JPEGUtils.isEXIFMarker(block, 4);
+	}
+	public static boolean isEXIFMarker(byte[] data, int offset)
+	{
+		return ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markEXIF, offset);
+	}
+	/**
+	 * Block is the block with FFE1 and the two following bytes
+	 * @param block block
+	 * @return true, if the block is extended xmp
+	 */
+	public static boolean isExtendedXMP(byte[] block)
+	{
+		return ArrayUtils.arrayIsPartOfOtherArrayOnOffset(block, markExtendedXMP, 4);
+	}
+	public static boolean isJPG(byte[] data)
+	{
+		return JPEGUtils.isJPG(data, 0);
+	}
+	public static boolean isJPG(byte[] data, int offset)
+	{
+		return ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, markJPG, offset);
+	}
+	/**
+	 * Block is the block with FFE1 and the two following bytes
+	 * @param block block
+	 * @return true, if the block is standard xmp
+	 */
+	public static boolean isStandardXMP(byte[] block)
+	{
+		return ArrayUtils.arrayIsPartOfOtherArrayOnOffset(block, markStandardXMP, 4);
+	}
+	public static boolean isStandardXMP(byte[] block, int offset)
+	{
+		return ArrayUtils.arrayIsPartOfOtherArrayOnOffset(block, markStandardXMP, offset);
+	}
+	public static byte[] replace(byte[] data, byte[] key, byte[] value)
+	{
+		int start = -1;
+		int end = -1;
+		for(int i=0; i<data.length; i++)
+		{
+			if(ArrayUtils.arrayIsPartOfOtherArrayOnOffset(data, key, i))
+			{
+				start = i+key.length+2;
+				break;
+			}
+		}
+		if(start != -1)
+		{
+			byte[] pre = Arrays.copyOfRange(data, 0, start);
+			for(int j=start; j<data.length; j++)
+			{
+				if(data[j] == 0x22)
+				{
+					end = j;
+					break;
+				}
+			}
+			if(end != -1)
+			{
+				byte[] post = Arrays.copyOfRange(data, end, data.length);
+				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");
+
+		return null;
+	}
+}