Fixes a hybrid stereo encoder issue
[opus.git] / src / opus_encoder.c
index 3762a1e..ee78a6e 100644 (file)
@@ -69,6 +69,7 @@ struct OpusEncoder {
     int          vbr_constraint;
     opus_int32   bitrate_bps;
     opus_int32   user_bitrate_bps;
+    int          lsb_depth;
     int          encoder_buffer;
 
 #define OPUS_ENCODER_RESET_START stream_channels
@@ -88,6 +89,7 @@ struct OpusEncoder {
     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
 #ifndef FIXED_POINT
     TonalityAnalysisState analysis;
+    int                   detected_bandwidth;
 #endif
     opus_uint32  rangeFinal;
 };
@@ -210,6 +212,7 @@ int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int applicat
     st->user_forced_mode = OPUS_AUTO;
     st->voice_ratio = -1;
     st->encoder_buffer = st->Fs/100;
+    st->lsb_depth = 24;
 
     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead 
        + 1.5 ms for SILK resamplers and stereo prediction) */
@@ -401,7 +404,7 @@ static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *ou
    int c, i;
    float coef;
 
-   coef = 4.*cutoff_Hz/Fs;
+   coef = 4.0f*cutoff_Hz/Fs;
    for (c=0;c<channels;c++)
    {
       for (i=0;i<len;i++)
@@ -458,22 +461,37 @@ static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus
     int i;
     int inc;
     int overlap;
+    int c;
     inc = 48000/Fs;
     overlap=overlap48/inc;
-    for (i=0;i<overlap;i++)
+    if (channels==1)
     {
-       opus_val16 g, w;
-       w = MULT16_16_Q15(window[i*inc], window[i*inc]);
-       g = SHR32(MAC16_16(MULT16_16(w,g2),
-             Q15ONE-w, g1), 15);
-       out[i*channels] = MULT16_16_Q15(g, in[i*channels]);
-       out[i*channels+1] = MULT16_16_Q15(g, in[i*channels+1]);
+       for (i=0;i<overlap;i++)
+       {
+          opus_val16 g, w;
+          w = MULT16_16_Q15(window[i*inc], window[i*inc]);
+          g = SHR32(MAC16_16(MULT16_16(w,g2),
+                Q15ONE-w, g1), 15);
+          out[i] = MULT16_16_Q15(g, in[i]);
+       }
+    } else {
+       for (i=0;i<overlap;i++)
+       {
+          opus_val16 g, w;
+          w = MULT16_16_Q15(window[i*inc], window[i*inc]);
+          g = SHR32(MAC16_16(MULT16_16(w,g2),
+                Q15ONE-w, g1), 15);
+          out[i*2] = MULT16_16_Q15(g, in[i*2]);
+          out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
+       }
     }
-    for (;i<frame_size;i++)
-    {
-       out[i*channels] = MULT16_16_Q15(g2, in[i*channels]);
-       out[i*channels+1] = MULT16_16_Q15(g2, in[i*channels+1]);
+    c=0;do {
+       for (i=overlap;i<frame_size;i++)
+       {
+          out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
+       }
     }
+    while (++c<channels);
 }
 
 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
@@ -517,15 +535,8 @@ static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int m
     return st->user_bitrate_bps;
 }
 
-#ifdef FIXED_POINT
-#define opus_encode_native opus_encode
-opus_int32 opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
-                unsigned char *data, opus_int32 out_data_bytes)
-#else
-#define opus_encode_native opus_encode_float
-opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
-                      unsigned char *data, opus_int32 out_data_bytes)
-#endif
+opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
+                unsigned char *data, opus_int32 out_data_bytes, int lsb_depth)
 {
     void *silk_enc;
     CELTEncoder *celt_enc;
@@ -578,6 +589,8 @@ opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_s
     silk_enc = (char*)st+st->silk_enc_offset;
     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
 
+    lsb_depth = IMIN(lsb_depth, st->lsb_depth);
+
 #ifndef FIXED_POINT
     perform_analysis = st->silk_mode.complexity >= 7 && frame_size >= st->Fs/100 && st->Fs==48000;
 #endif
@@ -844,6 +857,13 @@ opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_s
         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
+#ifndef FIXED_POINT
+    if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
+    {
+       st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
+    }
+#endif
+    celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
 
     /* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
     if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)*frame_size / (st->Fs * 8))
@@ -890,7 +910,7 @@ opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_s
           /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
           if (to_celt && i==nb_frames-1)
              st->user_forced_mode = MODE_CELT_ONLY;
-          tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, tmp_data+i*bytes_per_frame, bytes_per_frame);
+          tmp_len = opus_encode_native(st, pcm+i*(st->channels*st->Fs/50), st->Fs/50, tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth);
           if (tmp_len<0)
           {
              RESTORE_STACK;
@@ -961,12 +981,14 @@ opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_s
        int nb_analysis_frames;
        nb_analysis_frames = frame_size/(st->Fs/100);
        for (i=0;i<nb_analysis_frames;i++)
-          tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm_buf+i*(st->Fs/100)*st->channels, st->channels);
+          tonality_analysis(&st->analysis, &analysis_info, celt_enc, pcm_buf+i*(st->Fs/100)*st->channels, st->channels, lsb_depth);
        if (st->signal_type == OPUS_AUTO)
-          st->voice_ratio = floor(.5+100*(1-analysis_info.music_prob));
+          st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
+       st->detected_bandwidth = analysis_info.opus_bandwidth;
     } else {
        analysis_info.valid = 0;
        st->voice_ratio = -1;
+       st->detected_bandwidth = 0;
     }
 #endif
 
@@ -1194,7 +1216,7 @@ opus_int32 opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_s
        const CELTMode *celt_mode;
 
        celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
-       gain_fade(pcm_buf, pcm_buf,
+       gain_fade(pcm_buf+extra_buffer*st->channels, pcm_buf+extra_buffer*st->channels,
              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
     }
     st->prev_HB_gain = HB_gain;
@@ -1408,12 +1430,18 @@ opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
 
    for (i=0;i<frame_size*st->channels;i++)
       in[i] = FLOAT2INT16(pcm[i]);
-   ret = opus_encode(st, in, frame_size, data, max_data_bytes);
+   ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
    RESTORE_STACK;
    return ret;
 }
 #endif
 
+opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
+                unsigned char *data, opus_int32 out_data_bytes)
+{
+   return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16);
+}
+
 #else
 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
       unsigned char *data, opus_int32 max_data_bytes)
@@ -1426,10 +1454,16 @@ opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
 
    for (i=0;i<frame_size*st->channels;i++)
       in[i] = (1.0f/32768)*pcm[i];
-   ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
+   ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16);
    RESTORE_STACK;
    return ret;
 }
+opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
+                      unsigned char *data, opus_int32 out_data_bytes)
+{
+   return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24);
+
+}
 #endif
 
 
@@ -1685,13 +1719,15 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
         case OPUS_SET_LSB_DEPTH_REQUEST:
         {
             opus_int32 value = va_arg(ap, opus_int32);
-            ret = celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(value));
+            if (value<8 || value>24)
+               goto bad_arg;
+            st->lsb_depth=value;
         }
         break;
         case OPUS_GET_LSB_DEPTH_REQUEST:
         {
             opus_int32 *value = va_arg(ap, opus_int32*);
-            celt_encoder_ctl(celt_enc, OPUS_GET_LSB_DEPTH(value));
+            *value = st->lsb_depth;
         }
         break;
         case OPUS_RESET_STATE: