Implements OPUS_RESET_STATE for the encoder (untested as well)
[opus.git] / src / opus_encoder.c
index e90472f..a2b3f1e 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited
+/* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
    Written by Jean-Marc Valin and Koen Vos */
 /*
    Redistribution and use in source and binary forms, with or without
@@ -29,9 +29,6 @@
 #include "config.h"
 #endif
 
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <stdarg.h>
 #include "celt.h"
 #include "entenc.h"
@@ -41,6 +38,8 @@
 #include "float_cast.h"
 #include "opus.h"
 #include "arch.h"
+#include "opus_private.h"
+#include "os_support.h"
 
 #ifdef FIXED_POINT
 #define celt_encode_native celt_encode
@@ -54,26 +53,27 @@ struct OpusEncoder {
     int          celt_enc_offset;
     int          silk_enc_offset;
     silk_EncControlStruct silk_mode;
-    int          hybrid_stereo_width_Q14;
+    int          application;
     int          channels;
-    int          stream_channels;
+    int          delay_compensation;
     int          force_mono;
-
-    int          mode;
-    int          application;
-    int          prev_mode;
     int          signal_type;
-    int          bandwidth;
     int          user_bandwidth;
     int          voice_ratio;
-    /* Sampling rate (at the API level) */
     int          Fs;
     int          use_vbr;
     int          vbr_constraint;
     int          bitrate_bps;
     int          user_bitrate_bps;
     int          encoder_buffer;
-    int          delay_compensation;
+
+#define OPUS_ENCODER_RESET_START stream_channels
+    int          stream_channels;
+    int          hybrid_stereo_width_Q14;
+    int          mode;
+    int          prev_mode;
+    int          bandwidth;
+    /* Sampling rate (at the API level) */
     int          first;
     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
 
@@ -84,57 +84,51 @@ struct OpusEncoder {
    middle (memoriless) threshold. The second column is the hysteresis
    (difference with the middle) */
 static const int voice_bandwidth_thresholds[10] = {
-               11000, 1000, /* NB<->MB */
-               14000, 1000, /* MB<->WB */
-               21000, 2000, /* WB<->SWB */
-               29000, 2000, /* SWB<->FB */
+        11000, 1000, /* NB<->MB */
+        14000, 1000, /* MB<->WB */
+        21000, 2000, /* WB<->SWB */
+        29000, 2000, /* SWB<->FB */
 };
 static const int audio_bandwidth_thresholds[10] = {
-               30000,    0, /* MB not allowed */
-               20000, 2000, /* MB<->WB */
-               26000, 2000, /* WB<->SWB */
-               33000, 2000, /* SWB<->FB */
+        30000,    0, /* MB not allowed */
+        20000, 2000, /* MB<->WB */
+        26000, 2000, /* WB<->SWB */
+        33000, 2000, /* SWB<->FB */
 };
 
-/* Make sure everything's aligned to 4 bytes (this may need to be increased
-   on really weird architectures) */
-static inline int align(int i)
-{
-    return (i+3)&-4;
-}
 
 int opus_encoder_get_size(int channels)
 {
     int silkEncSizeBytes, celtEncSizeBytes;
     int ret;
     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
-    if(ret)
+    if (ret)
         return 0;
     silkEncSizeBytes = align(silkEncSizeBytes);
     celtEncSizeBytes = celt_encoder_get_size(channels);
     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
 }
 
-OpusEncoder *opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
+int opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
 {
     void *silk_enc;
     CELTEncoder *celt_enc;
     int err;
     int ret, silkEncSizeBytes;
 
-    if (channels > 2 || channels<1)
-        return NULL;
+    if (channels > 2 || channels < 1)
+        return OPUS_BAD_ARG;
     if (application < OPUS_APPLICATION_VOIP || application > OPUS_APPLICATION_AUDIO)
-        return NULL;
+        return OPUS_BAD_ARG;
     if (Fs != 8000 && Fs != 12000 && Fs != 16000 && Fs != 24000 && Fs != 48000)
-        return NULL;
+        return OPUS_BAD_ARG;
 
-    memset(st, 0, opus_encoder_get_size(channels));
+    OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
     /* Create SILK encoder */
     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
-    if( ret )
-       return NULL;
-       silkEncSizeBytes = align(silkEncSizeBytes);
+    if (ret)
+        return OPUS_BAD_ARG;
+    silkEncSizeBytes = align(silkEncSizeBytes);
     st->silk_enc_offset = align(sizeof(OpusEncoder));
     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
     silk_enc = (char*)st+st->silk_enc_offset;
@@ -145,7 +139,7 @@ OpusEncoder *opus_encoder_init(OpusEncoder* st, int Fs, int channels, int applic
     st->Fs = Fs;
 
     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
-    if( ret )
+    if (ret)
         goto failure;
 
     /* default SILK parameters */
@@ -164,17 +158,13 @@ OpusEncoder *opus_encoder_init(OpusEncoder* st, int Fs, int channels, int applic
     st->silk_mode.useCBR                    = 0;
     st->silk_mode.HP_cutoff_Hz              = 0;
 
-    st->hybrid_stereo_width_Q14             = 1 << 14;
-
     /* Create CELT encoder */
     /* Initialize CELT encoder */
     celt_encoder_init(celt_enc, Fs, channels, &err);
     if (err != CELT_OK)
-               goto failure;
+        goto failure;
     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
 
-    st->mode = MODE_HYBRID;
-    st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
     st->use_vbr = 0;
     st->user_bitrate_bps = OPUS_BITRATE_AUTO;
     st->bitrate_bps = 3000+Fs*channels;
@@ -182,20 +172,31 @@ OpusEncoder *opus_encoder_init(OpusEncoder* st, int Fs, int channels, int applic
     st->signal_type = OPUS_SIGNAL_AUTO;
     st->user_bandwidth = OPUS_BANDWIDTH_AUTO;
     st->voice_ratio = 90;
-    st->first = 1;
-
     st->encoder_buffer = st->Fs/100;
+
     st->delay_compensation = st->Fs/400;
-    if (st->Fs > 16000)
-        st->delay_compensation += 10;
-    return st;
+    /* This part is meant to compensate for the resampler delay as a function
+       of the API sampling rate */
+    if (st->Fs == 48000)
+        st->delay_compensation += 23;
+    else if (st->Fs == 24000)
+       st->delay_compensation += 15;
+    else
+       st->delay_compensation += 2;
+
+    st->hybrid_stereo_width_Q14             = 1 << 14;
+    st->first = 1;
+    st->mode = MODE_HYBRID;
+    st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
+
+    return OPUS_OK;
 
 failure:
-    free(st);
-    return NULL;
+    opus_free(st);
+    return OPUS_INTERNAL_ERROR;
 }
 
-static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
+static unsigned char gen_toc(int mode, int framerate, int bandwidth, int silk_bandwidth, int channels)
 {
    int period;
    unsigned char toc;
@@ -207,7 +208,7 @@ static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channel
    }
    if (mode == MODE_SILK_ONLY)
    {
-       toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
+       toc = (silk_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
        toc |= (period-2)<<3;
    } else if (mode == MODE_CELT_ONLY)
    {
@@ -226,19 +227,32 @@ static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channel
    toc |= (channels==2)<<2;
    return toc;
 }
-OpusEncoder *opus_encoder_create(int Fs, int channels, int mode)
+OpusEncoder *opus_encoder_create(int Fs, int channels, int mode, int *error)
 {
-    char *raw_state = (char *)malloc(opus_encoder_get_size(channels));
-    if (raw_state == NULL)
-       return NULL;
-    return opus_encoder_init((OpusEncoder*)raw_state, Fs, channels, mode);
+   int ret;
+   OpusEncoder *st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
+   if (st == NULL)
+   {
+      if (error)
+         *error = OPUS_ALLOC_FAIL;
+      return NULL;
+   }
+   ret = opus_encoder_init(st, Fs, channels, mode);
+   if (error)
+      *error = ret;
+   if (ret != OPUS_OK)
+   {
+      opus_free(st);
+      st = NULL;
+   }
+   return st;
 }
 #ifdef FIXED_POINT
 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
-               unsigned char *data, int max_data_bytes)
+                unsigned char *data, int max_data_bytes)
 #else
 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
-      unsigned char *data, int max_data_bytes)
+                      unsigned char *data, int max_data_bytes)
 #endif
 {
     void *silk_enc;
@@ -264,7 +278,10 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
     st->rangeFinal = 0;
     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
-        return OPUS_BAD_ARG;
+    {
+       RESTORE_STACK;
+       return OPUS_BAD_ARG;
+    }
     silk_enc = (char*)st+st->silk_enc_offset;
     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
 
@@ -324,7 +341,10 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
     /* Mode selection depending on application and signal type */
     if (st->application==OPUS_APPLICATION_VOIP)
     {
-        opus_int32 threshold = 20000;
+        opus_int32 threshold;
+        threshold = 20000;
+        /* OPUS_APPLICATION_VOIP default to auto high-pass */
+        st->silk_mode.HP_cutoff_Hz=0;
         /* Hysteresis */
         if (st->prev_mode == MODE_CELT_ONLY)
             threshold -= 4000;
@@ -340,6 +360,8 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
         opus_int32 threshold;
         /* SILK/CELT threshold is higher for voice than for music */
         threshold = 36000;
+        /* OPUS_APPLICATION_AUDIO disables the high-pass */
+        st->silk_mode.HP_cutoff_Hz=-1;
         if (st->signal_type == OPUS_SIGNAL_MUSIC)
             threshold -= 20000;
         else if (st->signal_type == OPUS_SIGNAL_VOICE)
@@ -515,7 +537,7 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
             pcm_silk = st->delay_buffer;
 #else
             for (i=0;i<st->encoder_buffer*st->channels;i++)
-               pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
+                pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
 #endif
             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
         }
@@ -524,16 +546,18 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
         pcm_silk = pcm;
 #else
         for (i=0;i<frame_size*st->channels;i++)
-           pcm_silk[i] = FLOAT2INT16(pcm[i]);
+            pcm_silk[i] = FLOAT2INT16(pcm[i]);
 #endif
         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
         if( ret ) {
-            fprintf (stderr, "SILK encode error: %d\n", ret);
+            /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
             /* Handle error */
+           return OPUS_INTERNAL_ERROR;
         }
         if (nBytes==0)
         {
-           data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
+           data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
+           RESTORE_STACK;
            return 1;
         }
         /* Extract SILK internal bandwidth for signaling in first byte */
@@ -560,9 +584,9 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
                 endband = 13;
                 break;
             case OPUS_BANDWIDTH_MEDIUMBAND:
-           case OPUS_BANDWIDTH_WIDEBAND:
-               endband = 17;
-               break;
+            case OPUS_BANDWIDTH_WIDEBAND:
+                endband = 17;
+                break;
             case OPUS_BANDWIDTH_SUPERWIDEBAND:
                 endband = 19;
                 break;
@@ -657,7 +681,7 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
             ec_enc_bit_logp(&enc, celt_to_silk, 1);
             if (st->mode == MODE_HYBRID)
-               ec_enc_uint(&enc, redundancy_bytes-2, 256);
+                ec_enc_uint(&enc, redundancy_bytes-2, 256);
         }
         start_band = 17;
     }
