diff --git a/celt b/celt
index 8952c45ea54a5608cd61fe2e137e39d0c3b19853..b1e017f58d2bb319eb7bc3305048185a9c8fe9d9 160000
--- a/celt
+++ b/celt
@@ -1 +1 @@
-Subproject commit 8952c45ea54a5608cd61fe2e137e39d0c3b19853
+Subproject commit b1e017f58d2bb319eb7bc3305048185a9c8fe9d9
diff --git a/src/hybrid.h b/src/hybrid.h
index 94d9f063d54e3e8609a9dc269fa0b62f1a09bae0..ae1566dab0ae619ff68f147af27c0b229098ee4d 100644
--- a/src/hybrid.h
+++ b/src/hybrid.h
@@ -76,7 +76,7 @@ extern "C" {
 typedef struct HybridEncoder HybridEncoder;
 typedef struct HybridDecoder HybridDecoder;
 
-HybridEncoder *hybrid_encoder_create();
+HybridEncoder *hybrid_encoder_create(int Fs);
 
 int hybrid_encode(HybridEncoder *st, const short *pcm, int frame_size,
 		unsigned char *data, int bytes_per_packet);
@@ -85,7 +85,7 @@ void hybrid_encoder_destroy(HybridEncoder *st);
 
 void hybrid_encoder_ctl(HybridEncoder *st, int request, ...);
 
-HybridDecoder *hybrid_decoder_create();
+HybridDecoder *hybrid_decoder_create(int Fs);
 
 int hybrid_decode(HybridDecoder *st, const unsigned char *data, int len,
 		short *pcm, int frame_size);
diff --git a/src/hybrid_decoder.c b/src/hybrid_decoder.c
index 2d258a449799b0ddfb15b9459b1be4cb0d642763..8eab5c907cd96047d8b70f694691776bc4601608 100644
--- a/src/hybrid_decoder.c
+++ b/src/hybrid_decoder.c
@@ -42,13 +42,15 @@
 #include "SKP_Silk_SDK_API.h"
 
 
-HybridDecoder *hybrid_decoder_create()
+HybridDecoder *hybrid_decoder_create(int Fs)
 {
 	int ret, decSizeBytes;
 	HybridDecoder *st;
 
 	st = malloc(sizeof(HybridDecoder));
 
+	st->Fs = Fs;
+
 	/* Initialize SILK encoder */
     ret = SKP_Silk_SDK_Get_Decoder_Size( &decSizeBytes );
     if( ret ) {
@@ -63,7 +65,7 @@ HybridDecoder *hybrid_decoder_create()
     }
 
 	/* We should not have to create a CELT mode for each encoder state */
-	st->celt_mode = celt_mode_create(48000, 960, NULL);
+	st->celt_mode = celt_mode_create(Fs, Fs/50, NULL);
 	/* Initialize CELT encoder */
 	st->celt_dec = celt_decoder_create(st->celt_mode, 1, NULL);
 
@@ -85,7 +87,7 @@ int hybrid_decode(HybridDecoder *st, const unsigned char *data,
 
     if (st->mode != MODE_CELT_ONLY)
     {
-        DecControl.API_sampleRate = 48000;
+        DecControl.API_sampleRate = st->Fs;
         /* Call SILK encoder for the low band */
         silk_ret = SKP_Silk_SDK_Decode( st->silk_dec, &DecControl, 0, &dec, len, pcm, &silk_frame_size );
         if (silk_ret)
diff --git a/src/hybrid_decoder.h b/src/hybrid_decoder.h
index eeeb0eea2df829e6254d9379b6676c2a55bf430a..b5a54fb58ee068ed9638635e31ba6736398a64b1 100644
--- a/src/hybrid_decoder.h
+++ b/src/hybrid_decoder.h
@@ -42,6 +42,8 @@ struct HybridDecoder {
 
     int          mode;
     int          bandwidth;
+    /* Sampling rate (at the API level) */
+    int          Fs;
 };
 
 
diff --git a/src/hybrid_encoder.c b/src/hybrid_encoder.c
index b2222c16ea5a8a387ae5a22479240fbaff731e96..413f08b226dbe2d4358264e73b7fe4d45ee1f4c8 100644
--- a/src/hybrid_encoder.c
+++ b/src/hybrid_encoder.c
@@ -41,7 +41,7 @@
 #include "modes.h"
 #include "SKP_Silk_SDK_API.h"
 
-HybridEncoder *hybrid_encoder_create()
+HybridEncoder *hybrid_encoder_create(int Fs)
 {
 	HybridEncoder *st;
 	int ret, encSizeBytes;
@@ -59,10 +59,13 @@ HybridEncoder *hybrid_encoder_create()
     if( ret ) {
         /* Handle error */
     }
+
+    st->Fs = Fs;
+
     /* Set Encoder parameters */
-    st->encControl.API_sampleRate        = 48000;
+    st->encControl.API_sampleRate        = Fs;
     st->encControl.maxInternalSampleRate = 16000;
-    st->encControl.packetSize            = 960;
+    st->encControl.packetSize            = Fs/50;
     st->encControl.packetLossPercentage  = 0;
     st->encControl.useInBandFEC          = 0;
     st->encControl.useDTX                = 0;
@@ -71,7 +74,7 @@ HybridEncoder *hybrid_encoder_create()
 
     /* Create CELT encoder */
 	/* We should not have to create a CELT mode for each encoder state */
-	st->celt_mode = celt_mode_create(48000, 960, NULL);
+	st->celt_mode = celt_mode_create(Fs, Fs/50, NULL);
 	/* Initialize CELT encoder */
 	st->celt_enc = celt_encoder_create(st->celt_mode, 1, NULL);
 
@@ -97,6 +100,8 @@ int hybrid_encode(HybridEncoder *st, const short *pcm, int frame_size,
 	if (st->mode != MODE_CELT_ONLY)
 	{
 	    st->encControl.bitRate = (bytes_per_packet*50*8+6000)/2;
+	    if (st->Fs / frame_size == 100)
+	        st->encControl.bitRate += 5000;
 	    st->encControl.packetSize = frame_size;
 	    /* Call SILK encoder for the low band */
 	    nBytes = bytes_per_packet;
@@ -127,7 +132,6 @@ int hybrid_encode(HybridEncoder *st, const short *pcm, int frame_size,
 
         celt_encoder_ctl(st->celt_enc, CELT_SET_PREDICTION(1));
 	    /* Encode high band with CELT */
-	    /* FIXME: Do some delay compensation here */
 	    ret = celt_encode_with_ec(st->celt_enc, buf, NULL, frame_size, data, bytes_per_packet, &enc);
 	    for (i=0;i<ENCODER_DELAY_COMPENSATION;i++)
 	        st->delay_buffer[i] = pcm[frame_size-ENCODER_DELAY_COMPENSATION+i];
diff --git a/src/hybrid_encoder.h b/src/hybrid_encoder.h
index 0d834a541eb8a951d14287d1a442213b6be6b4ae..6e4c62a8cf31e776a65556fb7b07bbb0e880aadb 100644
--- a/src/hybrid_encoder.h
+++ b/src/hybrid_encoder.h
@@ -48,6 +48,8 @@ struct HybridEncoder {
     int          mode;
 	int          bandwidth;
     int          vbr_rate;
+    /* Sampling rate (at the API level) */
+    int          Fs;
 
     short        delay_buffer[ENCODER_DELAY_COMPENSATION];
 };
diff --git a/src/test_hybrid.c b/src/test_hybrid.c
index 06ae843872e680e2179f22d93f9d0cf0fd5b73cf..9a5af094b2d591878a4ea7992e3a51d9b1a67494 100644
--- a/src/test_hybrid.c
+++ b/src/test_hybrid.c
@@ -94,8 +94,8 @@ int main(int argc, char *argv[])
       return 1;
    }
 
-   enc = hybrid_encoder_create();
-   dec = hybrid_decoder_create();
+   enc = hybrid_encoder_create(rate);
+   dec = hybrid_decoder_create(rate);
 
    mode = MODE_HYBRID;
    hybrid_encoder_ctl(enc, HYBRID_SET_BANDWIDTH(BANDWIDTH_FULLBAND));