From 18a826c102e42e61121bf95c920211f35b06e47e Mon Sep 17 00:00:00 2001
From: fyhertz <fyhertz@gmail.com>
Date: Mon, 19 Aug 2013 20:41:25 -0400
Subject: [PATCH] MediaCodec API support on the way. Important changes in
 RtpSocket. New RtspClient class for wowza users.

---
 AndroidManifest.xml                           |   4 +-
 assets/www/index.htm                          |   2 +-
 res/layout/main.xml                           |  32 +-
 res/values/strings.xml                        |   1 +
 .../spydroid/api/CustomHttpServer.java        |  10 +
 .../spydroid/ui/HandsetFragment.java          |  28 +-
 .../streaming/MediaStream.java                | 186 ++++----
 .../majorkernelpanic/streaming/Session.java   |  13 +-
 .../majorkernelpanic/streaming/Stream.java    |   9 +-
 .../AACNotSupportedException.java             |   2 +-
 .../streaming/audio/AACStream.java            |  28 +-
 .../streaming/audio/AudioStream.java          |  40 +-
 .../streaming/rtp/AACADTSPacketizer.java      |  47 +-
 .../streaming/rtp/AMRNBPacketizer.java        |  34 +-
 .../streaming/rtp/AbstractPacketizer.java     |  72 ++-
 .../streaming/rtp/H263Packetizer.java         |  34 +-
 .../streaming/rtp/H264Packetizer.java         | 141 +++---
 .../streaming/rtp/MediaCodecInputStream.java  | 104 +++++
 .../streaming/rtp/RtpSocket.java              | 266 ++++++++---
 .../streaming/rtsp/RtspClient.java            | 363 +++++++++++++++
 .../streaming/rtsp/RtspServer.java            |  17 +
 .../streaming/video/H264Stream.java           |  40 +-
 .../streaming/video/VideoStream.java          | 437 ++++++++++++++----
 23 files changed, 1483 insertions(+), 427 deletions(-)
 rename src/net/majorkernelpanic/streaming/{exceptions => audio}/AACNotSupportedException.java (81%)
 create mode 100644 src/net/majorkernelpanic/streaming/rtp/MediaCodecInputStream.java
 create mode 100644 src/net/majorkernelpanic/streaming/rtsp/RtspClient.java

diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index c101c6b..2f98a87 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="net.majorkernelpanic.spydroid"
-    android:versionCode="810"
-    android:versionName="8.1" >
+    android:versionCode="900"
+    android:versionName="9.0" >
 
     <uses-sdk
         android:minSdkVersion="9"
diff --git a/assets/www/index.htm b/assets/www/index.htm
index 13ebedb..17ef72a 100644
--- a/assets/www/index.htm
+++ b/assets/www/index.htm
@@ -240,7 +240,7 @@ <h2>You must leave the screen of your smartphone on !</h2>
     </div>
 
     <div class="popup" id="error-noplugin">
-      <h2>You need to install or update VLC and the VLC mozilla plugin ! qsdqs qsdqs qsdqs</h2>
+      <h2>You need to install or update VLC and the VLC mozilla plugin !</h2>
       <h3>Get VLC: <a href="http://www.videolan.org/vlc/#download" target="_blank">Linux</a> <a href="http://www.videolan.org/vlc/download-windows.html" target="_blank">Windows</a> <a href="http://www.videolan.org/vlc/download-macosx.html" target="_blank">MacOSX</a></h3>
       <div id="content"><h3>During the installation make sure to check the mozilla plugin !</h3></div>
       <img src="images/install.jpg" width="316px" height="243px" alt="Install VLC and the mozilla plugin" />
diff --git a/res/layout/main.xml b/res/layout/main.xml
index dbb929f..75b7c6a 100644
--- a/res/layout/main.xml
+++ b/res/layout/main.xml
@@ -54,16 +54,34 @@
         android:layout_width="match_parent"
         android:layout_height="wrap_content" >
 
-        <TextView
+        <LinearLayout
             android:id="@+id/streaming"
-            android:layout_width="wrap_content"
+            android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:layout_gravity="center"
+            android:layout_gravity="top"
             android:gravity="center"
-            android:text="@string/streaming"
-            android:textColor="#11FF11"
-            android:textSize="20sp"
-            android:visibility="gone" />
+            android:orientation="vertical"
+            android:visibility="gone" >
+
+            <TextView
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="center"
+                android:gravity="center"
+                android:text="@string/streaming"
+                android:textColor="#11FF11"
+                android:textSize="20sp" />
+
+            <TextView
+                android:id="@+id/bitrate"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="center"
+                android:gravity="center"
+                android:text="@string/bitrate"
+                android:textColor="#11FF11"
+                android:textSize="16sp" />
+        </LinearLayout>
 
         <TextView
             android:id="@+id/advice"
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 42fee67..750708a 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -9,6 +9,7 @@
     <string name="options_activity_title">Settings</string>
     <string name="warning">Turn on wifi or tethering !</string>
     <string name="streaming">Streaming !</string>
+    <string name="bitrate">0 kbps</string>
     <string name="notification_title">Spydroid</string>
     <string name="notification_content">Beware ! Spydroid is running ;)</string>
     <string name="preview">Start a stream to enable the preview !</string>
diff --git a/src/net/majorkernelpanic/spydroid/api/CustomHttpServer.java b/src/net/majorkernelpanic/spydroid/api/CustomHttpServer.java
index 6854f7c..e740501 100644
--- a/src/net/majorkernelpanic/spydroid/api/CustomHttpServer.java
+++ b/src/net/majorkernelpanic/spydroid/api/CustomHttpServer.java
@@ -145,6 +145,16 @@ public boolean isStreaming() {
 		return false;
 	}
 
+	public long getBitrate() {
+		long bitrate = 0;
+		for ( Session session : mSessions.keySet() ) {
+		    if ( session != null ) {
+		    	if (session.isStreaming()) bitrate += session.getBitrate();
+		    } 
+		}
+		return bitrate;
+	}
+	
 	class CustomRequestHandler implements HttpRequestHandler {
 
 		public CustomRequestHandler() {}
diff --git a/src/net/majorkernelpanic/spydroid/ui/HandsetFragment.java b/src/net/majorkernelpanic/spydroid/ui/HandsetFragment.java
index 0fbe676..b19d3e1 100644
--- a/src/net/majorkernelpanic/spydroid/ui/HandsetFragment.java
+++ b/src/net/majorkernelpanic/spydroid/ui/HandsetFragment.java
@@ -38,6 +38,7 @@
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.os.Bundle;
+import android.os.Handler;
 import android.os.IBinder;
 import android.support.v4.app.Fragment;
 import android.view.LayoutInflater;
@@ -50,8 +51,10 @@
 
 public class HandsetFragment extends Fragment {
 
-    private TextView mDescription1, mDescription2, mLine1, mLine2, mVersion, mSignWifi, mSignStreaming;
-    private LinearLayout mSignInformation;
+	public final static String TAG = "HandsetFragment";
+	
+    private TextView mDescription1, mDescription2, mLine1, mLine2, mVersion, mSignWifi, mTextBitrate;
+    private LinearLayout mSignInformation, mSignStreaming;
     private Animation mPulseAnimation;
     
     private SpydroidApplication mApplication;
@@ -74,9 +77,10 @@ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle sa
         mDescription2 = (TextView)rootView.findViewById(R.id.line2_description);
         mVersion = (TextView)rootView.findViewById(R.id.version);
         mSignWifi = (TextView)rootView.findViewById(R.id.advice);
-        mSignStreaming = (TextView)rootView.findViewById(R.id.streaming);
+        mSignStreaming = (LinearLayout)rootView.findViewById(R.id.streaming);
         mSignInformation = (LinearLayout)rootView.findViewById(R.id.information);
         mPulseAnimation = AnimationUtils.loadAnimation(mApplication.getApplicationContext(), R.anim.pulse);
+        mTextBitrate = (TextView)rootView.findViewById(R.id.bitrate);
         return rootView ;
     }
 	
@@ -152,6 +156,7 @@ private void streamingState(int state) {
 			mSignWifi.clearAnimation();
 			mSignStreaming.setVisibility(View.VISIBLE);
 			mSignStreaming.startAnimation(mPulseAnimation);
+			mHandler.post(mUpdateBitrate);
 			mSignInformation.setVisibility(View.INVISIBLE);
 			mSignWifi.setVisibility(View.GONE);
 		} else if (state==2) {
@@ -228,5 +233,22 @@ public void onReceive(Context context, Intent intent) {
         	}
         } 
     };
+    
+	private final Handler mHandler = new Handler();
+    
+	private Runnable mUpdateBitrate = new Runnable() {
+		@Override
+		public void run() {
+			if ((mRtspServer != null && mRtspServer.isStreaming()) || (mHttpServer != null && mHttpServer.isStreaming())) {
+				long bitrate = 0;
+				bitrate += mRtspServer!=null?mRtspServer.getBitrate():0;
+				bitrate += mHttpServer!=null?mHttpServer.getBitrate():0;
+				mTextBitrate.setText(""+bitrate/1000+" kbps");
+				mHandler.postDelayed(mUpdateBitrate, 1000);
+			} else {
+				mTextBitrate.setText("0 kbps");
+			}
+		}
+	};
 	
 }
diff --git a/src/net/majorkernelpanic/streaming/MediaStream.java b/src/net/majorkernelpanic/streaming/MediaStream.java
index 5b67bc0..27d78c7 100644
--- a/src/net/majorkernelpanic/streaming/MediaStream.java
+++ b/src/net/majorkernelpanic/streaming/MediaStream.java
@@ -25,10 +25,13 @@
 import java.util.Random;
 
 import net.majorkernelpanic.streaming.rtp.AbstractPacketizer;
+import android.annotation.SuppressLint;
+import android.media.MediaCodec;
 import android.media.MediaRecorder;
 import android.net.LocalServerSocket;
 import android.net.LocalSocket;
 import android.net.LocalSocketAddress;
+import android.util.Log;
 
 /**
  * A MediaRecorder that streams what it records using a packetizer from the rtp package.
@@ -39,40 +42,43 @@ public abstract class MediaStream implements Stream {
 	protected static final String TAG = "MediaStream";
 
 	/** MediaStream forwards data to a packetizer through a LocalSocket. */
-	public static final int MODE_STREAMING = 0;
+	public static final int MODE_STREAMING_LEGACY = 0;
 
-	/** MediaStream will just act as a regular MediaRecorder. */
-	public static final int MODE_DEFAULT = 1;
+	/** MediaStream uses the new MediaCodec API introduced in JB 4.2 to stream audio/video. */
+	public static final int MODE_STREAMING_JB = 1;
 
 	/** The packetizer that will read the output of the camera and send RTP packets over the networkd. */
 	protected AbstractPacketizer mPacketizer = null;
 
-	/** The underlying MediaRecorder. */
 	protected MediaRecorder mMediaRecorder;
+	protected MediaCodec mMediaCodec;
 
 	private int mSocketId;
 
-	protected boolean mStreaming = false, mModeDefaultWasUsed = false;
-	protected int mode = MODE_STREAMING;
+	protected boolean mStreaming = false;
+	protected int mMode = MODE_STREAMING_LEGACY;
+	protected static int sSuggestedMode = MODE_STREAMING_LEGACY; 
 
 	private LocalServerSocket mLss = null;
-	private LocalSocket mReceiver, mSender = null;
+	protected LocalSocket mReceiver, mSender = null;
 
-	private int mRtpPort = 0, mRtcpPort = 0;
-	private InetAddress mDestination;
+	protected int mRtpPort = 0, mRtcpPort = 0;
+	protected InetAddress mDestination;
 