@@ -719,19 +743,19 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
 
     if (frame_size>st->encoder_buffer)
     {
-       for (i=0;i<st->encoder_buffer*st->channels;i++)
-               st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
+        for (i=0;i<st->encoder_buffer*st->channels;i++)
+            st->delay_buffer[i] = pcm[(frame_size-st->encoder_buffer)*st->channels+i];
     } else {
-       int tmp = st->encoder_buffer-frame_size;
-       for (i=0;i<tmp*st->channels;i++)
+        int tmp = st->encoder_buffer-frame_size;
+        for (i=0;i<tmp*st->channels;i++)
             st->delay_buffer[i] = st->delay_buffer[i+frame_size*st->channels];
-       for (i=0;i<frame_size*st->channels;i++)
+        for (i=0;i<frame_size*st->channels;i++)
             st->delay_buffer[tmp*st->channels+i] = pcm[i];
     }
 
     /* Signalling the mode in the first byte */
     data--;
-    data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, st->stream_channels);
+    data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
 
     st->rangeFinal = enc.rng ^ redundant_rng;
 
@@ -740,6 +764,7 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
     else
         st->prev_mode = st->mode;
     st->first = 0;
+    RESTORE_STACK;
     return ret+1+redundancy_bytes;
 }
 
@@ -784,9 +809,11 @@ int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
 
 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
 {
+    int ret;
     CELTEncoder *celt_enc;
     va_list ap;
 
+    ret = OPUS_OK;
     va_start(ap, request);
 
     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
@@ -795,19 +822,19 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
     {
         case OPUS_SET_APPLICATION_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->application = value;
         }
         break;
         case OPUS_GET_APPLICATION_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->mode;
         }
         break;
         case OPUS_SET_BITRATE_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             if (value != OPUS_BITRATE_AUTO)
             {
                 if (value <= 0)
@@ -820,27 +847,27 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
         break;
         case OPUS_GET_BITRATE_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->bitrate_bps;
         }
         break;
         case OPUS_SET_FORCE_MONO_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->force_mono = value;
         }
         break;
         case OPUS_GET_FORCE_MONO_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = !!st->force_mono;
         }
         break;
         case OPUS_SET_BANDWIDTH_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
-               return OPUS_BAD_ARG;
+                return OPUS_BAD_ARG;
             st->user_bandwidth = value;
             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
                 st->silk_mode.maxInternalSampleRate = 8000;
@@ -853,50 +880,50 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
         break;
         case OPUS_GET_BANDWIDTH_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->bandwidth;
         }
         break;
         case OPUS_SET_DTX_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->silk_mode.useDTX = value;
         }
         break;
         case OPUS_GET_DTX_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->silk_mode.useDTX;
         }
         break;
         case OPUS_SET_COMPLEXITY_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->silk_mode.complexity = value;
             celt_encoder_ctl(celt_enc, CELT_SET_COMPLEXITY(value));
         }
         break;
         case OPUS_GET_COMPLEXITY_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->silk_mode.complexity;
         }
         break;
-        case OPUS_SET_INBAND_FEC_FLAG_REQUEST:
+        case OPUS_SET_INBAND_FEC_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->silk_mode.useInBandFEC = value;
         }
         break;
-        case OPUS_GET_INBAND_FEC_FLAG_REQUEST:
+        case OPUS_GET_INBAND_FEC_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->silk_mode.useInBandFEC;
         }
         break;
         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             if (value < 0 || value > 100)
                 return OPUS_BAD_ARG;
             st->silk_mode.packetLossPercentage = value;
@@ -905,26 +932,26 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
         break;
         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->silk_mode.packetLossPercentage;
         }
         break;
         case OPUS_SET_VBR_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->use_vbr = value;
             st->silk_mode.useCBR = 1-value;
         }
         break;
         case OPUS_GET_VBR_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->use_vbr;
         }
         break;
         case OPUS_SET_VOICE_RATIO_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             if (value>100 || value<0)
                 goto bad_arg;
             st->voice_ratio = value;
@@ -932,37 +959,37 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
         break;
         case OPUS_GET_VOICE_RATIO_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->voice_ratio;
         }
         break;
         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->vbr_constraint = value;
         }
         break;
         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->vbr_constraint;
         }
         break;
         case OPUS_SET_SIGNAL_REQUEST:
         {
-               opus_int32 value = va_arg(ap, opus_int32);
+            opus_int32 value = va_arg(ap, opus_int32);
             st->signal_type = value;
         }
         break;
         case OPUS_GET_SIGNAL_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->signal_type;
         }
         break;
         case OPUS_GET_LOOKAHEAD_REQUEST:
         {
-               opus_int32 *value = va_arg(ap, opus_int32*);
+            opus_int32 *value = va_arg(ap, opus_int32*);
             *value = st->delay_compensation+st->Fs/400;
         }
         break;
@@ -972,12 +999,32 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
             *value = st->rangeFinal;
         }
         break;
+        case OPUS_RESET_STATE:
+        {
+           void *silk_enc;
+           silk_EncControlStruct dummy;
+           silk_enc = (char*)st+st->silk_enc_offset;
+
+           OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
+                 opus_encoder_get_size(st->channels)-
+                 ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
+
+           celt_encoder_ctl(celt_enc, CELT_RESET_STATE);
+           silk_InitEncoder( silk_enc, &dummy );
+           st->stream_channels = st->channels;
+           st->hybrid_stereo_width_Q14             = 1 << 14;
+           st->first = 1;
+           st->mode = MODE_HYBRID;
+           st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
+        }
+        break;
         default:
-            fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
+            /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
+            ret = OPUS_BAD_ARG;
             break;
     }
     va_end(ap);
-    return OPUS_OK;
+    return ret;
 bad_arg:
     va_end(ap);
     return OPUS_BAD_ARG;
@@ -985,5 +1032,5 @@ bad_arg:
 
 void opus_encoder_destroy(OpusEncoder *st)
 {
-    free(st);
+    opus_free(st);
 }