-	public MediaStream() {
-
-		mMediaRecorder = new MediaRecorder();
-
-		for (int i=0;i<10;i++) {
-			try {
-				mSocketId = new Random().nextInt();
-				mLss = new LocalServerSocket("net.majorkernelpanic.librtp-"+mSocketId);
-				break;
-			} catch (IOException e1) {}
+	static {
+		// We determine wether or not the MediaCodec API should be used
+		try {
+			Class.forName("android.media.MediaCodec");
+			sSuggestedMode = MODE_STREAMING_LEGACY;
+			Log.d(TAG,"Phone supports the MediaCoded API");
+		} catch (ClassNotFoundException e) {
+			sSuggestedMode = MODE_STREAMING_LEGACY;
+			Log.d(TAG,"Phone does not support the MediaCodec API");
 		}
-
+	}
+	
+	public MediaStream() {
+		mMode = sSuggestedMode;
 	}
 
 	/** 
@@ -144,19 +150,11 @@ public int[] getLocalPorts() {
 
 	/**
 	 * Sets the mode of the {@link MediaStream}.
-	 * If the mode is set to {@link #MODE_STREAMING}, video is forwarded to a UDP socket,
-	 * and if the mode is {@link #MODE_DEFAULT}, video is recorded in a file.
-	 * @param mode Either {@link #MODE_STREAMING} or {@link #MODE_DEFAULT} 
-	 * @throws IllegalStateException
+	 * If the mode is set to {@link #MODE_STREAMING_LEGACY}, video is forwarded to a UDP socket.
+	 * @param mode Either {@link #MODE_STREAMING_LEGACY} or {@link #MODE_STREAMING_JB} 
 	 */
-	public void setMode(int mode) throws IllegalStateException {
-		if (!mStreaming) {
-			this.mode = mode;
-			if (mode == MODE_DEFAULT) mModeDefaultWasUsed = true;
-		}
-		else {
-			throw new IllegalStateException("You can't call setMode() while streaming !");
-		}
+	public void setMode(int mode) {
+		this.mMode = mode;
 	}
 
 	/**
@@ -167,6 +165,13 @@ public AbstractPacketizer getPacketizer() {
 		return mPacketizer;
 	}
 
+	/**
+	 * Returns an approximation of the bitrate of the stream in bit per seconde.
+	 */
+	public long getBitrate() {
+		return !mStreaming ? 0 : mPacketizer.getRtpSocket().getBitrate(); 
+	}
+
 	/**
 	 * Indicates if the {@link MediaStream} is streaming.
 	 * @return A boolean indicating if the {@link MediaStream} is streaming
@@ -175,80 +180,54 @@ public boolean isStreaming() {
 		return mStreaming;
 	}
 
-	/** Prepares the stream. */
-	public void prepare() throws IllegalStateException,IOException {
-		if (mode==MODE_STREAMING) {
-			createSockets();
-			// We write the ouput of the camera in a local socket instead of a file !			
-			// This one little trick makes streaming feasible quiet simply: data from the camera
-			// can then be manipulated at the other end of the socket
-			mMediaRecorder.setOutputFile(mSender.getFileDescriptor());
-		}
-		mMediaRecorder.prepare();
-	}
-
 	/** Starts the stream. */
-	public void start() throws IllegalStateException {
+	public synchronized void start() throws IllegalStateException, IOException {
 
-		if (mode==MODE_STREAMING) {
-			if (mPacketizer==null)
-				throw new IllegalStateException("setPacketizer() should be called before start().");
+		if (mPacketizer==null)
+			throw new IllegalStateException("setPacketizer() should be called before start().");
 
-			if (mDestination==null)
-				throw new IllegalStateException("No destination ip address set for the stream !");
+		if (mDestination==null)
+			throw new IllegalStateException("No destination ip address set for the stream !");
 
-			if (mRtpPort<=0 || mRtcpPort<=0)
-				throw new IllegalStateException("No destination ports set for the stream !");
-		}
+		if (mRtpPort<=0 || mRtcpPort<=0)
+			throw new IllegalStateException("No destination ports set for the stream !");
 
-		mMediaRecorder.start();
-		try {
-			if (mode==MODE_STREAMING) {
-				// mReceiver.getInputStream contains the data from the camera
-				// the mPacketizer encapsulates this stream in an RTP stream and send it over the network
-				mPacketizer.setDestination(mDestination, mRtpPort, mRtcpPort);
-				mPacketizer.setInputStream(mReceiver.getInputStream());
-				mPacketizer.start();
-			}
-			mStreaming = true;
-		} catch (IOException e) {
-			mMediaRecorder.stop();
-			throw new IllegalStateException("Something happened with the local sockets :/ Start failed !");
-		}
+		switch (mMode) {
+		case MODE_STREAMING_LEGACY: 
+			encodeWithMediaRecorder(); 
+			break;
+		case MODE_STREAMING_JB: 
+			encodeWithMediaCodec();
+			break;
+		};
+		
 	}
 
 	/** Stops the stream. */
-	public void stop() {
+	@SuppressLint("NewApi")
+	public synchronized  void stop() {
 		if (mStreaming) {
+			mPacketizer.stop();
 			try {
-				mMediaRecorder.stop();
-			}
-			catch (Exception ignore) {}
-			finally {
-				closeSockets();
-				if (mode==MODE_STREAMING) mPacketizer.stop();
-				mStreaming = false;
-			}
+				if (mMode==MODE_STREAMING_LEGACY) {
+					mMediaRecorder.stop();
+					mMediaRecorder.release();
+					mMediaRecorder = null;
+					closeSockets();
+				} else {
+					mMediaCodec.stop();
+					mMediaCodec.release();
+					mMediaCodec = null;
+				}
+			} catch (Exception ignore) {}	
+			mStreaming = false;
 		}
-		try {
-			mMediaRecorder.reset();
-		}
-		catch (Exception ignore) {}	
 	}
 
-	/** 
-	 * Releases ressources associated with the stream. 
-	 * The object can not be used anymore when this function is called. 
-	 **/
-	public void release() {
-		stop();
-		try {
-			mLss.close();
-		}
-		catch (Exception ignore) {}
-		mMediaRecorder.release();
-	}	
-
+	protected abstract void encodeWithMediaRecorder() throws IOException;
+	
+	protected abstract void encodeWithMediaCodec() throws IOException;
+	
 	/**
 	 * Returns the SSRC of the underlying {@link net.majorkernelpanic.streaming.rtp.RtpSocket}.
 	 * @return the SSRC of the stream
@@ -259,18 +238,33 @@ public int getSSRC() {
 
 	public abstract String generateSessionDescription()  throws IllegalStateException, IOException;
 
-	private void createSockets() throws IOException {
+	protected void createSockets() throws IOException {
+
+		final String LOCAL_ADDR = "net.majorkernelpanic.streaming-";
+
+		for (int i=0;i<10;i++) {
+			try {
+				mSocketId = new Random().nextInt();
+				mLss = new LocalServerSocket(LOCAL_ADDR+mSocketId);
+				break;
+			} catch (IOException e1) {}
+		}
+
 		mReceiver = new LocalSocket();
-		mReceiver.connect( new LocalSocketAddress("net.majorkernelpanic.librtp-" + mSocketId ) );
+		mReceiver.connect( new LocalSocketAddress(LOCAL_ADDR+mSocketId) );
 		mReceiver.setReceiveBufferSize(500000);
 		mSender = mLss.accept();
 		mSender.setSendBufferSize(500000);
 	}
 
-	private void closeSockets() {
+	protected void closeSockets() {
 		try {
 			mSender.close();
+			mSender = null;
 			mReceiver.close();
+			mReceiver = null;
+			mLss.close();
+			mLss = null;
 		} catch (Exception ignore) {}
 	}
 
diff --git a/src/net/majorkernelpanic/streaming/Session.java b/src/net/majorkernelpanic/streaming/Session.java
index 195acd1..df89801 100644
--- a/src/net/majorkernelpanic/streaming/Session.java
+++ b/src/net/majorkernelpanic/streaming/Session.java
@@ -187,6 +187,16 @@ public Stream getTrack(int id) {
 			return mVideoStream;
 	}
 
+	/**
+	 * Returns an approximation of the bandwidth consumed by the session in bit per seconde. 
+	 */
+	public long getBitrate() {
+		long sum = 0;
+		if (mAudioStream != null) sum += mAudioStream.getBitrate();
+		if (mVideoStream != null) sum += mVideoStream.getBitrate();
+		return sum;
+	}
+	
 	/** Indicates if a track is currently running. */
 	public boolean isStreaming() {
 		if ( (mAudioStream!=null && mAudioStream.isStreaming()) || (mVideoStream!=null && mVideoStream.isStreaming()) )
@@ -205,7 +215,6 @@ public void start(int id) throws IllegalStateException, IOException {
 			if (stream!=null && !stream.isStreaming()) {
 				stream.setTimeToLive(mTimeToLive);
 				stream.setDestinationAddress(mDestination);
-				stream.prepare();
 				stream.start();
 			}
 		}
@@ -260,12 +269,10 @@ public void flush() {
 		synchronized (sLock) {
 			if (mVideoStream!=null) {
 				mVideoStream.stop();
-				mVideoStream.release();
 				mVideoStream = null;
 			}
 			if (mAudioStream!=null) {
 				mAudioStream.stop();
-				mAudioStream.release();
 				mAudioStream = null;
 			}
 		}
diff --git a/src/net/majorkernelpanic/streaming/Stream.java b/src/net/majorkernelpanic/streaming/Stream.java
index 1cc998e..afea569 100644
--- a/src/net/majorkernelpanic/streaming/Stream.java
+++ b/src/net/majorkernelpanic/streaming/Stream.java
@@ -28,10 +28,8 @@
  */
 public interface Stream {
 
-	public void start() throws IllegalStateException;
-	public void prepare() throws IllegalStateException,IOException;
+	public void start() throws IllegalStateException, IOException;
 	public void stop();
-	public void release();
 
 	/**
 	 * Sets the Time To Live of packets sent over the network.
@@ -77,6 +75,11 @@ public interface Stream {
 	
 	public int getSSRC();
 
+	/**
+	 * Returns an approximation of the bitrate of the stream in bit per seconde. 
+	 */
+	public long getBitrate();
+	
 	/**
 	 * The SSRC identifier of the stream.
 	 * @return The SSRC
diff --git a/src/net/majorkernelpanic/streaming/exceptions/AACNotSupportedException.java b/src/net/majorkernelpanic/streaming/audio/AACNotSupportedException.java
similarity index 81%
rename from src/net/majorkernelpanic/streaming/exceptions/AACNotSupportedException.java
rename to src/net/majorkernelpanic/streaming/audio/AACNotSupportedException.java
index d3f413b..c924fb3 100644
--- a/src/net/majorkernelpanic/streaming/exceptions/AACNotSupportedException.java
+++ b/src/net/majorkernelpanic/streaming/audio/AACNotSupportedException.java
@@ -1,4 +1,4 @@
-package net.majorkernelpanic.streaming.exceptions;
+package net.majorkernelpanic.streaming.audio;
 
 public class AACNotSupportedException extends RuntimeException {
 
diff --git a/src/net/majorkernelpanic/streaming/audio/AACStream.java b/src/net/majorkernelpanic/streaming/audio/AACStream.java
index bb2340a..3328c83 100644
--- a/src/net/majorkernelpanic/streaming/audio/AACStream.java
+++ b/src/net/majorkernelpanic/streaming/audio/AACStream.java
@@ -25,7 +25,6 @@
 import java.io.RandomAccessFile;
 import java.lang.reflect.Field;
 
-import net.majorkernelpanic.streaming.exceptions.AACNotSupportedException;
 import net.majorkernelpanic.streaming.rtp.AACADTSPacketizer;
 import android.annotation.SuppressLint;
 import android.content.SharedPreferences;
@@ -119,10 +118,10 @@ public void setPreferences(SharedPreferences prefs) {
 		mSettings = prefs;
 	}
 
-	public void prepare() throws IllegalStateException, IOException {
+	public void start() throws IllegalStateException, IOException {
 		testADTS();
 		((AACADTSPacketizer)mPacketizer).setSamplingRate(mActualSamplingRate);
-		super.prepare();
+		super.start();
 
 	}
 
@@ -159,7 +158,7 @@ private void testADTS() throws IllegalStateException, IOException {
 				mActualSamplingRate = Integer.valueOf(s[0]);
 				mConfig = Integer.valueOf(s[1]);
 				mChannel = Integer.valueOf(s[2]);
-				return;
+				//return;
 			}
 		}
 
@@ -173,14 +172,16 @@ private void testADTS() throws IllegalStateException, IOException {
 		
 		// ADTS header is 7 or 9 bytes long
 		byte[] buffer = new byte[9];
-
-		// That means the H264Stream will behave as a regular MediaRecorder object
-		// it will not start the packetizer thread and can be used to save video in a file
-		setMode(MODE_DEFAULT);
+		
+		mMediaRecorder = new MediaRecorder();
+		mMediaRecorder.setAudioSource(mAudioSource);
+		mMediaRecorder.setOutputFormat(mOutputFormat);
+		mMediaRecorder.setAudioEncoder(mAudioEncoder);
+		mMediaRecorder.setAudioChannels(1);
+		mMediaRecorder.setAudioSamplingRate(mSamplingRate);
 		mMediaRecorder.setOutputFile(TESTFILE);
-
-		super.prepare();
-		start();
+		mMediaRecorder.prepare();
+		mMediaRecorder.start();
 
 		// We record for 1 sec
 		// TODO: use the MediaRecorder.OnInfoListener
@@ -188,8 +189,9 @@ private void testADTS() throws IllegalStateException, IOException {
 			Thread.sleep(1000);
 		} catch (InterruptedException e) {}
 
-		stop();
-		setMode(MODE_STREAMING);
+		mMediaRecorder.stop();
+		mMediaRecorder.release();
+		mMediaRecorder = null;
 
 		File file = new File(TESTFILE);
 		RandomAccessFile raf = new RandomAccessFile(file, "r");
diff --git a/src/net/majorkernelpanic/streaming/audio/AudioStream.java b/src/net/majorkernelpanic/streaming/audio/AudioStream.java
index 9a89f6e..e49d484 100644
--- a/src/net/majorkernelpanic/streaming/audio/AudioStream.java
+++ b/src/net/majorkernelpanic/streaming/audio/AudioStream.java
@@ -2,6 +2,8 @@
 
 import java.io.IOException;
 
+import android.media.MediaRecorder;
+
 import net.majorkernelpanic.streaming.MediaStream;
 
 /** 
@@ -29,20 +31,46 @@ public void setAudioEncoder(int audioEncoder) {
 	public void setAudioSamplingRate(int samplingRate) {
 		mSamplingRate = samplingRate;
 	}
-	
-	public void prepare() throws IllegalStateException, IOException {
-		
-		// Resets the recorder in case it is in a bad state
-		mMediaRecorder.reset();
+
+	@Override
+	protected void encodeWithMediaRecorder() throws IOException {
 		
+		// We need a local socket to forward data output by the camera to the packetizer
+		createSockets();
+
+		mMediaRecorder = new MediaRecorder();
 		mMediaRecorder.setAudioSource(mAudioSource);
 		mMediaRecorder.setOutputFormat(mOutputFormat);
 		mMediaRecorder.setAudioEncoder(mAudioEncoder);
 		mMediaRecorder.setAudioChannels(1);
 		mMediaRecorder.setAudioSamplingRate(mSamplingRate);
 		
-		super.prepare();
+		// We write the ouput of the camera in a local socket instead of a file !			
+		// This one little trick makes streaming feasible quiet simply: data from the camera
+		// can then be manipulated at the other end of the socket
+		mMediaRecorder.setOutputFile(mSender.getFileDescriptor());
+
+		mMediaRecorder.prepare();
+		mMediaRecorder.start();
+
+		try {
+			// mReceiver.getInputStream contains the data from the camera
+			// the mPacketizer encapsulates this stream in an RTP stream and send it over the network
+			mPacketizer.setDestination(mDestination, mRtpPort, mRtcpPort);
+			mPacketizer.setInputStream(mReceiver.getInputStream());
+			mPacketizer.start();
+			mStreaming = true;
+		} catch (IOException e) {
+			stop();
+			throw new IOException("Something happened with the local sockets :/ Start failed !");
+		}
 		
 	}
+
+	@Override
+	protected void encodeWithMediaCodec() throws IOException {
+		// TODO: Implement this !
+		encodeWithMediaRecorder();
+	}
 	
 }
diff --git a/src/net/majorkernelpanic/streaming/rtp/AACADTSPacketizer.java b/src/net/majorkernelpanic/streaming/rtp/AACADTSPacketizer.java
index 79a3170..687599e 100644
--- a/src/net/majorkernelpanic/streaming/rtp/AACADTSPacketizer.java
+++ b/src/net/majorkernelpanic/streaming/rtp/AACADTSPacketizer.java
@@ -60,15 +60,21 @@ public void stop() {
 			is.close();
 		} catch (IOException ignore) {}
 		t.interrupt();
+		try {
+			t.join();
+		} catch (InterruptedException e) {}
 		t = null;
 	}
 
 	public void setSamplingRate(int samplingRate) {
 		this.samplingRate = samplingRate;
+		socket.setClockFrequency(samplingRate);
 	}
 	
 	public void run() {
 
+		Log.d(TAG,"AAC packetizer started !");
+		
 		// "A packet SHALL carry either one or more complete Access Units, or a
 		// single fragment of an Access Unit.  Fragments of the same Access Unit
 		// have the same time stamp but different RTP sequence numbers.  The
@@ -78,53 +84,56 @@ public void run() {
 		// Adts header fields that we need to parse
 		boolean protection;
 		int frameLength, sum, length, nbau, nbpk;
-		long oldtime = System.nanoTime(), now = oldtime, measured = 0, lastmeasured = 5000, expected = 0;
-
+		long oldtime = System.nanoTime(), now = oldtime;
+		byte[] header = new byte[8]; 
+		
 		try {
 			while (!Thread.interrupted()) {
 
 				// Synchronisation: ADTS packet starts with 12bits set to 1
 				while (true) {
 					if ( (is.read()&0xFF) == 0xFF ) {
-						buffer[rtphl+1] = (byte) is.read();
-						if ( (buffer[rtphl+1]&0xF0) == 0xF0) break;
+						header[1] = (byte) is.read();
+						if ( (header[1]&0xF0) == 0xF0) break;
 					}
 				}
 
 				// Parse adts header (ADTS packets start with a 7 or 9 byte long header)
-				is.read(buffer,rtphl+2,5);
+				is.read(header,2,5);
 				
 				// The protection bit indicates whether or not the header contains the two extra bytes
-				protection = (buffer[rtphl+1]&0x01)>0 ? true : false;
-				frameLength = (buffer[rtphl+3]&0x03) << 11 | 
-						(buffer[rtphl+4]&0xFF) << 3 | 
-						(buffer[rtphl+5]&0xFF) >> 5 ;
+				protection = (header[1]&0x01)>0 ? true : false;
+				frameLength = (header[3]&0x03) << 11 | 
+						(header[4]&0xFF) << 3 | 
+						(header[5]&0xFF) >> 5 ;
 				frameLength -= (protection ? 7 : 9);
 				
 				// Number of AAC frames in the ADTS frame
-				nbau = (buffer[rtphl+6]&0x03) + 1;
+				nbau = (header[6]&0x03) + 1;
 				
 				// The number of RTP packets that will be sent for this ADTS frame
 				nbpk = frameLength/MAXPACKETSIZE + 1;
 				
 				// Read CRS if any
-				if (!protection) is.read(buffer,rtphl,2);
+				if (!protection) is.read(header,0,2);
 
 				// We update the RTP timestamp
-				ts +=  1024; //stats.average()*samplingRate/1000000000;
-				socket.updateTimestamp(ts);
+				ts +=  1024*1000000/samplingRate; //stats.average();
 				
 				// We send one RTCP Sender Report every 5 secs
 				if (intervalBetweenReports>0) {
 					if (delta>=intervalBetweenReports) {
 						delta = 0;
-						report.send(now,ts);
+						report.send(now,ts*samplingRate/1000000);
 					}
 				}
 				
 				sum = 0;
 				while (sum<frameLength) {
 
+					buffer = socket.requestBuffer();
+					socket.updateTimestamp(ts);
+					
 					// Read frame
 					if (frameLength-sum > MAXPACKETSIZE-rtphl-4) {
 						length = MAXPACKETSIZE-rtphl-4;
@@ -158,16 +167,8 @@ public void run() {
 
 				// We wait a little to avoid sending to many packets too quickly
 				now = System.nanoTime();
-				measured = (now-oldtime)/1000000;
-				delta += measured;
+				delta += (now-oldtime)/1000000;
 				oldtime = now;
-				expected = nbau*1024*1000 / (nbpk*samplingRate);
-				//Log.d(TAG,"expected: "+ expected + " measured: "+measured);
-				measured -= lastmeasured<2*expected/3 ? 2*expected/3-lastmeasured : 0;
-				lastmeasured = measured;
-				if (measured<2*expected/3) {
-					Thread.sleep( 2*expected/3-measured );
-				}
 				
 			}
 		} catch (IOException e) {
diff --git a/src/net/majorkernelpanic/streaming/rtp/AMRNBPacketizer.java b/src/net/majorkernelpanic/streaming/rtp/AMRNBPacketizer.java
index 5a71923..451f1b0 100644
--- a/src/net/majorkernelpanic/streaming/rtp/AMRNBPacketizer.java
+++ b/src/net/majorkernelpanic/streaming/rtp/AMRNBPacketizer.java
@@ -42,11 +42,13 @@ public class AMRNBPacketizer extends AbstractPacketizer implements Runnable {
 	private final int AMR_HEADER_LENGTH = 6; // "#!AMR\n"
 	private static final int AMR_FRAME_HEADER_LENGTH = 1; // Each frame has a short header
 	private static final int[] sFrameBits = {95, 103, 118, 134, 148, 159, 204, 244};
+	private int samplingRate = 8000;
 
 	private Thread t;
 
 	public AMRNBPacketizer() throws IOException {
 		super();
+		socket.setClockFrequency(samplingRate);
 	}
 
 	public void start() {
@@ -67,58 +69,52 @@ public void stop() {
 	public void run() {
 
 		int frameLength, frameType;
-		long now = System.nanoTime(), oldtime = now, measured;
-		long expected = 20, lastmeasured = 10000, intervalNs = 0;
+		long now = System.nanoTime(), oldtime = now;
+		byte[] header = new byte[AMR_HEADER_LENGTH];
 
 		try {
 
 			// Skip raw amr header
-			fill(rtphl,AMR_HEADER_LENGTH);
+			fill(header,0,AMR_HEADER_LENGTH);
 			
-			if (buffer[rtphl+5] != '\n') {
+			if (header[5] != '\n') {
 				Log.e(TAG,"Bad header ! AMR not correcty supported by the phone !");
 				return;
 			}
 
-			buffer[rtphl] = (byte) 0xF0;
-
 			while (!Thread.interrupted()) {
 
+				buffer = socket.requestBuffer();
+				buffer[rtphl] = (byte) 0xF0;
+				
 				// First we read the frame header
-				fill(rtphl+1,AMR_FRAME_HEADER_LENGTH);
+				fill(buffer, rtphl+1,AMR_FRAME_HEADER_LENGTH);
 
 				// Then we calculate the frame payload length
 				frameType = (Math.abs(buffer[rtphl + 1]) >> 3) & 0x0f;
 				frameLength = (sFrameBits[frameType]+7)/8;
 
 				// And we read the payload
-				fill(rtphl+2,frameLength);
+				fill(buffer, rtphl+2,frameLength);
 
 				//Log.d(TAG,"Frame length: "+frameLength+" frameType: "+frameType);
 
 				// RFC 3267 Page 14: "For AMR, the sampling frequency is 8 kHz"
 				// FIXME: Is this really always the case ??
-				ts += 160; 
+				ts += 160*1000000/samplingRate; //stats.average();
 				socket.updateTimestamp(ts);
 				socket.markNextPacket();
 
 				// We wait a little to avoid sending to many packets too quickly
 				now = System.nanoTime();
-				intervalNs = now-oldtime;
-				measured = intervalNs/1000000;
-				delta += measured;
+				delta += (now-oldtime)/1000000;
 				oldtime = now;
 				//Log.d(TAG,"expected: "+ expected + " measured: "+measured);
-				measured -= lastmeasured<2*expected/3 ? 2*expected/3-lastmeasured : 0;
-				lastmeasured = measured;
-				if (measured<2*expected/3) {
-					Thread.sleep( 2*expected/3-measured );
-				}
 				
 				if (intervalBetweenReports>0) {
 					if (delta>=intervalBetweenReports) {
 						delta = 0;
-						report.send(now,ts);
+						report.send(now,ts*samplingRate/1000000);
 					}
 				}
 				
@@ -134,7 +130,7 @@ public void run() {
 	}
 
 
-	private int fill(int offset,int length) throws IOException {
+	private int fill(byte[] buffer, int offset,int length) throws IOException {
 
 		int sum = 0, len;
 
diff --git a/src/net/majorkernelpanic/streaming/rtp/AbstractPacketizer.java b/src/net/majorkernelpanic/streaming/rtp/AbstractPacketizer.java
index 4c90dc8..d9cad4d 100644
--- a/src/net/majorkernelpanic/streaming/rtp/AbstractPacketizer.java
+++ b/src/net/majorkernelpanic/streaming/rtp/AbstractPacketizer.java
@@ -25,6 +25,8 @@
 import java.net.InetAddress;
 import java.util.Random;
 
+import android.util.Log;
+
 import net.majorkernelpanic.streaming.rtcp.SenderReport;
 
 /**
@@ -50,7 +52,6 @@ public AbstractPacketizer() throws IOException {
 		report = new SenderReport();
 		socket.setSSRC(ssrc);
 		report.setSSRC(ssrc);
-		buffer = socket.getBuffer();
 	}
 
 	public RtpSocket getRtpSocket() {
@@ -100,41 +101,84 @@ public void setSenderReportsInterval(long interval) {
 		intervalBetweenReports = interval;
 	}
 	
+	/** Starts the packetizer. */
 	public abstract void start() throws IOException;
 
+	/** Stops the packetizer. */
 	public abstract void stop();
 
+	/** Updates data for RTCP SR and sends the packet. */
 	protected void send(int length) throws IOException {
-		socket.send(length);
+		socket.commitBuffer(length);
 		report.update(length);
 	}
 
-	// Useful for debug
+	/** For debugging purposes. */
 	protected static String printBuffer(byte[] buffer, int start,int end) {
 		String str = "";
 		for (int i=start;i<end;i++) str+=","+Integer.toHexString(buffer[i]&0xFF);
 		return str;
 	}
 
+	/** Used in packetizers to estimate timestamps in RTP packets. */
 	protected static class Statistics {
 
-		public final static int COUNT=500000;
+		public final static String TAG = "Statistics";
+		
+		private int count=700, c = 0;
 		private float m = 0, q = 0;
-
-		public void init(long value) {
-			m = value;
-			q = COUNT;
+		private long elapsed = 0;
+		private long start = 0;
+		private long duration = 0;
+		private long period = 6000000000L;
+		private boolean initoffset = false;
+		
+		public Statistics() {}
+		
+		public Statistics(int count, int period) {
+			this.count = count;
+			this.period = period;
 		}
 		
-		public void push(long duration) {
-			m = (m*q+duration)/(q+1);
-			if (q<COUNT) q++;
+		public void reset() {
+			initoffset = false;
+			q = 0; m = 0; c = 0;
+			elapsed = 0;
+			start = 0;
+			duration = 0;
 		}
-
+		
+		public void push(long value) {
+			elapsed += value;
+			if (elapsed>period) {
+				elapsed = 0;
+				long now = System.nanoTime();
+				if (!initoffset || (now - start < 0)) {
+					start = now;
+					duration = 0;
+					initoffset = true;
+				}
+				// Prevents drifting issues by comparing the real duration of the 
+				// stream with the sum of all temporal lengths of RTP packets. 
+				value += (now - start) - duration;
+				//Log.d(TAG, "sum1: "+duration/1000000+" sum2: "+(now-start)/1000000+" drift: "+((now-start)-duration)/1000000+" v: "+value/1000000);
+			}
+			if (c<20) {
+				// We ignore the first 20 measured values because they may not be accurate
+				c++;
+				m = value;
+			} else {
+				m = (m*q+value)/(q+1);
+				if (q<count) q++;
+			}
+		}
+		
 		public long average() {
-			return (long)m;
+			long l = (long)m;
+			duration += l;
+			return l;
 		}
 
 	}
-
+	
 }
diff --git a/src/net/majorkernelpanic/streaming/rtp/H263Packetizer.java b/src/net/majorkernelpanic/streaming/rtp/H263Packetizer.java
index 5abbb2c..c88757a 100644
--- a/src/net/majorkernelpanic/streaming/rtp/H263Packetizer.java
+++ b/src/net/majorkernelpanic/streaming/rtp/H263Packetizer.java
@@ -22,7 +22,6 @@
 
 import java.io.IOException;
 
-import android.os.SystemClock;
 import android.util.Log;
 
 /**
@@ -44,6 +43,7 @@ public class H263Packetizer extends AbstractPacketizer implements Runnable {
 
 	public H263Packetizer() throws IOException {
 		super();
+		socket.setClockFrequency(90);
 	}
 
 	public void start() throws IOException {
@@ -66,7 +66,8 @@ public void run() {
 		long time, duration = 0;
 		int i = 0, j = 0, tr;
 		boolean firstFragment = true;
-
+		byte[] nextBuffer;
+		stats.reset();
 		// This will skip the MPEG4 header if this step fails we can't stream anything :(
 		try {
 			skipHeader();
@@ -75,12 +76,16 @@ public void run() {
 			return;
 		}	
 
-		// Each packet we send has a two byte long header (See section 5.1 of RFC 4629)
-		buffer[rtphl] = 0;
-		buffer[rtphl+1] = 0;
-
 		try { 
 			while (!Thread.interrupted()) {
+				
+				if (j==0) buffer = socket.requestBuffer();
+				socket.updateTimestamp(ts);
+				
+				// Each packet we send has a two byte long header (See section 5.1 of RFC 4629)
+				buffer[rtphl] = 0;
+				buffer[rtphl+1] = 0;
+				
 				time = System.nanoTime();
 				if (fill(rtphl+j+2,MAXPACKETSIZE-rtphl-j-2)<0) return;
 				duration += System.nanoTime() - time;
@@ -109,18 +114,19 @@ public void run() {
 					if (intervalBetweenReports>0) {
 						if (delta>=intervalBetweenReports && duration/1000000>10) {
 							delta = 0;
-							report.send(System.nanoTime(),ts);
+							report.send(System.nanoTime(),ts*90/1000000);
 						}
 					}
 					// We have found the end of the frame
 					stats.push(duration);
-					ts+= stats.average()*9/100000; duration = 0;
+					ts+= stats.average(); duration = 0;
 					//Log.d(TAG,"End of frame ! duration: "+stats.average());
 					// The last fragment of a frame has to be marked
 					socket.markNextPacket();
 					send(j);
-					socket.updateTimestamp(ts);
-					System.arraycopy(buffer,j+2,buffer,rtphl+2,MAXPACKETSIZE-j-2);
+					nextBuffer = socket.requestBuffer();
+					System.arraycopy(buffer,j+2,nextBuffer,rtphl+2,MAXPACKETSIZE-j-2);
+					buffer = nextBuffer;
 					j = MAXPACKETSIZE-j-2;
 					firstFragment = true;
 				} else {
@@ -129,7 +135,8 @@ public void run() {
 					send(MAXPACKETSIZE);
 				}
 			}
-		} catch (IOException e) {}
+		} catch (IOException e) { 
+		} catch (InterruptedException e) {}
 
 		Log.d(TAG,"H263 Packetizer stopped !");
 
@@ -154,10 +161,11 @@ private int fill(int offset,int length) throws IOException {
 	// The InputStream may start with a header that we need to skip
 	private void skipHeader() throws IOException {
 		// Skip all atoms preceding mdat atom
+		byte[] buffer = new byte[3];
 		while (true) {
 			while (is.read() != 'm');
-			is.read(buffer,rtphl,3);
-			if (buffer[rtphl] == 'd' && buffer[rtphl+1] == 'a' && buffer[rtphl+2] == 't') break;
+			is.read(buffer,0,3);
+			if (buffer[0] == 'd' && buffer[1] == 'a' && buffer[2] == 't') break;
 		}
 	}
 
diff --git a/src/net/majorkernelpanic/streaming/rtp/H264Packetizer.java b/src/net/majorkernelpanic/streaming/rtp/H264Packetizer.java
index 58095e0..b47b41e 100644
--- a/src/net/majorkernelpanic/streaming/rtp/H264Packetizer.java
+++ b/src/net/majorkernelpanic/streaming/rtp/H264Packetizer.java
@@ -34,7 +34,7 @@
  *   The stream must start with mpeg4 or 3gpp header, it will be skipped.
  *   
  */
-public class H264Packetizer extends AbstractPacketizer implements Runnable{
+public class H264Packetizer extends AbstractPacketizer implements Runnable {
 
 	public final static String TAG = "H264Packetizer";
 
@@ -42,11 +42,12 @@ public class H264Packetizer extends AbstractPacketizer implements Runnable{
 
 	private Thread t = null;
 	private int naluLength = 0;
-	private long delay = 0;
+	private long delay = 0, oldtime = 0;
 	private Statistics stats = new Statistics();
 
 	public H264Packetizer() throws IOException {
 		super();
+		socket.setClockFrequency(90);
 	}
 
 	public void start() throws IOException {
@@ -57,23 +58,24 @@ public void start() throws IOException {
 	}
 
 	public void stop() {
-		try {
-			is.close();
-		} catch (IOException ignore) {}
-		t.interrupt();
-		t = null;
+		if (t != null) {
+			t.interrupt();
+			try {
+				t.join(1000);
+			} catch (InterruptedException e) {}
+			t = null;
+		}
 	}
 
 	public void run() {
-
-		long duration = 0, oldtime = 0, sum = 0, start = 0, drift = 0, now, count = 0;
-		boolean initoffset = false;
-
+		long duration = 0;
+		Log.d(TAG,"H264 packetizer started !");
+		stats.reset();
 		// This will skip the MPEG4 header if this step fails we can't stream anything :(
 		try {
 			byte buffer[] = new byte[4];
 			// Skip all atoms preceding mdat atom
-			while (true) {
+			while (!Thread.interrupted()) {
 				while (is.read() != 'm');
 				is.read(buffer,0,3);
 				if (buffer[0] == 'd' && buffer[1] == 'a' && buffer[2] == 't') break;
@@ -83,8 +85,6 @@ public void run() {
 			return;
 		}
 
-		start = System.nanoTime();
-		
 		// We read a NAL units from the input stream and we send them
 		try {
 			while (!Thread.interrupted()) {
@@ -98,82 +98,72 @@ public void run() {
 				if (intervalBetweenReports>0) {
 					if (delta>=intervalBetweenReports) {
 						// We send a Sender Report
-						report.send(oldtime+duration,ts);
-					}
-				}
-				
-				count += duration/1000000;
-				if (count>=7000) {
-					// We estimate the drift of the steam
-					now = System.nanoTime();
-					if (!initoffset || (now - start < 0)) {
-						sum = (now - start);
-						initoffset = true;
+						report.send(oldtime+duration,ts*90/1000000);
 					}
-					drift = (now - start) - sum;
-					count = 0;
-					//Log.d(TAG, "sum1: "+sum/1000000+" sum2: "+(now-start)/1000000+" drift: "+drift/1000000);
 				}
-								
-				
-				if (drift!=0) {
-					// Compensates if the stream is drifting
-					stats.push(duration+drift);
-					drift = 0;
-				} else stats.push(duration);
+
+				stats.push(duration);
 				// Computes the average duration of a NAL unit
 				delay = stats.average();
-				sum += delay;
-				//Log.d(TAG,"duration: "+duration+" delay: "+delay);
+				//Log.d(TAG,"duration: "+duration/1000000+" delay: "+delay/1000000);
 
 			}
 		} catch (IOException e) {
-		} catch (InterruptedException e) {
-			e.printStackTrace();
-		}
+		} catch (InterruptedException e) {}
 
 		Log.d(TAG,"H264 packetizer stopped !");
 
 	}
 
-	// Reads a NAL unit in the FIFO and sends it
-	// If it is too big, we split it in FU-A units (RFC 3984)
+	/**
+	 * Reads a NAL unit in the FIFO and sends it.
+	 * If it is too big, we split it in FU-A units (RFC 3984).
+	 */
 	private void send() throws IOException, InterruptedException {
 		int sum = 1, len = 0, type;
+		byte[] header = new byte[5];
 
-		// Read NAL unit length (4 bytes)
-		fill(rtphl,4);
-		naluLength = buffer[rtphl+3]&0xFF | (buffer[rtphl+2]&0xFF)<<8 | (buffer[rtphl+1]&0xFF)<<16 | (buffer[rtphl]&0xFF)<<24;
+		// Read NAL unit length (4 bytes) and NAL unit header (1 byte)
+		fill(header,0,5);
+		naluLength = header[3]&0xFF | (header[2]&0xFF)<<8 | (header[1]&0xFF)<<16 | (header[0]&0xFF)<<24;
+		//naluLength = is.available();
 
-		// Read NAL unit header (1 byte)
-		fill(rtphl, 1);
-		// NAL unit type
-		type = buffer[rtphl]&0x1F;
+		if (naluLength>100000 || naluLength<0) resync();
 
-		ts += delay*9/100000;
-		socket.updateTimestamp(ts);
+		// Parses the NAL unit type
+		type = header[4]&0x1F;
 
-		//Log.d(TAG,"- Nal unit length: " + naluLength + " delay: "+delay+" type: "+type);
+		// Updates the timestamp
+		ts += delay;
+
+		//Log.d(TAG,"- Nal unit length: " + naluLength + " delay: "+delay/1000000+" type: "+type);
 
 		// Small NAL unit => Single NAL unit 
 		if (naluLength<=MAXPACKETSIZE-rtphl-2) {
-			len = fill(rtphl+1,  naluLength-1  );
+			buffer = socket.requestBuffer();
+			buffer[rtphl] = header[4];
+			len = fill(buffer, rtphl+1,  naluLength-1);
+			socket.updateTimestamp(ts);
 			socket.markNextPacket();
 			super.send(naluLength+rtphl);
-			//Log.d(TAG,"----- Single NAL unit - len:"+len+" header:"+printBuffer(rtphl,rtphl+3)+" delay: "+delay+" newDelay: "+newDelay);
+			//Log.d(TAG,"----- Single NAL unit - len:"+len+" delay: "+delay);
 		}
 		// Large NAL unit => Split nal unit 
 		else {
 
 			// Set FU-A header
-			buffer[rtphl+1] = (byte) (buffer[rtphl] & 0x1F);  // FU header type
-			buffer[rtphl+1] += 0x80; // Start bit
+			header[1] = (byte) (header[4] & 0x1F);  // FU header type
+			header[1] += 0x80; // Start bit
 			// Set FU-A indicator
-			buffer[rtphl] = (byte) ((buffer[rtphl] & 0x60) & 0xFF); // FU indicator NRI
-			buffer[rtphl] += 28;
+			header[0] = (byte) ((header[4] & 0x60) & 0xFF); // FU indicator NRI
+			header[0] += 28;
 
 			while (sum < naluLength) {
-				if ((len = fill(rtphl+2,  naluLength-sum > MAXPACKETSIZE-rtphl-2 ? MAXPACKETSIZE-rtphl-2 : naluLength-sum  ))<0) return; sum += len;
+				buffer = socket.requestBuffer();
+				buffer[rtphl] = header[0];
+				buffer[rtphl+1] = header[1];
+				socket.updateTimestamp(ts);
+				if ((len = fill(buffer, rtphl+2,  naluLength-sum > MAXPACKETSIZE-rtphl-2 ? MAXPACKETSIZE-rtphl-2 : naluLength-sum  ))<0) return; sum += len;
 				// Last packet before next NAL
 				if (sum >= naluLength) {
 					// End bit on
@@ -182,13 +172,13 @@ private void send() throws IOException, InterruptedException {
 				}
 				super.send(len+rtphl+2);
 				// Switch start bit
-				buffer[rtphl+1] = (byte) (buffer[rtphl+1] & 0x7F); 
+				header[1] = (byte) (header[1] & 0x7F); 
 				//Log.d(TAG,"----- FU-A unit, sum:"+sum);
 			}
 		}
 	}
 
-	private int fill(int offset,int length) throws IOException {
+	private int fill(byte[] buffer, int offset,int length) throws IOException {
 		int sum = 0, len;
 
 		while (sum<length) {
@@ -203,4 +193,33 @@ private int fill(int offset,int length) throws IOException {
 
 	}
 
+	private void resync() throws IOException {
+		byte[] header = new byte[5];
+		int type;
+
+		Log.e(TAG,"Packetizer out of sync ! Let's try to fix that...");
+		
+		while (true) {
+
+			header[0] = header[1];
+			header[1] = header[2];
+			header[2] = header[3];
+			header[3] = header[4];
+			header[4] = (byte) is.read();
+
+			type = header[4]&0x1F;
+
+			if (type == 5 || type == 1) {
+				naluLength = header[3]&0xFF | (header[2]&0xFF)<<8 | (header[1]&0xFF)<<16 | (header[0]&0xFF)<<24;
+				if (naluLength>0 && naluLength<100000) {
+					oldtime = System.nanoTime();
+					Log.e(TAG,"A NAL unit may have been found in the bit stream !");
+					break;
+				}
+			}
+
+		}
+
+	}
+
 }
\ No newline at end of file
diff --git a/src/net/majorkernelpanic/streaming/rtp/MediaCodecInputStream.java b/src/net/majorkernelpanic/streaming/rtp/MediaCodecInputStream.java
new file mode 100644
index 0000000..308cd84
--- /dev/null
+++ b/src/net/majorkernelpanic/streaming/rtp/MediaCodecInputStream.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2011-2013 GUIGUI Simon, fyhertz@gmail.com
+ * 
+ * This file is part of Spydroid (http://code.google.com/p/spydroid-ipcamera/)
+ * 
+ * Spydroid is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This source code 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.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this source code; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+package net.majorkernelpanic.streaming.rtp;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+import android.annotation.SuppressLint;
+import android.media.MediaCodec;
+import android.media.MediaCodec.BufferInfo;
+import android.util.Log;
+
+/**
+ * An InputStream that uses data from a MediaCodec.
+ * The purpose of this class is to interface existing RTP packetizers of
+ * libstreaming with the new MediaCodec API. This class is not thread safe !  
+ */
+@SuppressLint("NewApi")
+public class MediaCodecInputStream extends InputStream {
+
+	public final String TAG = "MediaCodecInputStream"; 
+	
+	private MediaCodec mMediaCodec = null;
+	private BufferInfo mBufferInfo = new BufferInfo();
+	private ByteBuffer[] mBuffers = null;
+	private ByteBuffer mBuffer = null;
+	private int mIndex;
+	private boolean mClosed = false;
+	
+	public MediaCodecInputStream(MediaCodec mediaCodec) {
+		mMediaCodec = mediaCodec;
+		mBuffers = mMediaCodec.getOutputBuffers();
+	}
+	
+	@Override
+	public void close() {
+		mClosed = true;
+	}
+	
+	@Override
+	public int read() throws IOException {
+		return 0;
+	}
+	
+	@Override
+	public int read(byte[] buffer, int offset, int length) throws IOException {
+		int min;
+		
+		if (mClosed) throw new IOException("This InputStream was closed");
+		
+		if (mBuffer==null || mBufferInfo.size-mBuffer.position() <= 0) {
+			mIndex = -1;
+			while (!Thread.interrupted() && mIndex<0) {
+				mIndex = mMediaCodec.dequeueOutputBuffer(mBufferInfo, 20000);
+				if (mIndex>=0 ){
+					//Log.d(TAG,"Index: "+mIndex+" Time: "+mBufferInfo.presentationTimeUs+" size: "+mBufferInfo.size);
+					mBuffer = mBuffers[mIndex];
+					mBuffer.position(0);
+					mMediaCodec.releaseOutputBuffer(mIndex, false);
+				} else if (mIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
+					mBuffers = mMediaCodec.getOutputBuffers();
+				} else if (mIndex != MediaCodec.INFO_TRY_AGAIN_LATER) {
+					Log.e(TAG,"BOG: "+mIndex);
+				}
+			}			
+		}
+
+		min = length < mBufferInfo.size - mBuffer.position() ? length : mBufferInfo.size - mBuffer.position(); 
+		
+		mBuffer.get(buffer, offset, min);
+		
+		return min;
+		
+	}
+
+	public int available() {
+		if (mBuffer != null) return mBufferInfo.size - mBuffer.position();
+		else return 0;
+	}
+	
+	public BufferInfo getLastBufferInfo() {
+		return mBufferInfo;
+	}
+	
+}
diff --git a/src/net/majorkernelpanic/streaming/rtp/RtpSocket.java b/src/net/majorkernelpanic/streaming/rtp/RtpSocket.java
index 7b5393c..feffb42 100644
--- a/src/net/majorkernelpanic/streaming/rtp/RtpSocket.java
+++ b/src/net/majorkernelpanic/streaming/rtp/RtpSocket.java
@@ -24,120 +24,282 @@
 import java.net.DatagramPacket;
 import java.net.InetAddress;
 import java.net.MulticastSocket;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+
+import android.os.SystemClock;
+import android.util.Log;
 
 /**
  * A basic implementation of an RTP socket.
+ * It implements a buffering mechanism, relying on a FIFO of buffers and a Thread.
+ * That way, if a packetizer tries to send many packets too quickly, the FIFO will
+ * grow and packets will be sent one by one smoothly.
  */
-public class RtpSocket {
+public class RtpSocket implements Runnable {
+
+	public static final String TAG = "RtpSocket";
 
 	public static final int RTP_HEADER_LENGTH = 12;
 	public static final int MTU = 1500;
-	
-	private MulticastSocket usock;
-	private DatagramPacket upack;
 
-	private byte[] buffer = new byte[MTU];
-	private int seq = 0;
-	private boolean upts = false;
-	private int ssrc;
-	private int port = -1;
+	private MulticastSocket mSocket;
+	private DatagramPacket[] mPackets;
+	private byte[][] mBuffers;
+	private long[] mTimestamps;
+
+	private Semaphore mBufferRequested, mBufferCommitted;
+	private Thread mThread;
+
+	private long mCacheSize;
+	private long mClock = 0;
+	private long mOldTimestamp = 0;
+	private long mTime = 0, mOldTime = 0;
+	private long mBitRate = 0, mOctetCount = 0;
+	private int mSsrc, mSeq = 0, mPort = -1;
+	private int mBufferCount, mBufferIn, mBufferOut;
 
+	/**
+	 * This RTP socket implements a buffering mechanism relying on a FIFO of buffers and a Thread.
+	 * @throws IOException
+	 */
 	public RtpSocket() throws IOException {
 
-		/*							     Version(2)  Padding(0)					 					*/
-		/*									 ^		  ^			Extension(0)						*/
-		/*									 |		  |				^								*/
-		/*									 | --------				|								*/
-		/*									 | |---------------------								*/
-		/*									 | ||  -----------------------> Source Identifier(0)	*/
-		/*									 | ||  |												*/
-		buffer[0] = (byte) Integer.parseInt("10000000",2);
+		mCacheSize = 1000;
+		mBufferCount = 300; // TODO: reajust that when the FIFO is full 
+		mBufferIn = 0;
+		mBufferOut = 0;
+		mBuffers = new byte[mBufferCount][];
+		mPackets = new DatagramPacket[mBufferCount];
+		mTimestamps = new long[mBufferCount];
+		mBufferRequested = new Semaphore(mBufferCount);
+		mBufferCommitted = new Semaphore(0);
 
-		/* Payload Type */
-		buffer[1] = (byte) 96;
+		for (int i=0; i<mBufferCount; i++) {
 
-		/* Byte 2,3        ->  Sequence Number                   */
-		/* Byte 4,5,6,7    ->  Timestamp                         */
-		/* Byte 8,9,10,11  ->  Sync Source Identifier            */
+			mBuffers[i] = new byte[MTU];
+			mPackets[i] = new DatagramPacket(mBuffers[i], 1);
+
+			/*							     Version(2)  Padding(0)					 					*/
+			/*									 ^		  ^			Extension(0)						*/
+			/*									 |		  |				^								*/
+			/*									 | --------				|								*/
+			/*									 | |---------------------								*/
+			/*									 | ||  -----------------------> Source Identifier(0)	*/
+			/*									 | ||  |												*/
+			mBuffers[i][0] = (byte) Integer.parseInt("10000000",2);
+
+			/* Payload Type */
+			mBuffers[i][1] = (byte) 96;
+
+			/* Byte 2,3        ->  Sequence Number                   */
+			/* Byte 4,5,6,7    ->  Timestamp                         */
+			/* Byte 8,9,10,11  ->  Sync Source Identifier            */
+
+		}
 
-		usock = new MulticastSocket();
-		upack = new DatagramPacket(buffer, 1);
+		mSocket = new MulticastSocket();
+		mTime = mOldTime = SystemClock.elapsedRealtime();
 
 	}
 
+	/** Closes the underlying socket. */
 	public void close() {
-		usock.close();
+		mSocket.close();
 	}
 
+	/** Sets the SSRC of the stream. */
 	public void setSSRC(int ssrc) {
-		this.ssrc = ssrc; 
-		setLong(ssrc,8,12);
+		this.mSsrc = ssrc;
+		for (int i=0;i<mBufferCount;i++) {
+			setLong(mBuffers[i], ssrc,8,12);
+		}
 	}
 
+	/** Returns the SSRC of the stream. */
 	public int getSSRC() {
-		return ssrc;
+		return mSsrc;
 	}
 
-	public void setTimeToLive(int ttl) throws IOException {
-		usock.setTimeToLive(ttl);
+	/** Sets the clock frquency of the stream in kHz. */
+	public void setClockFrequency(long clock) {
+		mClock = clock;
 	}
 
-	public void setDestination(InetAddress dest, int dport) {
-		port = dport;
-		upack.setPort(dport);
-		upack.setAddress(dest);
+	/** Sets the temporal  */
+	public void setCacheSize(long cacheSize) {
+		mCacheSize = cacheSize;
+	}
+	
+	/** Sets the Time To Live of the UDP packets. */
+	public void setTimeToLive(int ttl) throws IOException {
+		mSocket.setTimeToLive(ttl);
 	}
 
-	/** Returns the buffer that you can directly modify before calling send. */
-	public byte[] getBuffer() {
-		return buffer;
+	/** Sets the destination address and to which the packets will be sent. */
+	public void setDestination(InetAddress dest, int dport) {
+		mPort = dport;
+		for (int i=0;i<mBufferCount;i++) {
+			mPackets[i].setPort(dport);
+			mPackets[i].setAddress(dest);
+		}
 	}
 
 	public int getPort() {
-		return port;
+		return mPort;
 	}
 
 	public int getLocalPort() {
-		return usock.getLocalPort();
+		return mSocket.getLocalPort();
+	}
+
+	/** 
+	 * Returns an available buffer from the FIFO, it can then directly be modified. 
+	 * Call {@link commitBuffer(int)} to send it over the network. 
+	 * @throws InterruptedException 
+	 **/
+	public byte[] requestBuffer() throws InterruptedException {
+		mBufferRequested.acquire();
+		mBuffers[mBufferIn][1] &= 0x7F;
+		return mBuffers[mBufferIn];
 	}
 
 	/** Sends the RTP packet over the network. */
-	public void send(int length) throws IOException {
+	public void commitBuffer(int length) throws IOException {
 
 		updateSequence();
-		upack.setLength(length);
-		usock.send(upack);
+		mPackets[mBufferIn].setLength(length);
+
+		mOctetCount += length;
+		mTime = SystemClock.elapsedRealtime();
+		if (mTime - mOldTime > 1000) {
+			mBitRate = mOctetCount*8000/(mTime-mOldTime);
+			mOctetCount = 0;
+			mOldTime = mTime;
+		}
+
+		mBufferCommitted.release();
+		if (++mBufferIn>=mBufferCount) mBufferIn = 0;
 
-		if (upts) {
-			upts = false;
-			buffer[1] -= 0x80;
+		if (mThread == null) {
+			mThread = new Thread(this);
+			mThread.start();
 		}
 
 	}
 
+	/** Returns an approximation of the bitrate of the RTP stream in bit per seconde. */
+	public long getBitrate() {
+		return mBitRate;
+	}
+
 	/** Increments the sequence number. */
 	private void updateSequence() {
-		setLong(++seq, 2, 4);
+		setLong(mBuffers[mBufferIn], ++mSeq, 2, 4);
 	}
 
 	/** 
 	 * Overwrites the timestamp in the packet.
-	 * @param timestamp The new timestamp
+	 * @param timestamp The new timestamp in ns.
 	 **/
 	public void updateTimestamp(long timestamp) {
-		setLong(timestamp, 4, 8);
+		mTimestamps[mBufferIn] = timestamp;
+		setLong(mBuffers[mBufferIn], timestamp*mClock/1000000, 4, 8);
 	}
 
+	/** Sets the marker in the RTP packet. */
 	public void markNextPacket() {
-		upts = true;
-		buffer[1] += 0x80; // Mark next packet
+		mBuffers[mBufferIn][1] |= 0x80;
+	}
+
+	/** The Thread sends the packets in the FIFO one by one at a constant rate. */
+	@Override
+	public void run() {
+		Statistics stats = new Statistics(10,100);
+		long delta = 0;
+		try {
+			// Caches mCacheSize milliseconds of the stream in the FIFO.
+			Thread.sleep(mCacheSize);
+			while (mBufferCommitted.tryAcquire(4,TimeUnit.SECONDS)) {
+				if (mOldTimestamp != 0) {
+					// We use our knowledge of the clock rate of the stream and the difference between to timestamp to
+					// compute the temporal length of the packet.
+					stats.push(mTimestamps[mBufferOut]-mOldTimestamp);
+					// We ensure that packets are sent at a constant and suitable rate no matter how the RtpSocket is used.
+					long d = stats.average()/1000000;
+					//Log.d(TAG,"delay: "+d);
+					Thread.sleep(d);
+					delta += mTimestamps[mBufferOut]-mOldTimestamp;
+					if (delta>500000000) {
+						Log.d(TAG,"permits: "+mBufferCommitted.availablePermits());
+						delta = 0;
+					}
+				}
+				mOldTimestamp = mTimestamps[mBufferOut];
+				mSocket.send(mPackets[mBufferOut]);
+				if (++mBufferOut>=mBufferCount) mBufferOut = 0;
+				mBufferRequested.release();
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		mThread = null;
 	}
 
-	private void setLong(long n, int begin, int end) {
+	private void setLong(byte[] buffer, long n, int begin, int end) {
 		for (end--; end >= begin; end--) {
 			buffer[end] = (byte) (n % 256);
 			n >>= 8;
 		}
-	}	
+	}
+	
+	/** Computes the proper rate at which packets are sent. */
+	public static class Statistics {
+
+		public final static String TAG = "Statistics";
+		
+		private int count=500, c = 0;
+		private float m = 0, q = 0;
+		private long elapsed = 0;
+		private long start = 0;
+		private long duration = 0;
+		private long period = 6000000000L;
+		private boolean initoffset = false;
+
+		public Statistics(int count, int period) {
+			this.count = count;
+			this.period = period*1000000; 
+		}
+		
+		public void push(long value) {
+			duration += value;
+			elapsed += value;
+			if (elapsed>period) {
+				elapsed = 0;
+				long now = System.nanoTime();
+				if (!initoffset || (now - start < 0)) {
+					start = now;
+					duration = 0;
+					initoffset = true;
+				}
+				value -= (now - start) - duration;
+				Log.d(TAG, "sum1: "+duration/1000000+" sum2: "+(now-start)/1000000+" drift: "+((now-start)-duration)/1000000+" v: "+value/1000000);
+			}
+			if (c<20) {
+				// We ignore the first 20 measured values because they may not be accurate
+				c++;
+				m = value;
+			} else {
+				m = (m*q+value)/(q+1);
+				if (q<count) q++;
+			}
+		}
+		
+		public long average() {
+			long l = (long)m;
+			return l>0 ? l : 0;
+		}
+
+	}
 
 }
diff --git a/src/net/majorkernelpanic/streaming/rtsp/RtspClient.java b/src/net/majorkernelpanic/streaming/rtsp/RtspClient.java
new file mode 100644
index 0000000..0b0c084
--- /dev/null
+++ b/src/net/majorkernelpanic/streaming/rtsp/RtspClient.java
@@ -0,0 +1,363 @@
+/*
+ * Copyright (C) 2011-2013 GUIGUI Simon, fyhertz@gmail.com
+ * 
+ * This file is part of Spydroid (http://code.google.com/p/spydroid-ipcamera/)
+ * 
+ * Spydroid is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This source code 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.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this source code; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+package net.majorkernelpanic.streaming.rtsp;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import net.majorkernelpanic.streaming.Session;
+import net.majorkernelpanic.streaming.SessionBuilder;
+import net.majorkernelpanic.streaming.Stream;
+import android.util.Log;
+
+/**
+ * RFC 2326.
+ * A basic and synchronous RTSP client.
+ * The original purpose of this class was to implement a small RTSP client compatible with Wowza.
+ * It implements Digest Access Authentication according to RFC 2069. 
+ */
+public class RtspClient {
+
+	public final static String TAG = "RtspClient";
+
+	private Socket mSocket;
+	private String mHost;
+	private String mUsername;
+	private String mPassword;
+	private String mPath;
+	private String mSessionID;
+	private String mAuthorization;
+	private Session mSession;
+	private BufferedReader mBufferedReader;
+	private OutputStream mOutputStream;
+	private int mCSeq, mPort;
+	private boolean mRunning;
+
+	public RtspClient() {
+		mCSeq = 0;
+		mPort = 1935;
+		mPath = "/";
+		mAuthorization = null;
+		mRunning = false;
+	}
+
+	/**
+	 * The {@link Session} that will be used to stream to the server.
+	 * If not called before {@link #startStream(int)}, a it will be created.
+	 */
+	public void setSession(Session session) {
+		mSession = session;
+	}
+
+	/**
+	 * Sets the destination address of the RTSP server.
+	 * @param host The destination address
+	 * @param port The destination port
+	 */
+	public void setServerAddress(String host, int port) {
+		mPort = port;
+		mHost = host;
+	}
+
+	/**
+	 * If authentication is enabled on the server, you need to call this with a valid username/password pair.
+	 * Only implements Digest Access Authentication according to RFC 2069.
+	 * @param username The username
+	 * @param password The password
+	 */
+	public void setCredentials(String username, String password) {
+		mUsername = username;
+		mPassword = password;
+	}
+
+	/**
+	 * The path to which the stream will be sent to. 
+	 * @param path The path
+	 */
+	public void setStreamPath(String path) {
+		mPath = path;
+	}
+
+	public synchronized boolean isRunning() {
+		return mRunning;
+	}
+	
+	/**
+	 * Connects to the RTSP server to publish the stream, and the effectively starts streaming.
+	 * You need to call {@link #setServerAddress(String, int)} and optionnally {@link #setSession(Session)} 
+	 * and {@link #setCredentials(String, String)} before calling this.
+	 * Should be called of the main thread !
+	 * @param retries The number of retries that will be
+	 * @throws RuntimeException Thrown if wrong credentials have been provided, or if an error occurs with {@link Session#start()}
+	 * @throws IllegalStateException Thrown if {@link #setServerAddress(String, int)} was never called, if the server requires authentication of the client, or if an error occurs with {@link Session#start()} 
+	 * @throws UnknownHostException Thrown if the hostname specified with {@link #setServerAddress(String, int)} can't be resolved
+	 * @throws IOException Thrown if an error occurs with {@link Session#start()}
+	 */
+	public synchronized void startStream(int retries) throws RuntimeException, IllegalStateException, UnknownHostException, IOException {
+
+		if (mRunning) return;
+		if (mHost == null) throw new IllegalStateException("setServerAddress(String,int) has not been called !");
+		if (mSession == null) mSession = SessionBuilder.getInstance().build();
+
+		mSocket = new Socket(mHost, mPort);
+		mBufferedReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream()));
+		mOutputStream = mSocket.getOutputStream();
+		mSession.setDestination(InetAddress.getByName(mHost));
+
+		sendRequestAnnounce();
+		sendRequestSetup();
+		sendRequestRecord();
+
+		try {
+			mSession.start();
+		} catch (RuntimeException e) {
+			stopStream();
+			throw e;
+		} catch (IOException e) {
+			stopStream();
+			throw e;
+		}
+		
+		mRunning = true;
+
+	}
+
+	/**
+	 * Stops the stream, and informs the RTSP server.
+	 */
+	public synchronized void stopStream() {
+
+		if (!mRunning) return;
+		
+		try {
+			sendRequestTeardown();
+		} catch (Exception ignore) {}
+		try {
+			mSocket.close();
+		} catch (Exception ignore) {}
+
+		mSession.stop();
+		mRunning = false;
+	}
+
+	/**
+	 * Forges and sends the ANNOUNCE request 
+	 */
+	private void sendRequestAnnounce() throws IllegalStateException, SocketException, IOException {
+
+		String body = mSession.getSessionDescription();
+		String request = "ANNOUNCE rtsp://"+mHost+":"+mPort+mPath+" RTSP/1.0\r\n" +
+				"CSeq: " + (++mCSeq) + "\r\n" +
+				"Content-Length: " + body.length() + "\r\n" +
+				"Content-Type: application/sdp \r\n\r\n" +
+				body;
+
+		Log.i(TAG,request.substring(0, request.indexOf("\r\n")));
+
+		mOutputStream.write(request.getBytes("UTF-8"));
+		Response response = Response.parseResponse(mBufferedReader);
+
+		try {
+			Matcher m = Response.rexegSession.matcher(response.headers.get("session")); m.find();
+			mSessionID = m.group(1);
+		} catch (Exception e) {
+			throw new IOException("Invalid response from server");
+		}
+
+		if (response.status == 401) {
+			String nonce, realm;
+			Matcher m;
+
+			if (mUsername == null || mPassword == null) throw new IllegalStateException("Authentication is enabled and setCredentials(String,String) was not called !");
+
+			try {
+				m = Response.rexegAuthenticate.matcher(response.headers.get("www-authenticate")); m.find();
+				nonce = m.group(2);
+				realm = m.group(1);
+			} catch (Exception e) {
+				throw new IOException("Invalid response from server");
+			}
+
+			String uri = "rtsp://"+mHost+":"+mPort+mPath;
+			String hash1 = computeMd5Hash(mUsername+":"+m.group(1)+":"+mPassword);
+			String hash2 = computeMd5Hash("ANNOUNCE"+":"+uri);
+			String hash3 = computeMd5Hash(hash1+":"+m.group(2)+":"+hash2);
+
+			mAuthorization = "Digest username=\""+mUsername+"\",realm=\""+realm+"\",nonce=\""+nonce+"\",uri=\""+uri+"\",response=\""+hash3+"\"\r\n";
+
+			request = "ANNOUNCE rtsp://"+mHost+":"+mPort+mPath+" RTSP/1.0\r\n" +
+					"CSeq: " + (++mCSeq) + "\r\n" +
+					"Content-Length: " + body.length() + "\r\n" +
+					"Authorization: " + mAuthorization +
+					"Session: " + mSessionID + "\r\n" +
+					"Content-Type: application/sdp \r\n\r\n" +
+					body;
+
+			Log.i(TAG,request.substring(0, request.indexOf("\r\n")));
+
+			mOutputStream.write(request.getBytes("UTF-8"));
+			response = Response.parseResponse(mBufferedReader);
+
+			if (response.status == 401) throw new RuntimeException("Bad credentials !");
+
+		}
+
+	}
+
+	/**
+	 * Forges and sends the SETUP request 
+	 */
+	private void sendRequestSetup() throws IllegalStateException, SocketException, IOException {
+		for (int i=0;i<2;i++) {
+			Stream stream = mSession.getTrack(i);
+			if (stream != null) {
+				String request = "SETUP rtsp://"+mHost+":"+mPort+mPath+"/trackID="+i+" RTSP/1.0\r\n" +
+						"CSeq: " + (++mCSeq) + "\r\n" +
+						"Transport: RTP/AVP/UDP;unicast;client_port="+(5000+2*i)+"-"+(5000+2*i+1)+";mode=receive\r\n" +
+						"Session: " + mSessionID + "\r\n" +
+						"Authorization: " + mAuthorization+ "\r\n";
+
+				Log.i(TAG,request.substring(0, request.indexOf("\r\n")));
+
+				mOutputStream.write(request.getBytes("UTF-8"));
+				Response response = Response.parseResponse(mBufferedReader);
+
+				Matcher m;
+				try {
+					m = Response.rexegTransport.matcher(response.headers.get("transport")); m.find();
+					stream.setDestinationPorts(Integer.parseInt(m.group(3)), Integer.parseInt(m.group(4)));
+				} catch (Exception e) {
+					e.printStackTrace();
+					int[] ports = stream.getDestinationPorts();
+					Log.d(TAG,"Server did not specify ports, using default ports: "+ports[0]+"-"+ports[1]);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Forges and sends the RECORD request 
+	 */
+	private void sendRequestRecord() throws IllegalStateException, SocketException, IOException {
+		String request = "RECORD rtsp://"+mHost+":"+mPort+mPath+" RTSP/1.0\r\n" +
+				"Range: npt=0.000-" +
+				"CSeq: " + (++mCSeq) + "\r\n" +
+				"Session: " + mSessionID + "\r\n" +
+				"Authorization: " + mAuthorization+ "\r\n";
+		Log.i(TAG,request.substring(0, request.indexOf("\r\n")));
+		mOutputStream.write(request.getBytes("UTF-8"));
+		Response.parseResponse(mBufferedReader);
+	}
+	
+	/**
+	 * Forges and sends the TEARDOWN request 
+	 */
+	private void sendRequestTeardown() throws IOException {
+		String request = "TEARDOWN rtsp://"+mHost+":"+mPort+mPath+" RTSP/1.0\r\n" +
+				"CSeq: " + (++mCSeq) + "\r\n" +
+				"Session: " + mSessionID + "\r\n" +
+				"Authorization: " + mAuthorization+ "\r\n";
+		Log.i(TAG,request.substring(0, request.indexOf("\r\n")));
+		mOutputStream.write(request.getBytes("UTF-8"));
+		Response.parseResponse(mBufferedReader);
+	}
+
+	final protected static char[] hexArray = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
+
+	private static String bytesToHex(byte[] bytes) {
+		char[] hexChars = new char[bytes.length * 2];
+		int v;
+		for ( int j = 0; j < bytes.length; j++ ) {
+			v = bytes[j] & 0xFF;
+			hexChars[j * 2] = hexArray[v >>> 4];
+			hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+		}
+		return new String(hexChars);
+	}
+
+	private String computeMd5Hash(String buffer) {
+		MessageDigest md;
+		try {
+			md = MessageDigest.getInstance("MD5");
+			return bytesToHex(md.digest(buffer.getBytes("UTF-8")));
+		} catch (NoSuchAlgorithmException ignore) {
+		} catch (UnsupportedEncodingException e) {}
+		return "";
+	}
+
+	static class Response {
+
+		// Parses method & uri
+		public static final Pattern regexStatus = Pattern.compile("RTSP/\\d.\\d (\\d+) (\\w+)",Pattern.CASE_INSENSITIVE);
+		// Parses a request header
+		public static final Pattern rexegHeader = Pattern.compile("(\\S+):(.+)",Pattern.CASE_INSENSITIVE);
+		// Parses a WWW-Authenticate header
+		public static final Pattern rexegAuthenticate = Pattern.compile("realm=\"(.+)\",\\s+nonce=\"(\\w+)\"",Pattern.CASE_INSENSITIVE);
+		// Parses a Session header
+		public static final Pattern rexegSession = Pattern.compile("(\\d+);",Pattern.CASE_INSENSITIVE);
+		// Parses a Transport header
+		public static final Pattern rexegTransport = Pattern.compile("client_port=(\\d+)-(\\d+).+server_port=(\\d+)-(\\d+)",Pattern.CASE_INSENSITIVE);
+
+
+		public int status;
+		public HashMap<String,String> headers = new HashMap<String,String>();
+
+		/** Parse the method, uri & headers of a RTSP request */
+		public static Response parseResponse(BufferedReader input) throws IOException, IllegalStateException, SocketException {
+			Response response = new Response();
+			String line;
+			Matcher matcher;
+
+			// Parsing request method & uri
+			if ((line = input.readLine())==null) throw new SocketException("Connection lost");
+			matcher = regexStatus.matcher(line);
+			matcher.find();
+			response.status = Integer.parseInt(matcher.group(1));
+
+			// Parsing headers of the request
+			while ( (line = input.readLine()) != null && line.length()>3 ) {
+				matcher = rexegHeader.matcher(line);
+				matcher.find();
+				response.headers.put(matcher.group(1).toLowerCase(Locale.US),matcher.group(2));
+			}
+			if (line==null) throw new SocketException("Connection lost");
+
+			// It's not an error, it's just easier to follow what's happening in logcat with the request in red
+			Log.d(TAG, "Response from server: "+response.status);
+
+			return response;
+		}
+	}
+
+}
diff --git a/src/net/majorkernelpanic/streaming/rtsp/RtspServer.java b/src/net/majorkernelpanic/streaming/rtsp/RtspServer.java
index abacbdc..ca56d50 100644
--- a/src/net/majorkernelpanic/streaming/rtsp/RtspServer.java
+++ b/src/net/majorkernelpanic/streaming/rtsp/RtspServer.java
@@ -116,6 +116,11 @@ public interface CallbackListener {
 	 */
 	public void addCallbackListener(CallbackListener listener) {
 		synchronized (mListeners) {
+			if (mListeners.size() > 0) {
+				for (CallbackListener cl : mListeners) {
+					if (cl == listener) return;
+				}
+			}
 			mListeners.add(listener);			
 		}
 	}
@@ -181,6 +186,7 @@ public void stop() {
 		}
 	}
 
+	/** Returns whether or not the RTSP server is streaming to some client(s). */
 	public boolean isStreaming() {
 		for ( Session session : mSessions.keySet() ) {
 		    if ( session != null ) {
@@ -193,6 +199,17 @@ public boolean isStreaming() {
 	public boolean isEnabled() {
 		return mEnabled;
 	}
+
+	/** Returns the bandwidth consumed by the RTSP server in bits per second. */
+	public long getBitrate() {
+		long bitrate = 0;
+		for ( Session session : mSessions.keySet() ) {
+		    if ( session != null ) {
+		    	if (session.isStreaming()) bitrate += session.getBitrate();
+		    } 
+		}
+		return bitrate;
+	}
 	
 	@Override
 	public int onStartCommand(Intent intent, int flags, int startId) {
diff --git a/src/net/majorkernelpanic/streaming/video/H264Stream.java b/src/net/majorkernelpanic/streaming/video/H264Stream.java
index 6969922..4aa5913 100644
--- a/src/net/majorkernelpanic/streaming/video/H264Stream.java
+++ b/src/net/majorkernelpanic/streaming/video/H264Stream.java
@@ -80,7 +80,7 @@ public void setPreferences(SharedPreferences prefs) {
 	 * Returns a description of the stream using SDP. It can then be included in an SDP file.
 	 * Will fail if called when streaming.
 	 */
-	public String generateSessionDescription() throws IllegalStateException, IOException {
+	public synchronized  String generateSessionDescription() throws IllegalStateException, IOException {
 		MP4Config config = testH264();
 
 		return "m=video "+String.valueOf(getDestinationPorts()[0])+" RTP/AVP 96\r\n" +
@@ -110,10 +110,27 @@ private MP4Config testH264() throws IllegalStateException, IOException {
 		boolean savedFlashState = mFlashState;
 		mFlashState = false;
 
-		// That means the H264Stream will behave as a regular MediaRecorder object
-		// it will not start the packetizer thread and can be used to save video in a file
-		setMode(MODE_DEFAULT);
+		// Opens the camera if needed
+		if (mCamera == null) {
+			mCameraOpenedManually = false;
+		}
+
+		// Will start the preview if not already started !
+		startPreview();
 
+		unlockCamera();
+		
+		mMediaRecorder = new MediaRecorder();
+		mMediaRecorder.setCamera(mCamera);
+		mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+		mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+		mMediaRecorder.setMaxDuration(1000);
+		mMediaRecorder.setMaxFileSize(Integer.MAX_VALUE);
+		mMediaRecorder.setVideoEncoder(mVideoEncoder);
+		mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
+		mMediaRecorder.setVideoSize(mQuality.resX,mQuality.resY);
+		mMediaRecorder.setVideoFrameRate(mQuality.framerate);
+		mMediaRecorder.setVideoEncodingBitRate(mQuality.bitrate);
 		mMediaRecorder.setOutputFile(TESTFILE);
 
 		// We wait a little and stop recording
@@ -134,8 +151,8 @@ public void onInfo(MediaRecorder mr, int what, int extra) {
 		});
 
 		// Start recording
-		prepare();
-		start();
+		mMediaRecorder.prepare();
+		mMediaRecorder.start();
 
 		try {
 			if (mLock.tryAcquire(6,TimeUnit.SECONDS)) {
@@ -147,15 +164,12 @@ public void onInfo(MediaRecorder mr, int what, int extra) {
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		} finally {
-			stop();
-			setMode(MODE_STREAMING);
+			mMediaRecorder.stop();
+			mMediaRecorder.release();
+			mMediaRecorder = null;
+			lockCamera();
 		}
 
-		// Disable the callback
-		try {
-			mMediaRecorder.setOnInfoListener(null);
-		} catch (Exception ignore) {}
-
 		// Retrieve SPS & PPS & ProfileId with MP4Config
 		MP4Config config = new MP4Config(TESTFILE);
 
diff --git a/src/net/majorkernelpanic/streaming/video/VideoStream.java b/src/net/majorkernelpanic/streaming/video/VideoStream.java
index 2dc9328..feda71d 100644
--- a/src/net/majorkernelpanic/streaming/video/VideoStream.java
+++ b/src/net/majorkernelpanic/streaming/video/VideoStream.java
@@ -21,11 +21,22 @@
 package net.majorkernelpanic.streaming.video;
 
 import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+import java.util.List;
 
 import net.majorkernelpanic.streaming.MediaStream;
+import net.majorkernelpanic.streaming.rtp.MediaCodecInputStream;
+import android.annotation.SuppressLint;
+import android.graphics.ImageFormat;
 import android.hardware.Camera;
 import android.hardware.Camera.CameraInfo;
 import android.hardware.Camera.Parameters;
+import android.hardware.Camera.Size;
+import android.media.MediaCodec;
+import android.media.MediaCodecInfo;
+import android.media.MediaCodecList;
+import android.media.MediaFormat;
 import android.media.MediaRecorder;
 import android.util.Log;
 import android.view.SurfaceHolder;
@@ -41,9 +52,12 @@ public abstract class VideoStream extends MediaStream {
 	protected VideoQuality mQuality = VideoQuality.defaultVideoQualiy.clone();
 	protected SurfaceHolder.Callback mSurfaceHolderCallback = null;
 	protected SurfaceHolder mSurfaceHolder = null;
-	protected boolean mFlashState = false,  mQualityHasChanged = false;
 	protected int mVideoEncoder, mCameraId = 0;
 	protected Camera mCamera;
+	protected boolean mCameraOpenedManually = true;
+	protected boolean mFlashState = false;
+	protected boolean mSurfaceReady = false;
+	protected boolean mUnlocked = false;
 
 	/** 
 	 * Don't use this class directly.
@@ -52,7 +66,7 @@ public abstract class VideoStream extends MediaStream {
 	public VideoStream() {
 		this(CameraInfo.CAMERA_FACING_BACK);
 	}	
-	
+
 	/** 
 	 * Don't use this class directly
 	 * @param camera Can be either CameraInfo.CAMERA_FACING_BACK or CameraInfo.CAMERA_FACING_FRONT
@@ -66,7 +80,7 @@ public VideoStream(int camera) {
 	 * Sets the camera that will be used to capture video.
 	 * You can call this method at any time and changes will take effect next time you call {@link #prepare()}.
 	 * @param camera Can be either CameraInfo.CAMERA_FACING_BACK or CameraInfo.CAMERA_FACING_FRONT
-	 */	
+	 */
 	public void setCamera(int camera) {
 		CameraInfo cameraInfo = new CameraInfo();
 		int numberOfCameras = Camera.getNumberOfCameras();
@@ -78,41 +92,112 @@ public void setCamera(int camera) {
 			}
 		}
 	}
-	
+
+	/**	Switch between the front facing and the back facing camera of the phone. 
+	 * If {@link startPreview()} has been called, the preview will be  briefly interrupted. 
+	 * If {@link start()} has been called, the stream will be  briefly interrupted.
+	 * You should not call this method from the main thread if you are already streaming. 
+	 * @throws IOException 
+	 * @throws RuntimeException 
+	 **/
+	public void switchCamera() throws RuntimeException, IOException {
+		if (Camera.getNumberOfCameras() == 1) throw new IllegalStateException("Phone only has one camera !");
+		boolean streaming = mStreaming;
+		boolean previewing = mCamera!=null && mCameraOpenedManually; 
+		mCameraId = (mCameraId == CameraInfo.CAMERA_FACING_BACK) ? CameraInfo.CAMERA_FACING_FRONT : CameraInfo.CAMERA_FACING_BACK; 
+		setCamera(mCameraId);
+		stopPreview();
+		if (previewing) startPreview();
+		if (streaming) start(); 
+	}
+
+	public int getCamera() {
+		return mCameraId;
+	}
+
 	/**
 	 * Sets a Surface to show a preview of recorded media (video). 
 	 * You can call this method at any time and changes will take effect next time you call {@link #prepare()}.
 	 */
-	public void setPreviewDisplay(SurfaceHolder surfaceHolder) {
+	public synchronized void setPreviewDisplay(SurfaceHolder surfaceHolder) {
 		if (mSurfaceHolderCallback != null && mSurfaceHolder != null) {
 			mSurfaceHolder.removeCallback(mSurfaceHolderCallback);
 		}
-		mSurfaceHolderCallback = new Callback() {
-			@Override
-			public void surfaceDestroyed(SurfaceHolder holder) {
-				if (VideoStream.this.isStreaming()) {
-					VideoStream.this.stop();
-					Log.d(TAG,"Surface destroyed: video streaming stopped.");
+		if (surfaceHolder != null) {
+			mSurfaceHolderCallback = new Callback() {
+				@Override
+				public void surfaceDestroyed(SurfaceHolder holder) {
+					mSurfaceReady = false;
+					if (VideoStream.this.mStreaming) {
+						VideoStream.this.stop();
+						Log.d(TAG,"Surface destroyed: video streaming stopped.");
+					}
+					if (mCamera != null) stopPreview();
+				}
+				@Override
+				public void surfaceCreated(SurfaceHolder holder) {
+					mSurfaceReady = true;
 				}
+				@Override
+				public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+					Log.d(TAG,"Surface Changed !");
+				}
+			};
+			mSurfaceHolder = surfaceHolder;
+			mSurfaceHolder.addCallback(mSurfaceHolderCallback);
+			mSurfaceReady = true;
+		}
+	}
+
+	/** Turns the LED on or off if phone has one. */
+	public synchronized void setFlashState(boolean state) {
+
+		// FIXME: Is it possible to toggle the flash while streaming on android 2.3 ?
+		// FIXME: It works on android 4.2 and 4.3
+		
+		mFlashState = state;
+
+		// If the camera has already been opened, we apply the change immediately
+		// FIXME: Will this work on Android 2.3 ?
+		if (mCamera != null) {
+
+			// Needed on Android 2.3
+			if (mStreaming && mMode == MODE_STREAMING_LEGACY) {
+				lockCamera();
 			}
-			@Override
-			public void surfaceCreated(SurfaceHolder holder) {
-				
+
+			Parameters parameters = mCamera.getParameters();
+
+			// We test if the phone has a flash
+			if (parameters.getFlashMode()==null) {
+				// The phone has no flash or the choosen camera can not toggle the flash
+				throw new RuntimeException("Can't turn the flash on !");
+			} else {
+				parameters.setFlashMode(mFlashState?Parameters.FLASH_MODE_TORCH:Parameters.FLASH_MODE_OFF);
+				try {
+					mCamera.setParameters(parameters);
+				} catch (RuntimeException e) {
+					throw new RuntimeException("Can't turn the flash on !");	
+				}
 			}
-			@Override
-			public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
-				
+
+			// Needed on Android 2.3
+			if (mStreaming && mMode == MODE_STREAMING_LEGACY) {
+				unlockCamera();
 			}
-		};
-		mSurfaceHolder = surfaceHolder;
-		mSurfaceHolder.addCallback(mSurfaceHolderCallback);
+
+		}
 	}
 
-	/** Turns the LED on or off if phone has one. */
-	public void setFlashState(boolean state) {
-		mFlashState = state;
+	/** Toggle the LED of the phone if it has one. */
+	public void toggleFlash() {
+		setFlashState(!mFlashState);
 	}
-	
+
+	public boolean getFlashState() {
+		return mFlashState;
+	}
+
 	/** 
 	 * Modifies the resolution of the stream. You can call this method at any time 
 	 * and changes will take effect next time you call {@link #prepare()}.
@@ -124,7 +209,6 @@ public void setVideoSize(int width, int height) {
 		if (mQuality.resX != width || mQuality.resY != height) {
 			mQuality.resX = width;
 			mQuality.resY = height;
-			mQualityHasChanged = true;
 		}
 	}
 
@@ -137,7 +221,6 @@ public void setVideoSize(int width, int height) {
 	public void setVideoFramerate(int rate) {
 		if (mQuality.framerate != rate) {
 			mQuality.framerate = rate;
-			mQualityHasChanged = true;
 		}
 	}
 
@@ -150,7 +233,6 @@ public void setVideoFramerate(int rate) {
 	public void setVideoEncodingBitrate(int bitrate) {
 		if (mQuality.bitrate != bitrate) {
 			mQuality.bitrate = bitrate;
-			mQualityHasChanged = true;
 		}
 	}
 
@@ -162,7 +244,6 @@ public void setVideoEncodingBitrate(int bitrate) {
 	public void setVideoQuality(VideoQuality videoQuality) {
 		if (!mQuality.equals(videoQuality)) {
 			mQuality = videoQuality;
-			mQualityHasChanged = true;
 		}
 	}
 
@@ -174,39 +255,27 @@ public void setVideoQuality(VideoQuality videoQuality) {
 	protected void setVideoEncoder(int videoEncoder) {
 		this.mVideoEncoder = videoEncoder;
 	}
-	
+
 	/** Stops the stream. */
 	public synchronized void stop() {
+		if (mMode == MODE_STREAMING_JB) {
+			mCamera.setPreviewCallback(null);
+		}
 		super.stop();
-		if (mCamera != null) {
-			try {
-				mCamera.reconnect();
-			} catch (Exception e) {
-				Log.e(TAG,e.getMessage()!=null?e.getMessage():"unknown error");
-			}
-			mCamera.stopPreview();
-			try {
-				mCamera.release();
-			} catch (Exception e) {
-				Log.e(TAG,e.getMessage()!=null?e.getMessage():"unknown error");
-			}
-			mCamera = null;
+		if (mMode == MODE_STREAMING_LEGACY) {
+			lockCamera();
+		}
+		if (!mCameraOpenedManually) {
+			stopPreview();
 		}
+		mCameraOpenedManually = true;
 	}
 
-	/**
-	 * Prepare the VideoStream, you can then call {@link #start()}.
-	 * The underlying Camera will be opened and configured when you call this method so don't forget to deal with the RuntimeExceptions !
-	 * Camera.open, Camera.setParameter, Camera.unlock may throw one !
-	 */
-	public void prepare() throws IllegalStateException, IOException {
-		
-		// Resets the recorder in case it is in a bad state
-		mMediaRecorder.reset();
-		
-		if (mSurfaceHolder == null || mSurfaceHolder.getSurface() == null || !mSurfaceHolder.getSurface().isValid()) 
+	public synchronized void startPreview() throws RuntimeException, IOException {
+
+		if (mSurfaceHolder == null || mSurfaceHolder.getSurface() == null || !mSurfaceReady)
 			throw new IllegalStateException("Invalid surface holder !");
-		
+
 		if (mCamera == null) {
 			mCamera = Camera.open(mCameraId);
 			mCamera.setErrorCallback(new Camera.ErrorCallback() {
@@ -218,79 +287,253 @@ public void onError(int error, Camera camera) {
 						// In this case the application must release the camera and instantiate a new one
 						Log.e(TAG,"Media server died !");
 						// We don't know in what thread we are so stop needs to be synchronized
+						mCameraOpenedManually = false;
 						stop();
 					} else {
 						Log.e(TAG,"Error unknown with the camera: "+error);
 					}	
 				}
 			});
-		}
-
-		// If an exception is thrown after the camera was open, we must absolutly release it !
-		try {
 
 			Parameters parameters = mCamera.getParameters();
+
+			if (mMode == MODE_STREAMING_JB) {
+				getClosestSupportedQuality(parameters);
+				parameters.setPreviewFormat(ImageFormat.YV12);
+				parameters.setPreviewSize(mQuality.resX, mQuality.resY);
+				parameters.setPreviewFrameRate(mQuality.framerate);
+			}
+
 			if (mFlashState) {
 				if (parameters.getFlashMode()==null) {
 					// The phone has no flash or the choosen camera can not toggle the flash
 					throw new IllegalStateException("Can't turn the flash on !");
 				} else {
 					parameters.setFlashMode(mFlashState?Parameters.FLASH_MODE_TORCH:Parameters.FLASH_MODE_OFF);
-					mCamera.setParameters(parameters);
 				}
 			}
+
+			mCamera.setParameters(parameters);
 			mCamera.setDisplayOrientation(mQuality.orientation);
-			mCamera.unlock();
-			
-			mMediaRecorder.setCamera(mCamera);
-			mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
-			mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
-			
-			if (mode==MODE_DEFAULT) {
-				mMediaRecorder.setMaxDuration(1000);
-				mMediaRecorder.setMaxFileSize(Integer.MAX_VALUE);
-			} else if (mModeDefaultWasUsed) {
-				// On some phones a RuntimeException might be thrown :/
-				try {
-					mMediaRecorder.setMaxDuration(0);
-					mMediaRecorder.setMaxFileSize(Integer.MAX_VALUE); 
-				} catch (RuntimeException e) {
-					Log.e(TAG,"setMaxDuration or setMaxFileSize failed !");
-				}
-			}
-			
-			mMediaRecorder.setVideoEncoder(mVideoEncoder);
-			mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
-			mMediaRecorder.setVideoSize(mQuality.resX,mQuality.resY);
-			mMediaRecorder.setVideoFrameRate(mQuality.framerate);
-			mMediaRecorder.setVideoEncodingBitRate(mQuality.bitrate);
+			mCamera.setPreviewDisplay(mSurfaceHolder);
+
+			mCamera.startPreview();
+
+		}
+
+	}
 
-			super.prepare();
+	public synchronized void stopPreview() {
 
-			// Quality has been updated
-			mQualityHasChanged = false;
+		if (mStreaming) super.stop();
 
-		} catch (RuntimeException e) {
-			mCamera.release();
+		if (mCamera != null) {
+			lockCamera();
+			mCamera.stopPreview();
+			try {
+				mCamera.release();
+			} catch (Exception e) {
+				Log.e(TAG,e.getMessage()!=null?e.getMessage():"unknown error");
+			}
 			mCamera = null;
-			throw e;
+			mUnlocked = false;
+		}		
+	}
+
+	/**
+	 * Starts the stream.
+	 * This will also open the camera and dispay the preview if {@link #startPreview()}
+	 * has not laready been called.
+	 */
+	public synchronized void start() throws IllegalStateException, IOException {
+		super.start();
+	}
+
+	/**
+	 * Encoding of the audio/video is done by a MediaRecorder.
+	 */
+	protected void encodeWithMediaRecorder() throws IOException {
+
+		// We need a local socket to forward data output by the camera to the packetizer
+		createSockets();
+
+		// Opens the camera if needed
+		if (mCamera == null) {
+			mCameraOpenedManually = false;
+			// Will start the preview if not already started !
+			Log.d(TAG,"Preview must be started to record video !");
+			startPreview();
+		}
+
+		unlockCamera();
+	
+		mMediaRecorder = new MediaRecorder();
+		mMediaRecorder.setCamera(mCamera);
+		mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+		mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+		mMediaRecorder.setVideoEncoder(mVideoEncoder);
+		mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
+		mMediaRecorder.setVideoSize(mQuality.resX,mQuality.resY);
+		mMediaRecorder.setVideoFrameRate(mQuality.framerate);
+		mMediaRecorder.setVideoEncodingBitRate(mQuality.bitrate);
+
+		// We write the ouput of the camera in a local socket instead of a file !			
+		// This one little trick makes streaming feasible quiet simply: data from the camera
+		// can then be manipulated at the other end of the socket
+		mMediaRecorder.setOutputFile(mSender.getFileDescriptor());
+
+		mMediaRecorder.prepare();
+		mMediaRecorder.start();
+
+		try {
+			// mReceiver.getInputStream contains the data from the camera
+			// the mPacketizer encapsulates this stream in an RTP stream and send it over the network
+			mPacketizer.setDestination(mDestination, mRtpPort, mRtcpPort);
+			mPacketizer.setInputStream(mReceiver.getInputStream());
+			mPacketizer.start();
+			mStreaming = true;
 		} catch (IOException e) {
-			mCamera.release();
-			mCamera = null;
-			throw e;
+			stop();
+			throw new IOException("Something happened with the local sockets :/ Start failed !");
+		}
+
+	}
+
+	/**
+	 * Encoding of the audio/video is done by a MediaCodec.
+	 */
+	@SuppressLint({ "InlinedApi", "NewApi" })
+	protected void encodeWithMediaCodec() throws RuntimeException, IOException {
+
+		// Opens the camera if needed
+		if (mCamera == null) {
+			mCameraOpenedManually = false;
+			// Will start the preview if not already started !
+			startPreview();
+		}
+
+		mMediaCodec = MediaCodec.createEncoderByType("video/avc");
+		MediaFormat mediaFormat = MediaFormat.createVideoFormat("video/avc", mQuality.resX, mQuality.resY);
+		mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, mQuality.bitrate);
+		mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, mQuality.framerate);	
+		mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT,MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar);
+		mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 4);
+		mMediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+		mMediaCodec.start();
+
+		final ByteBuffer[] inputBuffers = mMediaCodec.getInputBuffers();
+
+		mCamera.setPreviewCallback(new Camera.PreviewCallback() {
+			@Override
+			public void onPreviewFrame(byte[] data, Camera camera) {
+				long now = System.nanoTime()/1000, timeout = 1000000/mQuality.framerate;
+				int bufferIndex = mMediaCodec.dequeueInputBuffer(timeout);
+
+				if (bufferIndex>=0) {
+					inputBuffers[bufferIndex].clear();
+					inputBuffers[bufferIndex].put(data, 0, data.length);
+					mMediaCodec.queueInputBuffer(bufferIndex, 0, data.length, System.nanoTime()/1000, 0);
+				} else {
+					Log.e(TAG,"No buffer available !");
+				}
+
+			}
+		});
+
+		try {
+			// mReceiver.getInputStream contains the data from the camera
+			// the mPacketizer encapsulates this stream in an RTP stream and send it over the network
+			mPacketizer.setDestination(mDestination, mRtpPort, mRtcpPort);
+			mPacketizer.setInputStream(new MediaCodecInputStream(mMediaCodec));
+			mPacketizer.start();
+			mStreaming = true;
+		} catch (IOException e) {
+			stop();
+			throw new IOException("Something happened with the local sockets :/ Start failed !");
 		}
 
 	}
 
 	public abstract String generateSessionDescription() throws IllegalStateException, IOException;
 
+	/** Verifies if streaming using the MediaCodec API is feasable. */
+	@SuppressLint("NewApi")
+	private void checkMediaCodecAPI() {
+		for(int j = MediaCodecList.getCodecCount() - 1; j >= 0; j--){
+			MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(j);
+			if (codecInfo.isEncoder()) {
+				MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType("video/avc");
+				for (int i = 0; i < capabilities.colorFormats.length; i++) {
+					int format = capabilities.colorFormats[i];
+					Log.e(TAG, codecInfo.getName()+" with color format " + format);           
+				}
+				/*for (int i = 0; i < capabilities.profileLevels; i++) {
+					int format = capabilities.colorFormats[i];
+					Log.e(TAG, codecInfo.getName()+" with color format " + format);           
+				}*/
+			}
+		}
+	}
+
 	/** 
-	 * Releases ressources associated with the {@link VideoStream}. 
-	 * The object can't be reused once this function has been called. 
+	 * Checks if the resolution and the framerate selected are supported by the camera.
+	 * If not, it modifies it by supported parameters. 
 	 **/
-	public void release() {
-		stop();
-		super.release();
+	private void getClosestSupportedQuality(Camera.Parameters parameters) {
+
+		// Resolutions
+		String supportedSizesStr = "Supported resolutions: ";
+		List<Size> supportedSizes = parameters.getSupportedPreviewSizes();
+		for (Iterator<Size> it = supportedSizes.iterator(); it.hasNext();) {
+			Size size = it.next();
+			supportedSizesStr += size.width+"x"+size.height+(it.hasNext()?", ":"");
+		}
+		Log.v(TAG,supportedSizesStr);
+
+		// Frame rates
+		String supportedFrameRatesStr = "Supported frame rates: ";
+		List<Integer> supportedFrameRates = parameters.getSupportedPreviewFrameRates();
+		for (Iterator<Integer> it = supportedFrameRates.iterator(); it.hasNext();) {
+			supportedFrameRatesStr += it.next()+"fps"+(it.hasNext()?", ":"");
+		}
+		//Log.v(TAG,supportedFrameRatesStr);
+
+		int minDist = Integer.MAX_VALUE, newFps = mQuality.framerate;
+		if (!supportedFrameRates.contains(mQuality.framerate)) {
+			for (Iterator<Integer> it = supportedFrameRates.iterator(); it.hasNext();) {
+				int fps = it.next();
+				int dist = Math.abs(fps - mQuality.framerate);
+				if (dist<minDist) {
+					minDist = dist;
+					newFps = fps;
+				}
+			}
+			Log.v(TAG,"Frame rate modified: "+mQuality.framerate+"->"+newFps);
+			//mQuality.framerate = newFps;
+		}
+
+	}
+	
+	protected void lockCamera() {
+		if (mUnlocked) {
+			try {
+				mCamera.reconnect();
+			} catch (Exception e) {
+				Log.e(TAG,e.getMessage());
+			}
+			mUnlocked = false;
+		}
 	}
 
+	protected void unlockCamera() {
+		if (!mUnlocked) {
+			try {	
+				mCamera.unlock();
+			} catch (Exception e) {
+				Log.e(TAG,e.getMessage());
+			}
+			mUnlocked = true;
+		}
+	}
+	
 }